/* Aussehen der Oberflaeche.
 *
 * Die Farben und Abstaende stammen aus den Entwuerfen unter
 * web/entwuerfe und stehen hier an einer Stelle, damit ein neuer
 * Bildschirm nicht sein eigenes Dunkelgrau erfindet.
 *
 * Die Richtung hat der Besitzer an zwei Vorbildern festgemacht: die
 * Farben und die Schrift nach hubtown.co.in, die Fuehrung durch das
 * Haus nach horizonte-village.com. Dunkel bleibt die Voreinstellung,
 * weil die Oberflaeche auf Wandtafeln laeuft: ein weisses Bild
 * leuchtet nachts in den Flur.
 *
 * Die Schriften liegen daneben und werden mitgeliefert. Die Anlage
 * steht ohne Internet im Haus; eine Schrift von fremdem Server waere
 * dort schlicht nicht da - und ausserdem eine Spur, wer wann sein
 * Licht anschaut.
 */
@font-face {
  font-family: "Inter"; font-style: normal; font-weight: 100 900;
  font-display: swap; src: url("schriften/inter-latein.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+2000-206F,
                 U+2122, U+2191, U+2193, U+2212, U+25BE, U+25B8;
}
@font-face {
  font-family: "Inter"; font-style: normal; font-weight: 100 900;
  font-display: swap; src: url("schriften/inter-kyrillisch.woff2") format("woff2");
  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}
@font-face {
  font-family: "JetBrains Mono"; font-style: normal; font-weight: 100 800;
  font-display: swap; src: url("schriften/mono-latein.woff2") format("woff2");
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+2000-206F, U+2122, U+2212;
}
@font-face {
  font-family: "JetBrains Mono"; font-style: normal; font-weight: 100 800;
  font-display: swap; src: url("schriften/mono-kyrillisch.woff2") format("woff2");
  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
}

:root {
  /* Die Farben des Vorbildes. Die alten Namen bleiben bestehen und
     zeigen auf die neuen Werte, damit kein Bildschirm zwischen zwei
     Staenden haengt. */
  --grund: #020a19; --flaeche: #0c1524; --flaeche-hoch: #12203a;
  --bg: var(--grund); --panel: var(--flaeche); --panel-2: var(--flaeche-hoch);
  --linie: rgba(213, 224, 255, .10); --linie-stark: rgba(213, 224, 255, .26);
  --line: var(--linie);
  /* Die leiseste Schrift war zu leise: #6c7899 mass auf der hoechsten
     Flaeche (--flaeche-hoch) nur 3.70:1, auf der Karte 4.17:1 - unter
     dem Schwellwert 4.5:1 fuer Fliesstext. Sie traegt keine
     Nebensachen: unter ihr stehen Messwerte, Adressen und die Zahl der
     Ebene. #7f8bad misst auf allen drei Flaechen mindestens 4.79:1 und
     bleibt deutlich unter --text-leise (mindestens 6.29:1), damit die
     drei Stufen drei Stufen bleiben. */
  --text: #d5e0ff; --text-leise: #93a1c4; --text-still: #7f8bad;
  --muted: var(--text-leise);
  /* #052261 traegt als Flaeche, als Schrift auf #020a19 ist es unlesbar:
     deshalb zwei Namen statt eines. */
  --akzent: #8fb0ff; --akzent-flaeche: #052261; --accent: var(--akzent);

  /* "An" ist das einzige Warme im ganzen Bild. Das ist Absicht: in einem
     kalten, fast einfarbigen Haus faellt ein brennendes Licht dadurch von
     weitem auf, auch schraeg auf die Wandtafel gesehen. */
  --an: #f5c451; --an-flaeche: rgba(245, 196, 81, .14);
  --an-linie: rgba(245, 196, 81, .55);
  /* Eigene Schrift fuer den Punkt auf dem Plan: er liegt auf einem Foto
     unbekannter Helligkeit, nicht auf der Flaeche des Hauses, und braucht
     deshalb einen Ton, der auf dem eigenen dunklen Schild lesbar bleibt -
     in beiden Erscheinungen des Hauses derselbe (siehe hell weiter unten). */
  --an-punkt: #f5c451;

  --gut: #58d39a; --ok: var(--gut);
  --warn: #e3a94b;
  --fehler: #ff6b5e; --fehler-flaeche: rgba(255, 107, 94, .12);
  --err: var(--fehler);

  /* Wie --an-punkt: eigene Schrifttoene fuer Schilder mit fest dunklem
     Grund (der Punkt auf dem Plan, die Tuer, die Statuszeile). --text,
     --muted, --akzent und --warn sind fuer die Flaeche des Hauses
     gedacht und wechseln mit der Erscheinung; auf einem Schild, das immer
     dunkel bleibt, braucht es stattdessen einen Ton, der dort in beiden
     Erscheinungen lesbar ist - hier derselbe wie in der dunklen Erscheinung
     ohnehin schon (siehe hell weiter unten fuer die Rechnung). */
  --punkt-text: #d5e0ff;
  --punkt-muted: #93a1c4;
  --punkt-akzent: #8fb0ff;
  --punkt-warn: #e3a94b;
  --band-err: #ff6b5e;
  --band-ok: #58d39a;
  /* Die Platte unter dem Plan: wie der Plan selbst immer dunkel. */
  --platte-grund: #0b1733; --platte-rand: rgba(213, 224, 255, .26);

  --raum-1: 4px;  --raum-2: 8px;  --raum-3: 12px; --raum-4: 16px;
  --raum-5: 24px; --raum-6: 32px; --raum-7: 48px; --raum-8: 64px;

  --schrift-marke: 11px;
  --schrift-xs: 12px; --schrift-s: 13px; --schrift-m: 15px;
  --schrift-l: 17px;  --schrift-xl: 20px; --schrift-xxl: 26px;

  --rund-s: 10px; --rund-m: 14px; --rund-l: 20px; --rund-voll: 999px;

  /* Anfassgroessen. 44px ist der Richtwert fuer den Finger, 56px fuer die
     Wandtafel, an der man steht und nicht zielt. */
  --griff: 44px; --griff-gross: 56px;
  /* Der sichtbare Kreis eines Punktes auf dem Plan. Klein, damit er die
     Zeichnung nicht zudeckt; angefasst wird er ueber die volle Griffbreite
     (das unsichtbare Pseudoelement um den Kreis). */
  --punkt-kreis: 16px;

  --zeit-antwort: 120ms; --zeit-wechsel: 220ms; --zeit-auftritt: 380ms;
  --kurve: cubic-bezier(.2, .7, .2, 1);
  /* Das Haus in 3D, nach den Vorbildern (Spezifikation, Teil "Bewegung"):
     "expo-out" fuer alles Weite, eine Feder mit etwa 4 % Ueberschwingen nur
     fuer die gewaehlte Platte. Dieselben Zahlen stehen in haus.js. */
  --kurve-weit: cubic-bezier(0.16, 1, 0.3, 1);
  --kurve-pruzhina: cubic-bezier(0.34, 1.4, 0.64, 1);
  --zeit-nah: 600ms; --zeit-heraus: 500ms; --zeit-weg: 400ms; --zeit-blende: 200ms;

  --schrift-text: "Inter", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
  --schrift-zahl: "JetBrains Mono", ui-monospace, Consolas, monospace;
}

/* Der helle Stand fuer den Tag: dieselbe Gestaltung, umgekehrte
   Helligkeit - kein zweiter Entwurf. Der Besitzer bedient auch draussen
   am Telefon, und dort ist Dunkel auf Dunkel nicht zu lesen. */
:root[data-thema="hell"] {
  --grund: #eef1f9; --flaeche: #ffffff; --flaeche-hoch: #f4f6fd;
  --linie: rgba(2, 10, 25, .12); --linie-stark: rgba(2, 10, 25, .30);
  /* Im hellen Stand war es schlimmer: #838aa0 mass zwischen 3.04:1
     und 3.44:1. #646b81 misst mindestens 4.69:1 und bleibt unter
     --text-leise (mindestens 5.69:1). */
  --text: #020a19; --text-leise: #59617a; --text-still: #646b81;
  --akzent: #052261; --akzent-flaeche: #dbe4ff;
  --an: #8a5a00; --an-flaeche: #fdf1d4; --an-linie: #d8a52a;
  /* Dasselbe Schild-Amber wie im dunklen Stand: das Schild des Punktes
     bleibt dunkel (siehe .plan .punkt), und #8a5a00 waere darauf fast
     unlesbar (Kontrast ~3:1). #f5c451 auf demselben Schild misst ~11:1. */
  --an-punkt: #f5c451;
  --gut: #17734a; --warn: #8a5a00; --fehler: #a4231b;
  --fehler-flaeche: rgba(164, 35, 27, .10);
  /* Dieselben Schild-Toene wie im dunklen Stand, aus demselben Grund wie
     --an-punkt: --muted (#59617a), --akzent (#052261) und --warn (#8a5a00)
     der hellen Erscheinung sind fuer helle Flaechen gedacht und massen auf
     dem dunklen Schild nur ~3:1 (siehe test_schild_kontrast_erreicht_wcag_aa). */
  --punkt-text: #d5e0ff;
  --punkt-muted: #93a1c4;
  --punkt-akzent: #8fb0ff;
  --punkt-warn: #e3a94b;
  --band-err: #ff6b5e;
  --band-ok: #58d39a;
}

* { box-sizing: border-box; }
/* EIN Ring fuer alles, was den Fokus bekommen kann - Knoepfe, Felder,
   Listen, Verweise, und jedes Ding, das spaeter dazukommt.
   Vorher stand der Ring an einem knappen Dutzend einzelner Stellen, und
   ueberall sonst - auf jedem .knopf, auf jedem Weg in der Kopfzeile, in
   jedem Formular - war beim Tabben nichts zu sehen. Wer mit der Tastatur
   arbeitet, wusste nicht, wo er steht; auf der Wandtafel im Flur ist die
   Tastatur ausserdem die einzige Bedienung, die ohne Maus auskommt.

   :focus-visible und nicht :focus: der Browser entscheidet damit selbst,
   ob der Fokus von der Tastatur kommt. Ein Ring nach jedem Mausklick
   waere Laerm, und Laerm wird weggestellt.

   Wer einen anderen Abstand braucht - innen liegend, weiter aussen -,
   schreibt ihn weiterhin bei sich selbst hin; diese Regel steht ganz
   oben und weicht jeder spaeteren. */
:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; }
body {
  margin: 0; font-family: var(--schrift-text);
  -webkit-font-smoothing: antialiased;
  background: var(--bg); color: var(--text);
}
main { max-width: 920px; margin: 0 auto; padding: 24px 16px 64px; }
h1 { font-size: 22px; margin: 0 0 4px; }
.unterzeile { color: var(--muted); font-size: 14px; margin-bottom: 16px; }
.verborgen { display: none !important; }
/* Ein Haken muss den Finger treffen, auch an der Tafel an der Wand: 24
   statt der 13 des Browsers. Das Tippen nimmt die Zeile darum an, die so
   hoch ist wie ein Griff (Aufgabe 5.6.1). */
input[type="checkbox"] { width: 24px; height: 24px; margin: 0; flex: none;
  accent-color: var(--akzent); }
/* Optisch versteckt, aber im Dokument: anders als .verborgen (display:
 * none) bleibt dieses Element im Tastaturweg und fuer Vorleseprogramme
 * erreichbar - fuer natives Steuerelemente wie <input type=file>, deren
 * eigener Text sich nicht uebersetzen laesst und die deshalb hinter einem
 * eigenen, uebersetzten Knopf verschwinden. */
.nur-fuer-vorleser {
  position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0;
  overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0;
}

/* Die Kopfzeile ist eine einzige Zeile - auch am Telefon. Sie brach dort
   auf vier Reihen um und frass das halbe Bild (Besitzer, 23.09.2026).
   position: relative traegt das Menue, das unter dem Zeichen ausfaehrt. */
header.nav {
  display: flex; align-items: center; gap: 4px; padding: 10px 16px;
  background: var(--panel); border-bottom: 1px solid var(--line);
  flex-wrap: nowrap; position: relative; z-index: 30;
}
/* Die Leiste der Wege rollt, statt umzubrechen. min-width: 0 ist noetig,
   damit sie im Flex ueberhaupt schmaler werden darf als ihr Inhalt;
   position: relative macht sie zum Bezug fuer offsetLeft in wegSichtbar. */
header.nav .wege {
  display: flex; align-items: center; gap: 4px; flex-wrap: nowrap;
  flex: 1 1 auto; min-width: 0; position: relative;
  overflow-x: auto; overflow-y: hidden; scroll-behavior: smooth;
  scrollbar-width: none; -webkit-overflow-scrolling: touch;
}
/* Ein Rollbalken quer durch die Kopfzeile waere Laerm: gerollt wird mit
   dem Finger, und wegSichtbar sorgt fuer den Rest. */
header.nav .wege::-webkit-scrollbar { display: none; }
header.nav button.weg {
  font-family: inherit; font-size: 14px; padding: 8px 12px; border-radius: 6px;
  border: 0; background: transparent; color: var(--muted); cursor: pointer;
  flex: none; white-space: nowrap;
  /* Das eigene Mass dieses Hauses: --griff ist 44px, und ein Weg war
     rund 33px hoch. Auf der Wandtafel im Flur wird mit dem Finger
     bedient, und ein danebengegriffener Weg fuehrt auf einen fremden
     Bildschirm - das ist teurer als ein Knopf, der nicht reagiert. */
  min-height: var(--griff);
}
header.nav button.weg.aktiv { background: var(--panel-2); color: var(--text); font-weight: 600; }
header.nav .rechts { margin-left: auto; display: flex; align-items: center; gap: 8px;
  flex: none; }
header.nav .wer { font-size: 13px; color: var(--muted); }
/* Am breiten Schirm bleibt alles offen in der Zeile: dort gibt es weder
   Zeichen noch Kreuz noch Schleier, und ".zu" bedeutet nichts. */
header.nav .menuezeichen, header.nav .menue-zu, header.nav .menue-schleier {
  display: none;
}
/* Am Telefon zieht alles, was nicht Weg ist, unter das Zeichen rechts.
   979px ist dieselbe Grenze, an der auch die Tafel des Raumes zur
   Schublade wird - und sie liegt sicher oberhalb der Breite, bei der
   Wege, Name, Sprache, Erscheinung und Abmelden noch nebeneinander
   passen. */
@media (max-width: 979px) {
  header.nav .menuezeichen {
    display: flex; align-items: center; justify-content: center; flex: none;
    min-width: var(--griff); min-height: var(--griff);
    border: 1px solid var(--linie); border-radius: var(--rund-s);
    background: none; color: var(--text); font-size: var(--schrift-l);
    cursor: pointer;
    /* Ueber dem Schleier: sonst laege das Zeichen im Dunkeln, waehrend
       das Menue, das es aufgezogen hat, hell darunter steht. */
    position: relative; z-index: 31;
  }
  header.nav .menue-zu { display: flex; align-items: center; justify-content: center; }
  header.nav .menue-schleier { display: block; z-index: 29; }
  header.nav .rechts {
    position: absolute; top: 100%; right: var(--raum-2); z-index: 31;
    flex-direction: column; align-items: stretch; gap: var(--raum-2);
    margin-left: 0; min-width: 220px; max-width: calc(100vw - 2 * var(--raum-2));
    padding: var(--raum-3); background: var(--flaeche);
    border: 1px solid var(--linie-stark); border-radius: var(--rund-m);
    box-shadow: 0 12px 32px rgba(1, 6, 15, .45);
  }
  header.nav .rechts.zu { display: none; }
  /* Der Name stand auf dem Schnappschuss als "me" da: er war das Einzige,
     das schrumpfen durfte. Im Menue hat er die ganze Breite und bricht
     um, statt abgeschnitten zu werden. */
  header.nav .wer {
    white-space: normal; overflow-wrap: anywhere; font-size: var(--schrift-s);
    font-weight: 600; color: var(--text); order: -1;
  }
}
/* Das Band des Beispiels. Es klebt oben und laesst sich nicht schliessen:
   wer vergisst, dass er im Beispiel ist, sucht darin seine eigenen Raeume.
   Sein Ausgang steht in der Zeile - auch am Telefon, wo er sonst hinter
   dem Menuezeichen verschwaende.

   z-index bleibt unter dem Kopf (30) und unter dem Menue am Telefon (31):
   sonst laege das Band ueber der Liste, die das Zeichen ausfaehrt. Der
   Schleier (29) darf es verdunkeln, solange das Menue offen steht. */
.beispielband {
  position: sticky; top: 0; z-index: 28;
  display: flex; align-items: center; flex-wrap: wrap;
  gap: var(--raum-2) var(--raum-3);
  padding: var(--raum-2) var(--raum-4);
  background: var(--an-flaeche); color: var(--an);
  border-bottom: 1px solid var(--an-linie);
  font-size: var(--schrift-s);
  /* Ohne eigenen Grund schiene beim Rollen das Haus durch. */
  backdrop-filter: blur(8px);
}
.beispielband .band-text { font-weight: 600; }
.beispielband .band-hinweis { color: var(--text-leise); }
/* Der Ausgang ganz rechts, und am Telefon in der zweiten Reihe ganz
   aussen - nie abgeschnitten, nie hinter einem Zeichen. */
.beispielband .knopf { margin-left: auto; flex: none; }

/* Dieselbe Wahl steht zweimal: im Kopf und ueber der Anmeldung, wo
   der Kopf noch verborgen ist. Zwei Auswahlen und eine Regel - eine
   zweite Regel waere ein zweiter Ort, an dem eines Tages ein anderes
   Mass steht. */
header.nav select, .anmelde-leiste select {
  font-family: inherit; font-size: 13px; padding: 6px 8px; background: var(--panel-2);
  border: 1px solid var(--line); border-radius: 6px; color: var(--text);
  /* Rund 27px hoch war die kleinste Bedienung des ganzen Hauses. */
  min-height: var(--griff);
}

/* Der Streifen sagt, ob die Anlage gerade antwortet. Er steht oben und
 * nicht neben dem einzelnen Schalter: faellt der Bus aus, gilt das fuer
 * alles, und eine Meldung je Zeile waere Laerm. */
/* Die Zeile hat einen fest dunklen Grund - deshalb --band-err/--band-ok
   statt --err/--ok: die sind fuer die Flaeche des Hauses gedacht und in
   der hellen Erscheinung dunkel (siehe --punkt-* in :root). */
.bus-banner {
  display: flex; align-items: center; gap: 10px; padding: 10px 14px; border-radius: 8px;
  font-size: 13.5px; margin-bottom: 18px; border: 1px solid #6a2b22;
  background: #2a1613; color: var(--band-err);
}
.bus-banner .punkt { width: 9px; height: 9px; border-radius: 50%; background: var(--band-err); flex: none; }
.bus-banner.online { border-color: #205a37; background: #12241a; color: var(--band-ok); }
.bus-banner.online .punkt { background: var(--band-ok); }

.karte {
  background: var(--panel); border: 1px solid var(--line); border-radius: 10px;
  margin-bottom: 14px; overflow: hidden;
}
/* Fehlen die Namen der Typen aus knx_master.xml, steht der Code roh da
   (haus.js: typName) - "de.gira.schema.functions.KNX.HeatingCooling", ein
   Wort ohne Fuge. Ohne Umbruch und ohne min-width: 0 drueckte es das
   Abzeichen "ohne Rueckmeldung" ueber den Rand der Karte hinaus
   (Besitzer, 23.09.2026). Bei den Geraetekarten steht derselbe Umbruch
   laengst. */
.karte-kopf {
  display: flex; align-items: center; justify-content: space-between;
  flex-wrap: wrap; gap: 8px;
  padding: 12px 16px; border-bottom: 1px solid var(--line); background: var(--panel-2);
}
.karte-titel { display: flex; align-items: center; gap: 10px;
  flex-wrap: wrap; min-width: 0; }
.karte-titel .name { font-size: 14.5px; font-weight: 600; overflow-wrap: anywhere; }
.karte-titel .typ { font-size: 11.5px; color: var(--muted);
  overflow-wrap: anywhere; }
.karte-leib {
  padding: 14px 16px; display: flex; align-items: center; justify-content: space-between;
  gap: 16px; flex-wrap: wrap;
}
/* Einige Karten tragen Zeile unter Zeile statt Bedienung neben Namen:
   dort steht der Leib laengs. */
.karte-leib.felder { flex-direction: column; align-items: stretch; }
/* Eine Klappe, deren Kopf sich anfassen laesst. Ohne das waere er auf
   einem Wandtablet ein Ziel von elf Pixeln - und der Zeiger verriete
   nicht einmal, dass er ein Griff ist. */
.klappe > summary { cursor: pointer; min-height: var(--griff);
  display: flex; align-items: center; }
/* Ein leiser Teil der Module, zugeklappt: die Ueberschrift bleibt eine
   Ueberschrift (fuer den Vorleser), steht aber in der Zeile des Kopfes,
   und die Zahl daneben sagt, ob sich das Aufklappen lohnt. */
.klappe > summary > h3 { margin: 0; }
.klappe-zahl { margin-left: 8px; color: var(--text-leise);
  font-variant-numeric: tabular-nums; }
/* Dieselbe Spalte wie .karte-leib.felder, nur fuer eine Bedienzeile:
   die Klappen stehen untereinander und nicht nebeneinander. */
.bedienung.spalte { flex-direction: column; align-items: stretch; }
/* Was ein Einlesen an Rechten verschoben hat: die beiden Saetze unter dem
   Namen ruecken an ihn heran statt einen Absatz weit wegzurutschen. */
.rechte-verschoben .unterzeile { margin: 6px 0 0; }

.karte.veraltet { opacity: .82; }

/* Kein fest eingetragener dunkler Grund: Rand und Grund kommen aus der
   eigenen Schriftfarbe, damit das Abzeichen in beiden Erscheinungen des
   Hauses lesbar bleibt (siehe test_abzeichen_bleibt_in_beiden_erscheinungen_lesbar). */
.abzeichen { font-size: var(--schrift-s); padding: 2px 8px; border-radius: 999px; white-space: nowrap;
             border: 1px solid color-mix(in srgb, currentColor 40%, transparent);
             background: color-mix(in srgb, currentColor 12%, transparent); }
.abzeichen.ohne-rm { color: var(--err); }
.abzeichen.veraltet { color: var(--warn); }
.abzeichen.zugang-anders { color: var(--warn); }
.abzeichen.nur-sehen { color: var(--muted); }
.abzeichen.logik { color: var(--accent); cursor: help; }
/* Das Abzeichen "Logik im X1" ist der Kopf einer Klappe mit den Namen der
   Knoten - es sieht weiter aus wie ein Abzeichen, nur ohne Dreieck. */
/* inline-block: zugeklappt steht das Abzeichen in der Reihe der anderen,
   nicht auf einer eigenen Zeile. */
.logik-knoten { display: inline-block; vertical-align: middle; }
.logik-knoten > summary.abzeichen.logik { list-style: none; cursor: pointer; }
.logik-knoten > summary::-webkit-details-marker { display: none; }
.logik-knoten > ul { margin: var(--raum-1) 0 0; padding-left: var(--raum-4);
                     font-size: var(--schrift-xs); color: var(--text-leise); }

/* Der Zustand eines Moduls: "arbeitet" und "meldet eine Stoerung" duerfen
   sich nicht nur im Wort unterscheiden. Ausgeschaltet ist kein Fehler und
   bleibt darum leise. */
.abzeichen.modul-laeuft { color: var(--gut); }
.abzeichen.modul-stoerung { color: var(--fehler); }
.abzeichen.modul-unklar { color: var(--warn); }
.abzeichen.modul-aus { color: var(--muted); }

/* Unterwegs: der Befehl ist raus, die Antwort noch nicht da. Das Pulsen
   ist das einzige Bewegte am Zustand - es zeigt Warten, keinen Wert.
   Das Abzeichen sitzt auf der Karte (Flaeche des Hauses, gefaerbt mit der
   Erscheinung) - der Punkt auf dem Plan aber auf seinem eigenen, fest
   dunklen Schild (siehe .plan .punkt weiter unten) und braucht deshalb
   eigene, dort lesbare Toene statt --akzent/--warn. */
.abzeichen.warte { color: var(--akzent); border-color: var(--akzent); }
.abzeichen.stumm { color: var(--warn); border-color: var(--warn); }
.abzeichen.warte::after { content: ""; display: inline-block; width: 6px; height: 6px;
  margin-left: 6px; border-radius: 50%; background: currentColor; vertical-align: middle;
  animation: pulsen 900ms infinite var(--kurve); }
@keyframes pulsen { 0%, 100% { opacity: .25; } 50% { opacity: 1; } }

.bedienung { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
/* Der Regler zeigt die gemeldete Helligkeit. Ohne Meldung steht er blass
   bei null - er behauptet dann nichts. */
.regler { width: 180px; min-height: var(--griff); accent-color: var(--akzent); }
.regler.ohne-wert { opacity: .45; }
button.knopf, .knopf {
  font-family: inherit; font-size: var(--schrift-s); padding: 0 var(--raum-4);
  min-height: var(--griff); border-radius: var(--rund-s);
  display: inline-flex; align-items: center; justify-content: center;
  border: 1px solid var(--linie-stark); background: var(--flaeche-hoch);
  color: var(--text); cursor: pointer;
  transition: transform var(--zeit-antwort) var(--kurve),
              background var(--zeit-antwort) var(--kurve),
              border-color var(--zeit-antwort) var(--kurve),
              color var(--zeit-antwort) var(--kurve);
}
button.knopf:hover:not(:disabled) { background: var(--akzent-flaeche); }
/* "Zum Inhalt" (index.html, erster Knopf im Rumpf): ausser Sicht, bis die
   Tastatur ihn erreicht. Nicht display:none - dann erreichte sie ihn nie. */
.zum-inhalt {
  position: fixed; left: var(--raum-2); top: var(--raum-2); z-index: 1000;
  transform: translateY(-200%);
}
.zum-inhalt:focus { transform: none; }
button.knopf:active:not(:disabled) { transform: scale(.97); }
/* Das einzige Warme im Bild: hier brennt Licht. */
button.knopf.an {
  border-color: var(--an-linie); background: var(--an-flaeche); color: var(--an);
}
button.knopf:disabled { opacity: .45; cursor: not-allowed; }
button.knopf.haupt { border-color: var(--accent); color: var(--accent); }

.rueckmeldung { text-align: right; min-width: 150px; }
.rueckmeldung .wert { font-size: 18px; font-weight: 700; font-family: var(--schrift-zahl); }
.rueckmeldung .wert.veraltet-wert { color: var(--warn); }
.rueckmeldung .zeit { font-size: 11px; color: var(--muted); margin-top: 2px; }
.rueckmeldung .adresse { font-size: 11px; color: var(--muted); font-family: var(--schrift-zahl); }
.rueckmeldung .fehlt { font-size: 12.5px; color: var(--err); font-style: italic; }

/* Mehrere Messwerte rechts in der Karte: Name klein, Wert gross, in zwei Spalten
   ueber alle Zeilen - die Werte stehen in einer Flucht, auch am Telefon. */
.messwerte { display: grid; grid-template-columns: auto auto; justify-content: end;
  align-items: baseline; column-gap: var(--raum-3); row-gap: var(--raum-1); }
.messzeile { display: contents; }
.messzeile .messname { font-size: var(--schrift-xs); color: var(--text-still); text-align: right; }

/* Der gemeinsame Kasten der beiden Zeilen unten. column-reverse haelt
   die Reihenfolge des Dokuments - Meldezeile zuerst - und dreht nur
   die Richtung: unten am Daumen steht, was der Mensch gerade getan
   hat, darueber, was vorhin nicht ankam. Der Kasten selbst faengt
   keine Zeiger ab, sonst laege ein unsichtbarer Streifen ueber dem
   halben Bildschirm. */
.untenstapel {
  position: fixed; left: 50%; bottom: max(16px, env(safe-area-inset-bottom));
  transform: translateX(-50%); z-index: 50;
  display: flex; flex-direction: column-reverse; align-items: center;
  gap: var(--raum-2); max-width: min(560px, calc(100vw - 32px));
  pointer-events: none;
}
.untenstapel > * { pointer-events: auto; }

.meldung {
  max-width: 100%;
  padding: var(--raum-3) var(--raum-4); border-radius: var(--rund-m);
  font-size: var(--schrift-s); text-align: center;
  border: 1px solid var(--fehler); background: var(--fehler-flaeche);
  color: var(--fehler); backdrop-filter: blur(8px);
  animation: meldung-auf var(--zeit-wechsel) var(--kurve);
}
/* Die Meldelinie (10.1.1): oben, laut, und nur wenn sie etwas sagt. */
.meldelinie { display: flex; flex-direction: column; gap: var(--raum-2);
  margin: var(--raum-2) var(--raum-4); }
.meldelinie.verborgen { display: none; }
.meldelinie-zeile { padding: var(--raum-2) var(--raum-3); border-radius: var(--rund-m);
  font-size: var(--schrift-s); border: 1px solid var(--linie); }
.meldelinie-zeile.alarm { border-color: var(--fehler); background: var(--fehler-flaeche);
  color: var(--fehler); font-weight: 600; }
.meldelinie-zeile.unbekannt { border-color: var(--warn); color: var(--warn); }
.meldung.hinweis { border-color: var(--gut); background: rgba(88, 211, 154, .12); color: var(--gut); }
/* Leer heisst unsichtbar und trotzdem da: der Bereich bleibt im
   Dokument, damit ein Vorleseprogramm die naechste Meldung ueberhaupt
   bemerkt. Weg ist nur der Kasten - Rahmen, Flaeche, Polsterung -, und
   ohne Text bleibt nichts zu sehen uebrig. */
.meldung.leer {
  border: 0; background: none; padding: 0;
  backdrop-filter: none; animation: none;
}

/* Was beim Laden nicht ankam - still und unterhalb der
   Meldezeile. Leise mit Absicht: es ist kein Fehler, den jemand
   gerade ausgeloest hat, sondern ein Zustand, der bleibt, bis
   etwas nachkommt. Darum die Farbe der Warnung und nicht die des
   Fehlers. Der Platz kommt aus .untenstapel: was der Mensch gerade
   getan hat, steht unten am Daumen, der Hinweis darueber. */
.unvollstaendig {
  max-width: 100%;
  display: flex; flex-wrap: wrap; align-items: center;
  gap: var(--raum-2);
  padding: var(--raum-2) var(--raum-3); border-radius: var(--rund-m);
  font-size: var(--schrift-xs);
  border: 1px solid var(--warn); background: var(--flaeche);
  color: var(--text-still);
}

/* Sprache und Erscheinung ueber der Anmeldung: rechts oben, leise,
   und am Telefon in derselben Zeile - zwei Steuerelemente brechen dort
   nicht um. */
.anmelde-leiste {
  display: flex; justify-content: flex-end; align-items: center;
  gap: var(--raum-2); margin-bottom: var(--raum-3); flex-wrap: wrap;
}

@keyframes meldung-auf {
  from { opacity: 0; transform: translate(-50%, 12px); }
  to   { opacity: 1; transform: translate(-50%, 0); }
}
/* Wer Bewegung nicht vertraegt, bekommt keine. */
@media (prefers-reduced-motion: reduce) {
  * { animation-duration: .01ms !important; transition-duration: .01ms !important;
      animation-delay: 0s !important; transition-delay: 0s !important; }
  /* Das gleitende Nachfuehren der Wegleiste ist auch Bewegung. */
  header.nav .wege { scroll-behavior: auto; }
}

form.tafel { max-width: 420px; }
form.tafel label { display: block; font-size: 13px; color: var(--muted); margin: 14px 0 6px; }
form.tafel input, .raumwahl select, .vorschlagsfeld input,
.ansichtform select, .ansichtform input[name="titel"], .planleiste select {
  font-family: inherit; font-size: 14px; padding: 8px 10px; width: 100%;
  background: var(--panel); border: 1px solid var(--line); border-radius: 6px; color: var(--text);
  /* Auch ein Eingabefeld ist ein Griff: hineingetippt wird mit dem
     Finger, und daneben zu treffen heisst, das Feld gar nicht erst
     aufzumachen. */
  min-height: var(--griff);
}
/* Der Dateiwaehler in einer Tafel (Import eines Projektes): sein Knopf ist
   ein <label>, damit ein Klick darauf denselben Dialog oeffnet wie die
   Tastatur auf dem versteckten Feld. Ohne diese Zeile faenge ihn
   "form.tafel label" oben ab und machte aus dem Knopf wieder eine graue
   Beschriftung in eigener Zeile. */
form.tafel .dateizeile { margin-top: 6px; }
/* "form.tafel input" oben zieht jedes Feld auf volle Breite - auch das
   versteckte. Sichtbar wird es davon nicht (clip), aber schmal soll es
   bleiben, damit es nichts verschiebt. */
/* Der unsichtbare Dateiwaehler ist einen Bildpunkt gross und liegt
   ausserhalb des Flusses; ein Mass von 44px waere dort eine Zahl ohne
   Wirkung. Der Griff ist sein Knopf daneben. */
form.tafel .dateizeile input[type="file"] { width: 1px; padding: 0; min-height: 0; }
form.tafel .dateizeile label.knopf {
  display: inline-flex; margin: 0; font-size: var(--schrift-s); color: var(--text);
}
form.tafel .dateizeile button { margin-top: 0; }
/* Beim Ankreuzfeld waechst die ZEILE auf das Mass und nicht das
   Kaestchen: ein 44px hohes Kaestchen saehe aus wie ein Fehler, und
   die Beschriftung daneben gehoert ueber <label for> ohnehin zum
   selben Griff. */
form.tafel .zeile-ankreuz { display: flex; align-items: center; gap: 8px;
  margin-top: 14px; min-height: var(--griff); }
/* "form.tafel input" wiegt mehr als die Regel fuer Haken oben. */
form.tafel .zeile-ankreuz input { width: 24px; height: 24px; min-height: 0; padding: 0; }
form.tafel .zeile-ankreuz label { display: flex; align-items: center;
  min-height: var(--griff); }
form.tafel button { margin-top: 18px; }

.raumwahl { display: flex; align-items: center; gap: 8px; margin-bottom: 20px; flex-wrap: wrap; }
.raumwahl select { width: auto; min-width: 220px; }
/* Vorschlaege unter dem Feld eines Rechts: Name, daneben leiser, was
   gleiche Namen unterscheidet (Raum darueber, Raum der Funktion). */
.vorschlagsfeld { position: relative; min-width: 220px; }
/* Die Karte schneidet sonst die offene Liste an ihrer Kante ab. */
.karte:has(.vorschlaege:not(.verborgen)) { overflow: visible; }
.vorschlaege { position: absolute; left: 0; top: calc(100% + 4px); z-index: 20; margin: 0; padding: 4px;
  list-style: none; min-width: 100%; max-width: min(420px, calc(100vw - 32px));
  background: var(--panel); border: 1px solid var(--line); border-radius: 8px;
  box-shadow: 0 8px 24px rgba(0, 0, 0, .35); }
.vorschlaege button { display: flex; width: 100%; justify-content: space-between; gap: 12px;
  min-height: var(--griff); padding: 6px 10px; border: 0; border-radius: 6px; background: transparent;
  color: var(--text); font: inherit; text-align: left; cursor: pointer; }
.vorschlaege button:hover, .vorschlaege button:focus-visible { background: var(--panel-2); outline: none; }
.vorschlaege .zusatz { color: var(--muted); font-size: 12px; white-space: nowrap; }
.leer { color: var(--muted); font-size: 14px; }

/* Der Baum, aus dem ein Recht gewaehlt wird.
 *
 * Bisher wurde die Kennung eines Raumes abgeschrieben; hier steht das
 * Haus, wie der Mensch es kennt. Die Liste hat eine Hoehe: sonst schoebe
 * ein Haus mit achtzig Raeumen die Knoepfe darunter aus dem Bild - und
 * damit den Ausgang.
 */
.rechteform { display: flex; flex-direction: column; align-items: stretch; }
.rechteform .raumwahl { margin-bottom: var(--raum-2); }
.rechtebaum { display: flex; flex-direction: column; gap: var(--raum-2);
  margin-bottom: var(--raum-4); max-width: 520px; }
/* Ein Feld, zwei Baeume: der Baum der Rechte und der Baum des
   Hauses suchen mit demselben Feld und darum nach derselben Regel
   auch im Bild. */
.rechtebaum .suche, .raumbaum .suche, .raumsuche .suche { font-family: inherit; font-size: 14px; padding: 8px 10px;
  min-height: var(--griff); width: 100%; max-width: 420px;
  background: var(--panel); border: 1px solid var(--line);
  border-radius: var(--rund-s); color: var(--text); }
.rechtebaum .baum { max-height: 340px; overflow: auto; overscroll-behavior: contain;
  border: 1px solid var(--linie); border-radius: var(--rund-s);
  background: var(--flaeche); }
.rechtebaum .baum .unterzeile { margin: 0; padding: var(--raum-3); }
/* Auf dem Telefon rollt der Baum mit der Seite: eine eigene Rolle in der
   Karte auf der rollenden Seite fing den Finger in der falschen Schicht. */
@media (max-width: 979px) {
  .rechtebaum .baum { max-height: none; overflow: visible; }
}
.baumzeile { display: flex; align-items: center; gap: var(--raum-2);
  border-bottom: 1px solid var(--linie); }
.baumzeile:last-child { border-bottom: 0; }
.baumzeile.baum-ebene { background: var(--flaeche-hoch); }
/* Das Dreieck steht hier und nicht im Quelltext: ein Zeichen ohne Sprache
   gehoert in kein Sprachpaket. Zu heisst: es zeigt nach rechts. */
.baumzeile .falten { width: var(--griff); min-height: var(--griff); flex: none;
  border: 0; background: transparent; color: var(--muted); cursor: pointer;
  font-size: 12px; }
.baumzeile .falten::before { content: "\25B8"; display: inline-block;
  transition: transform var(--zeit-antwort, 120ms) ease; }
.baumzeile .falten[aria-expanded="true"]::before { transform: rotate(90deg); }
.baumzeile .falten:focus-visible { outline: 2px solid var(--akzent); outline-offset: -2px; }
.baumzeile .eintrag { display: flex; align-items: center; gap: var(--raum-3);
  flex: 1 1 auto; min-height: var(--griff); padding: 0 var(--raum-3);
  font-size: 14px; cursor: pointer; }
.baumzeile.baum-ebene .eintrag { font-weight: 600; }
.baumzeile .eintrag .rechts { margin-left: auto; font-size: 12px; color: var(--text-still); }
.baumzeile .eintrag input:disabled { opacity: .6; }
.baumfuss { display: flex; align-items: center; gap: var(--raum-3); flex-wrap: wrap; }
.baumfuss .marke { font-size: 13px; color: var(--muted); }

/* Meine Geraete.
 *
 * Eine Liste von Browserzeilen ist keine Liste von Geraeten. Oben steht
 * der Name, den der Mensch gegeben hat; die Browserzeile liegt darunter
 * zugeklappt und unterscheidet zwei gleiche Tablets. Das eigene Geraet
 * traegt einen Rand in der Farbe des Akzents: wer abmeldet, soll sehen,
 * welches er selbst ist.
 */
.geraet.eigenes { border-color: var(--akzent); }
/* Ein Band am Namen: eigener Ton, eigener Rand, kein fester dunkler Grund -
   so bleibt es in beiden Erscheinungen lesbar. */
.geraet .band { font-family: var(--schrift-zahl); font-size: 11px;
  letter-spacing: .08em; text-transform: uppercase; white-space: nowrap;
  padding: 1px 8px; border-radius: var(--rund-voll);
  border: 1px solid var(--linie-stark); color: var(--muted); }
.geraet .band.dieses { color: var(--akzent); border-color: var(--akzent); }
/* Ohne eigenen Namen steht dort die Browserzeile - sie ist lang und darf
   umbrechen, statt am Telefon aus der Karte zu laufen. */
.geraet .karte-titel { flex-wrap: wrap; }
.geraet .karte-titel .name { overflow-wrap: anywhere; }
.geraet-leib { display: flex; flex-wrap: wrap; justify-content: flex-start;
  gap: var(--raum-2) var(--raum-4); font-size: 12px; color: var(--text-still); }
.geraet-leib b { font-weight: 500; color: var(--muted); margin-right: var(--raum-1); }
.geraet details { padding: 0 var(--raum-4) var(--raum-2); }
/* Das Dreieck des Browsers bleibt stehen: es sagt ohne Wort, dass sich
   hier etwas aufklappt. Die Zeile ist hoch genug zum Antippen. */
.geraet summary { cursor: pointer; padding: var(--raum-2) 0;
  font-size: 12px; color: var(--text-still); }
.geraet .browserzeile { font-family: var(--schrift-zahl); font-size: 11px;
  color: var(--text-still); word-break: break-all; }
/* Die Rueckfrage steht in der Zeile, nicht in einem Fenster darueber: sie
   gilt diesem Geraet, und man soll beim Lesen sehen, welchem. */
.geraet-frage, .geraet-name { display: flex; align-items: center; gap: var(--raum-2);
  flex-wrap: wrap; padding: var(--raum-3) var(--raum-4);
  border-top: 1px dashed var(--linie-stark); font-size: 14px; color: var(--muted); }
.geraet-frage .luecke { margin-left: auto; }
/* Was beim Ausschalten verloren geht: eine eigene Zeile, nicht ein
   angehaengtes Stueck Satz. flex-basis 100% zwingt den Umbruch, damit
   sie auch auf einem breiten Schirm unter der Frage steht und nicht
   neben ihr verschwindet. Die Warnfarbe und nicht die Fehlerfarbe:
   hier ist nichts kaputt, hier geht etwas verloren. */
.geraet-frage .warnung { flex-basis: 100%; color: var(--warn); }

/* Der Platz, an dem ein Knopf und seine Rueckfrage einander abloesen.
   Er selbst hat keine Gestalt: die Knoepfe stehen in der Reihe, in der
   sie schon standen, sonst haette das Fragen die Leiste umgebaut. */
.mit-frage { display: contents; }
.geraet-name input { font-family: inherit; font-size: 14px; padding: 8px 10px;
  min-height: var(--griff); flex: 1 1 200px;
  background: var(--panel); border: 1px solid var(--line);
  border-radius: var(--rund-s); color: var(--text); }
.knopf.gefahr { color: var(--fehler); border-color: var(--fehler); }
/* Der Blick des Verwalters auf fremde Geraete: eingerueckt in der Karte
   des Menschen, mit einem sichtbaren Weg zurueck. */
.fremde-geraete { display: flex; flex-direction: column; gap: var(--raum-2);
  margin-top: var(--raum-3); padding-top: var(--raum-3);
  border-top: 1px solid var(--linie); }
.fremde-geraete .leiste { display: flex; align-items: center; gap: var(--raum-3);
  flex-wrap: wrap; }
.fremde-geraete .unterzeile { margin: 0; }

/* Der Baum des Hauses. Stockwerke lassen sich zuklappen: wer im
 * Erdgeschoss steht, braucht die Raeume des zweiten Obergeschosses nicht
 * zu sehen, und auf einer Wandtafel ist jede Zeile weniger ein Gewinn. */
.raumbaum { margin-bottom: 20px; }
.raumbaum .stockwerk { margin-bottom: 6px; }
.raumbaum .stockwerk-kopf {
  display: flex; align-items: center; gap: 8px; width: 100%;
  font-family: inherit; font-size: 14px; text-align: left; cursor: pointer;
  padding: 9px 12px; border-radius: 8px; color: var(--text);
  background: var(--panel); border: 1px solid var(--line);
}
.raumbaum .stockwerk-kopf .zahl { margin-left: auto; font-size: 12px; color: var(--muted); }
.raumbaum .stockwerk-kopf .pfeil {
  color: var(--muted); font-size: 12px;
  background: none; border: 0; padding: 0; cursor: pointer; font-family: inherit;
  min-width: var(--griff); min-height: var(--griff); text-align: center;
}
.raumbaum .stockwerk-kopf .stockwerk-name {
  flex: 1; text-align: left; background: none; border: 0; padding: 0;
  font-family: inherit; font-size: inherit; color: inherit; cursor: pointer;
}
.raumbaum .stockwerk-kopf .stockwerk-name:disabled { cursor: default; color: var(--muted); }
.raumbaum .stockwerk-kopf.gewaehlt { border-color: var(--accent); }
.raumbaum .stockwerk-kopf.gewaehlt .stockwerk-name { color: var(--accent); }
.raumbaum .planmarke { margin-left: 6px; font-size: 11px; color: var(--muted); }
.raumbaum .raeume { display: flex; flex-wrap: wrap; gap: 6px; padding: 8px 4px 4px 22px; }
.raumbaum .raum {
  font-family: inherit; font-size: var(--schrift-s); padding: 0 var(--raum-3);
  min-height: var(--griff); display: inline-flex; align-items: center;
  border-radius: var(--rund-s); border: 1px solid var(--linie);
  background: var(--flaeche-hoch); color: var(--text); cursor: pointer;
  transition: background var(--zeit-antwort) var(--kurve);
}
.raumbaum .raum:hover { background: var(--akzent-flaeche); }
.raumbaum .raum.gewaehlt { border-color: var(--accent); color: var(--accent); }

/* Der Plan: Grundriss oder Foto des Raumes, darauf die Bedienpunkte.
 *
 * Der Punkt sitzt in Anteilen der Bildgroesse, nicht in Bildpunkten -
 * deshalb steht er auch hier in Prozent und wandert mit dem Bild, wenn
 * die Wandtafel ein anderes Seitenverhaeltnis hat als das Telefon. */
/* inline-size: die Zone um einen Punkt rechnet in Breiten des Plans (cqw). */
.plan { position: relative; margin-bottom: 18px; container-type: inline-size; }
.plan img, .werkstatt img { width: 100%; display: block; border-radius: 10px; border: 1px solid var(--line); }
/* Der nachgezeichnete Plan ist immer eine dunkle Tafel - auch in der
   hellen Erscheinung; seine Farben stehen im SVG selbst. */
.plan.nachgezeichnet img { background: #020a19; border-color: #0b1733; }
/* Die Zusage der Werkstatt: wie der Grundriss zustande kommt. Sie steht
   unter dem Bild, das hinausginge, und vor dem Knopf - nicht im Grau der
   Unterzeilen, denn sie ist keine Nebenbemerkung. Der geratene Weg ist der
   einzige, bei dem der Grundriss des Hauses zu einem Fremden geht; er
   traegt deshalb den warnenden Ton, die beiden gemessenen den ruhigen. */
.werkstatt .zusage { margin: 10px 0 0; font-size: 14px; color: var(--gut); }
.werkstatt .zusage.hinaus { color: var(--warn); }
.werkstatt .vorher-nachher { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
/* Ein Bauplan hat kein "vorher" zu zeigen: die eine Zeichnung steht
   dann allein und nicht in einer halb leeren Spalte. */
.werkstatt .nur-nachher { display: block; }
@media (max-width: 600px) { .werkstatt .vorher-nachher { grid-template-columns: 1fr; } }
/* Das Schild bleibt IMMER dunkel (nicht var(--panel) o.ae.): das Bild
   darunter hat eine eigene, unbekannte Helligkeit, und der Schriftton hier
   ist deshalb --punkt-text statt --text - dasselbe fest lesbare Amber/Blau/
   Grau in beiden Erscheinungen, siehe die Tokens --punkt-... und --an-punkt
   in :root und test_schild_kontrast_erreicht_wcag_aa. */
:root { --vorschau-kante: 96px; }
.plan .punkt {
  position: absolute; transform: translate(-50%, -50%);
  width: var(--punkt-kreis); height: var(--punkt-kreis);
  padding: 0; border: 0; border-radius: 50%;
  font-family: inherit; font-size: 0; line-height: 0; cursor: pointer;
  color: var(--punkt-text); background: currentColor;
  box-shadow: 0 0 0 2px rgba(16, 21, 26, .88), 0 2px 8px rgba(0, 0, 0, .45);
}
/* Klein ist der Kreis, nicht der Finger: das unsichtbare Pseudoelement
   haelt die Treffflaeche auf der vollen Griffgroesse (44 px), damit die
   Wandtafel im Flur mit dem Daumen bedienbar bleibt - und damit der Punkt
   beim Setzen greifbar und ziehbar bleibt. */
/* Die Zone ist ein Kreis von einem Griff - hoechstens so gross wie der
   Abstand zum naechsten Punkt (--nah, zonenBegrenzen in app.js): zwei
   Kreise beruehren sich dann, sie decken sich nicht. Ein Browser ohne
   cqw verwirft die zweite Zeile und behaelt den Griff. */
.plan .punkt::before {
  content: ""; position: absolute; left: 50%; top: 50%;
  width: var(--griff); height: var(--griff);
  width: max(var(--punkt-kreis), min(var(--griff), calc(var(--nah, 1) * 100cqw)));
  height: max(var(--punkt-kreis), min(var(--griff), calc(var(--nah, 1) * 100cqw)));
  border-radius: 50%;
  transform: translate(-50%, -50%);
}
/* Ein Punkt mit lebendem Bild ist kein Kreis mehr: das Bild ist der Punkt.
   Gross genug, um etwas zu erkennen, und klein genug, dass ein Plan mit
   zehn davon nicht zur Bildwand wird - der Dienst schickt ohnehin nur
   diese Kante (fundament.VORSCHAU_KANTE).
   Das Bild deckt den Kreis, ohne ihn wegzunehmen: kommt kein Bild, steht
   der Kreis wieder da, und der Zustand darunter bleibt lesbar. */
.plan .punkt > img.vorschau {
  position: absolute; left: 50%; top: 50%;
  transform: translate(-50%, -50%);
  width: var(--vorschau-kante); height: auto;
  border-radius: 6px; object-fit: cover;
  box-shadow: 0 0 0 2px currentColor, 0 2px 8px rgba(0, 0, 0, .45);
}
/* Kein Bild da, kein leerer Rahmen: ein Kasten mit gebrochenem Bild sae
   aus wie ein Fehler des Plans und nicht wie eine schweigende Kamera. */
.plan .punkt > img.vorschau:not([src]) { display: none; }

/* Auch auf dem Plan bedeutet warm: hier brennt Licht - derselbe Sinn wie
   am Knopf ("an" ist die einzige warme Farbe). Frueher trugen Schrift und
   Rahmen den Zustand; jetzt traegt ihn die Flaeche des Kreises, und die
   Regeln setzen dafuer weiter nur color (background: currentColor). */
.plan .punkt.an { color: var(--an-punkt); }
.plan .punkt.aus { color: var(--punkt-text); }
.plan .punkt.warte { color: var(--punkt-akzent); }
.plan .punkt.stumm { color: var(--punkt-warn); }
/* Keine Verbindung ist kein leiser Zustand. Ein Melder, der schweigt,
   ist so wichtig wie eine Tuer, die offen steht, und darf nicht im Grau
   verschwinden (Abschnitt 8.5, Punkt 3). Darum dasselbe Leuchten ueber
   den Rand hinaus, das ".an" traegt - nur in der Warnfarbe. */
.plan .punkt.veraltet-wert {
  color: var(--punkt-warn);
  box-shadow: 0 0 0 2px rgba(16, 21, 26, .88), 0 0 10px var(--punkt-warn);
}
/* Ohne Wert: kein voller Kreis, sondern ein Ring - da ist etwas, aber die
   Anlage hat noch nichts dazu gesagt. */
.plan .punkt.ohne-wert {
  color: var(--punkt-muted); background: rgba(16, 21, 26, .88);
  box-shadow: 0 0 0 2px currentColor, 0 2px 8px rgba(0, 0, 0, .45);
}
/* Modul fehlt: ein gestrichelter statt ein durchgezogener Ring. Das ist
   keine schweigende Anlage (.ohne-wert), sondern ein Punkt, dessen
   Unterpaket gerade gar nicht laeuft - zwei Ursachen, zwei Zeichen. */
.plan .punkt.ohne-modul {
  color: var(--punkt-muted); background: transparent;
  border: 2px dashed currentColor;
  box-shadow: 0 2px 8px rgba(0, 0, 0, .45);
}
/* Was brennt, leuchtet auch ueber seinen Rand hinaus - so findet das Auge
   die brennenden Punkte auf einem vollen Grundriss wieder. */
.plan .punkt.an {
  box-shadow: 0 0 0 2px rgba(16, 21, 26, .88), 0 0 10px var(--an-linie);
}
/* Die Tuer ist genauso klein: auch ihre Schilder ("WC/Dusche" mit Pfeil,
   "Esszimmer" mit Pfeil) verdeckten den halben Grundriss. Sie traegt statt einer
   Farbe einen Pfeil, der aus dem Raum hinaus zeigt - wohin sie fuehrt,
   sagt die Zeichnung selbst, und der Name kommt beim Druck. */
.plan .punkt.tuer {
  --pfeil: 0deg;
  background: #12202b; color: var(--punkt-akzent);
  display: flex; align-items: center; justify-content: center;
  box-shadow: 0 0 0 2px currentColor, 0 2px 8px rgba(0, 0, 0, .45);
}
.plan .punkt.tuer::after {
  content: "\2192"; font-size: 12px; line-height: 1;
  transform: rotate(var(--pfeil));
}
/* Welche Seite die naechste ist, rechnet haus.js (tuerRichtung); hier
   steht nur, wie weit der eine Pfeil sich dafuer dreht. */
.plan .punkt.tuer.nach-rechts { --pfeil: 0deg; }
.plan .punkt.tuer.nach-unten { --pfeil: 90deg; }
.plan .punkt.tuer.nach-links { --pfeil: 180deg; }
.plan .punkt.tuer.nach-oben { --pfeil: -90deg; }
/* Die Karte, die ein Punkt auf dem Plan aufgeschlagen hat: eine Weile
   markiert, damit der Blick den Weg vom Kreis zur Bedienung findet. */
.karte.vom-punkt { border-color: var(--akzent); outline: 2px solid var(--akzent); outline-offset: 2px; }
.karte.vom-punkt:focus { outline: 2px solid var(--akzent); }
/* Die Karte, die beim Setzen der Punkte gewaehlt ist. Mit Umriss und
   nicht nur mit Rand: fehlt ihr die Rueckmeldung, behaelt sie den roten
   Rand weiter unten und zeigt die Wahl trotzdem (11.34.34). */
.karte.gewaehlt { border-color: var(--akzent); outline: 2px solid var(--akzent); outline-offset: 2px; }
/* Die Formen der Modulpunkte: je Art eine eigene Silhouette. Die Farbe
   bleibt dem Zustand - zwei Bedeutungen auf einer Farbe waeren eine
   Farbe, die nichts mehr sagt. Welche Art welche Form bekommt, hat das
   Modul gewaehlt (fundament.ZEICHEN); hier steht nur, wie sie aussieht. */
.plan .punkt.zeichen-bogen { border-radius: 50% 50% 4px 4px; }
.plan .punkt.zeichen-welle { border-radius: 60% 40% 60% 40%; }
.plan .punkt.zeichen-flamme { border-radius: 50% 50% 50% 4px; }
.plan .punkt.zeichen-hand { border-radius: 30%; }
.plan .punkt.zeichen-tropfen { border-radius: 50% 50% 50% 20%; }
.plan .punkt.zeichen-horn { border-radius: 50% 4px 50% 50%; }
.plan .punkt.zeichen-knoten { border-radius: 4px; }
/* Die Einteilung, die ein Geraet aus seiner Anlage mitbringt: ein
   Schildchen neben der Beschriftung, das sich durch Rahmen und Groesse
   unterscheidet und nicht durch eine Farbe. Die Farben sind hier den
   Zustaenden vergeben, und eine Farbe mit zwei Bedeutungen sagt nichts. */
.geraetemarke {
  display: inline-block; margin-left: 6px; padding: 1px 6px;
  font-size: 12px; color: var(--muted);
  border: 1px solid var(--muted); border-radius: 999px;
}
/* Die Bemerkung des Besitzers aus seiner Anlage: eine leise eigene
   Zeile unter dem Geraet, kein Zeichen wie die Marke. */
.geraetebemerkung { display: block; font-size: 12px; color: var(--muted); }
.plan.legen .punkt { cursor: grab; }
.plan.legen img { cursor: crosshair; }
/* Der gewaehlte Punkt beim Setzen. Nicht warm: warm heisst "brennt". */
.plan .punkt.gewaehlt { outline: 3px solid var(--akzent); outline-offset: 2px; }
/* Ein Hinweis des Moduls (die schwache Batterie, Hauptplan 11.14.3): ein
   warmer Ring um den Punkt. Ein Ring und nicht eine Farbe des Kreises -
   die Farbe gehoert dem Zustand, und eine Tuer bleibt zu, auch wenn ihre
   Batterie schwach ist. ::after ist schon die Form der Tuer. */
.plan .punkt.mit-hinweis {
  box-shadow: 0 0 0 2px rgba(16, 21, 26, .88), 0 0 0 4px var(--punkt-warn),
              0 2px 8px rgba(0, 0, 0, .45);
}
.planleiste { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; margin-bottom: 10px; }
.planleiste .hinweis-text { font-size: 12.5px; color: var(--muted); }
/* Die Klappe "Verwalten" nimmt ihre eigene Zeile. Ohne das stuende sie
   als gewoehnliches Glied neben dem Feld der Bildwahl und entfaltete
   ihre sechs Knoepfe in den Rest der Breite - auf einer Wandtafel eine
   Spalte von drei Fingern. Und sie steht oben statt in der Mitte: sonst
   rutscht der Kopf von der Linie der Nachbarn weg, sobald sie offen ist. */
.planleiste > .klappe { flex: 1 0 100%; align-self: flex-start; }

/* Die Form fuer ein Bild: Datei, Art und Titel untereinander - auf dem
   Telefon wie auf der Wandtafel, ohne waagerechtes Schieben. */
.ansichtform { display: flex; flex-direction: column; gap: var(--raum-3);
               margin-bottom: 14px; padding: var(--raum-3);
               border: 1px solid var(--linie); border-radius: var(--rund-s);
               background: var(--flaeche-hoch); }
.ansichtform label { display: flex; flex-direction: column; gap: 6px;
                     font-size: var(--schrift-s); }
.ansichtform fieldset { border: 0; padding: 0; margin: 0;
                        display: flex; gap: var(--raum-3); flex-wrap: wrap; }
.ansichtform fieldset label { flex-direction: row; align-items: center;
                              min-height: var(--griff); }
/* Nicht der tiefe "an"-Ton: eine Radiowahl ist keine Anlage, die brennt. */
.ansichtform fieldset input[type="radio"] { accent-color: var(--akzent); }
.ansichtform legend { font-size: var(--schrift-s); color: var(--muted); margin-bottom: 6px; }
.ansichtform input[name="titel"] { min-height: var(--griff); }
/* Der Dateiwaehler: der Knopf und der Dateiname vertreten das versteckte
   <input> optisch, das ganze Label reicht den Klick weiter. */
.dateizeile { display: flex; align-items: center; gap: var(--raum-3); flex-wrap: wrap; }
.dateizeile .knopf { flex: none; }
.dateiname { font-size: var(--schrift-s); color: var(--muted); }
/* Der Fokusring liegt auf dem Knopf, nicht auf dem unsichtbaren <input> -
   sonst saehe eine tastende Person beim Tab nichts markiert. */
/* Und der Ring der allgemeinen Regel bleibt dem unsichtbaren Feld
   selbst erspart: es ist einen Bildpunkt gross, und ein Ring darum
   waere ein Fleck neben dem Knopf, auf dem der Ring schon liegt. */
.nur-fuer-vorleser:focus-visible { outline: none; }
.nur-fuer-vorleser:focus-visible + .knopf {
  outline: 2px solid var(--akzent); outline-offset: 2px;
}
.plan-titel { font-size: var(--schrift-s); color: var(--muted); margin: 0 0 8px; }

/* Die Raeume ohne Platz: Knoepfe nebeneinander, die in den Raum fuehren. */
.karte-leib.ohne-platz { flex-wrap: wrap; justify-content: flex-start; gap: 6px; }

/* Einstellungen: je Zeile Name, Abzeichen und Eingabe. Auf schmalen
   Geraeten untereinander - eine Wandtafel im Hochformat soll nicht
   waagerecht schieben muessen. */
.einstellung { display: grid; grid-template-columns: 240px auto 1fr auto;
               gap: 10px; align-items: center; padding: 8px 0;
               border-bottom: 1px solid var(--line); }
/* Der Satz zuerst, der Bezeichner klein darunter, die Hilfe darunter.
   Bis zum 24.09.2026 stand hier nur der Bezeichner aus der .env in
   Schreibmaschinenschrift - richtig als Anker, falsch als einzige
   Beschriftung. Jetzt traegt die Schreibmaschinenschrift nur noch den
   Anker, und die Sprache steht oben. */
.einstellung label { display: flex; flex-direction: column; gap: 2px;
                     font-size: 13px; color: var(--text); word-break: break-word; }
.einstellung label .schluessel { font-family: ui-monospace, Consolas, monospace;
                                 font-size: 11px; color: var(--muted);
                                 word-break: break-all; }
/* Der Bezeichner aus der .env ist der Anker fuer den Integrator; zu sehen
   ist er nur, wenn jemand ihn eingeschaltet hat (bezeichnerSchalter). */
body:not(.bezeichner-an) .einstellung label .schluessel { display: none; }
/* Der Schalter dazu ist ein Griff, kein Kaestchen von dreizehn Pixeln. */
.bezeichner-schalter { display: flex; align-items: center; gap: var(--raum-2);
  min-height: var(--griff); cursor: pointer; }
.einstellung label .hilfe { font-size: 12px; color: var(--muted); line-height: 1.35; }
/* Die Zeile waechst damit ueber eine Zeile hinaus - die Felder gehoeren
   dann nach oben und nicht in die Mitte. */
.einstellung { align-items: start; }
.einstellung input[type="text"], .einstellung input[type="password"],
.einstellung input[type="number"] { width: 100%; }
.abzeichen.pflicht { color: var(--warn); }
@media (max-width: 720px) {
  .einstellung { grid-template-columns: 1fr; gap: 6px; }
}

/* Ein Feld, das der Dienst abgelehnt hat. */
.einstellung input[aria-invalid="true"] {
  border-color: var(--fehler); background: var(--fehler-flaeche);
}

/* Das Haus als Schnitt (Entwurf 13). Straenge nebeneinander, Hoehen als
   1px-Linien quer durch alle Straenge. Ein Raster statt eines Bildes: so
   hat jede Ebene von selbst die volle Anfassgroesse, auch am Telefon. */
.buehne { display: grid; gap: var(--raum-5); grid-template-columns: 1fr; align-items: start;
  margin-bottom: var(--raum-5); }
@media (min-width: 980px) { .buehne { grid-template-columns: minmax(0, 1.4fr) minmax(300px, .9fr); }
  /* Ohne gewaehlte Ebene ist die Tafel weg - dann gehoert die Breite dem Haus. */
  .buehne.breit { grid-template-columns: minmax(0, 1fr); } }
.schnitt { position: relative; border: 1px solid var(--linie); border-radius: var(--rund-m);
  background: var(--grund); padding: var(--raum-5) var(--raum-4) var(--raum-4) 64px; }
.schnitt .kopfzeile { display: grid; column-gap: var(--raum-3); margin-bottom: var(--raum-2); }
.schnitt .strang-name { font-family: var(--schrift-zahl); font-size: var(--schrift-marke);
  text-transform: uppercase; letter-spacing: .16em; color: var(--text-still);
  border-bottom: 1px solid var(--linie); padding-bottom: var(--raum-2); }
.schnitt .raster { position: relative; display: grid; grid-auto-rows: minmax(84px, auto);
  column-gap: var(--raum-3); }
/* Die Hoehenlinie gehoert zur Zeile, nicht zur Ebene: sie laeuft durch,
   auch wo in einem Strang auf dieser Hoehe nichts liegt. */
.schnitt .hoehe { grid-column: 1 / -1; position: relative; border-top: 1px solid var(--linie);
  pointer-events: none; }
.schnitt .hoehe span { position: absolute; left: -56px; top: -8px; width: 48px; text-align: right;
  font-family: var(--schrift-zahl); font-size: var(--schrift-marke); color: var(--text-still);
  letter-spacing: .08em; }
/* Die Zahl selbst nimmt den Zeiger an: an ihr steht der Satz, was sie
   misst (title). Die Linie bleibt durchlaessig. */
.schnitt .hoehe span { pointer-events: auto; }
.schnitt .hoehe.null { border-top-color: var(--linie-stark); }
/* Drei Ebenen in einer Zelle (Ebene C, D und E beim Besitzer) pressten
   sich auf je 90 Punkte, und die Namen standen senkrecht Buchstabe fuer
   Buchstabe. Sie brechen jetzt um statt sich zu zerquetschen. */
.schnitt .fach { display: flex; flex-wrap: wrap; gap: var(--raum-2); z-index: 1; min-width: 0; }
.ebene { flex: 1 1 128px; min-width: 0; position: relative; margin: 6px 0; display: flex; flex-direction: column;
  justify-content: space-between; align-items: flex-start; gap: var(--raum-1); min-height: 72px;
  padding: var(--raum-3); text-align: left; cursor: pointer; font-family: inherit; color: var(--text);
  background: rgba(143, 176, 255, .07); border: 1px solid var(--linie-stark); border-radius: 6px; }
.ebene:hover { background: rgba(143, 176, 255, .14); border-color: rgba(213, 224, 255, .5); }
.ebene:focus-visible { outline: 2px solid var(--akzent); outline-offset: 3px; }
/* Steht die Tafel daneben, schrumpft die Spalte, und "Obergeschoss"
   stand als "O be rg es ch os s" da - ein Name, den man raten muss
   (Besitzer, 25.09.2026). Ein Wort wird nicht mehr zerlegt: was nicht
   passt, endet mit Auslassungspunkten. Den ganzen Namen traegt der Knopf
   im title bei sich, damit das Kuerzen nichts wegnimmt. */
.ebene .name { font-size: var(--schrift-l); font-weight: 600; letter-spacing: -.01em; line-height: 1.1;
  max-width: 100%; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
/* Die Marke "PLAN" sass bis zum 26.09.2026 oben rechts und absolut, und
   der Name musste 44 Punkte fuer sie freihalten. Bei offener Tafel ist
   die Kachel etwa 140 Punkte breit: 44 fuer die Marke, 24 fuer die
   Raender, rund 72 fuer den Namen - "Obergeschoss" stand als "Oberg..."
   da. Der Besitzer entschied, die Marke in die untere Zeile zu setzen
   (Frage B0.11). Der Name bekommt damit die ganze Breite, und
   reserviert wird nichts mehr. Ganz zu sehen ist er damit nicht: bei
   offener Tafel steht "Obergesch...", ein Zeichen fehlt (Hauptplan
   11.27.2; ob man ihm nachjagt, ist Frage B0.24 an den Besitzer). */
.ebene .zeile { display: flex; gap: var(--raum-3); flex-wrap: wrap; font-family: var(--schrift-zahl);
  font-size: var(--schrift-xs); color: var(--text-still); }
/* Gewaehlt: Farben umgedreht wie .floor.active im Vorbild. */
.ebene.gewaehlt { background: var(--akzent-flaeche); border-color: var(--akzent); }
.ebene.ohne-plan { background: transparent; border-style: dashed; }
.ebene.nur-weg { background: transparent; border-style: dotted; color: var(--text-still); }

.schnittform { border: 1px solid var(--akzent); border-radius: var(--rund-m);
  background: rgba(5, 34, 97, .28); padding: var(--raum-4); margin-bottom: var(--raum-5);
  /* Sechs feste Spalten nehmen 708 Punkte. Gab die erste alles her, was
     sie brauchten, stand da "Beispielhau" und "Obergesch" - ein Name zum
     Raten (Besitzer, 25.09.2026). Die erste Spalte hat jetzt ein
     Mindestmass; wird es dadurch zu eng, rollt die Maske waagrecht,
     statt vorne etwas abzuschneiden. */
  /* Neun Ebenen, sieben Spalten: wer nach unten rollt, sah die Koepfe
     nicht mehr und wusste nicht, in welche Spalte er tippt (Befund 2.9
     vom 25.09.2026). `position: sticky` allein half nicht - es klebt am
     naechsten rollenden Vorfahren, und das ist wegen overflow-x DIESE
     Maske und nicht die Seite. In einem echten Chrome gemessen
     (29.09.2026): ohne eigene Hoehe wanderte der Kopf beim Rollen der
     Seite mit (-399 von 800), mit eigener Hoehe klebt er (1 von 600).
     Darum rollt die Maske jetzt in sich - waagrecht wie bisher und
     senkrecht dazu. Das Mass ist grosszuegig: bei wenigen Ebenen
     entsteht gar kein zweiter Rollbalken. */
  overflow: auto; max-height: min(70vh, 640px); }
/* Hinter diesem Rand steht noch etwas (rollHinweis in app.js). */
/* Rechts bleibt der senkrechte Rollbalken voll sichtbar (--balken). */
.schnittform.rechts-mehr {
  -webkit-mask-image: linear-gradient(to left, #000 var(--balken, 0px), transparent var(--balken, 0px), #000 calc(var(--balken, 0px) + 40px));
  mask-image: linear-gradient(to left, #000 var(--balken, 0px), transparent var(--balken, 0px), #000 calc(var(--balken, 0px) + 40px)); }
.schnittform.links-mehr {
  -webkit-mask-image: linear-gradient(to right, transparent, #000 40px);
  mask-image: linear-gradient(to right, transparent, #000 40px); }
.schnittform.links-mehr.rechts-mehr {
  -webkit-mask-image: linear-gradient(to right, transparent, #000 40px, #000 calc(100% - var(--balken, 0px) - 40px), transparent calc(100% - var(--balken, 0px)), #000 calc(100% - var(--balken, 0px)));
  mask-image: linear-gradient(to right, transparent, #000 40px, #000 calc(100% - var(--balken, 0px) - 40px), transparent calc(100% - var(--balken, 0px)), #000 calc(100% - var(--balken, 0px))); }
.schnittzeilen { display: grid;
  /* Die sechs festen Spalten stehen genau auf dem Mass, das
     test_am_bildschirm_passt_die_tabelle_der_ebenen verlangt - keinen
     Punkt mehr. Zusammen mit dem Mindestmass der ersten Spalte und dem
     kleineren Abstand dazwischen passt die Maske damit ganz ins Bild.
     Nahmen sie mehr, stand die letzte Spalte halb ausserhalb, und das
     Rollen half nicht: den Rand erkennt niemand als Rand. */
     Die erste Spalte traegt seit dem 28.09.2026 die zwei Pfeile fuer
     die Reihenfolge mit und braucht dafuer vier Zeichen mehr. Eine
     achte Spalte waere der billigere Weg gewesen und der falsche:
     sie draengte die letzte halb aus dem Bild. */
  grid-template-columns: minmax(18ch, 1fr) 88px 140px 104px 88px 140px 104px;
  gap: var(--raum-2) var(--raum-2); align-items: center; margin: var(--raum-3) 0; }
.schnittname { min-width: 0; display: flex; align-items: center;
  gap: var(--raum-2); }
.schnittwort { min-width: 0; overflow-wrap: anywhere; }
.schnittordnung { flex: none; display: flex; gap: 2px; }
/* Ein Pfeil ist ein Zeichen und kein Satz: er darf schmal sein, muss
   aber so hoch bleiben wie jeder andere Griff - am Telefon wird er
   mit dem Finger getroffen und nicht mit der Maus. */
.schnittordnung .pfeil { min-width: var(--griff); min-height: var(--griff);
  padding: 0; }
.schnittkopf { font-family: var(--schrift-zahl); font-size: var(--schrift-xs); color: var(--text-still);
  min-width: 0; overflow-wrap: anywhere;
  /* Der eigene Grund ist keine Zier: ohne ihn schoeben sich die
     Zeilen beim Rollen durch die Schrift des Kopfes, und lesbar
     waere er nirgends. Dieselbe Farbe wie die Maske. */
  position: sticky; top: 0; z-index: 1;
  background: var(--flaeche); padding-bottom: 2px; }
/* Am Bildschirm sagen die Koepfe, was in der Spalte steht; die Platzhalter
   gelten erst am Telefon, wo die Koepfe fehlen. */
.schnittzeilen input::placeholder { color: transparent; }
.schnittzeilen input, .schnittzeilen select { font-family: inherit; font-size: var(--schrift-s);
  min-height: var(--griff); padding: 0 var(--raum-2); background: var(--flaeche);
  border: 1px solid var(--linie-stark); border-radius: 6px; color: var(--text); width: 100%; }
#schnitt-bearbeiten { margin-bottom: var(--raum-5); }
/* Die Marke hat ihre eigene Zeile: sonst stand sie je nach Laenge von
   "2 an" mal in der zweiten, mal in der dritten (Hauptplan 11.27.1). */
.ebene .planzeichen { flex-basis: 100%; font-family: var(--schrift-zahl); font-size: var(--schrift-marke);
  letter-spacing: .14em; text-transform: uppercase; color: var(--text-still); }
.ebene.gewaehlt .planzeichen { color: var(--akzent); }
/* "An" ist das einzige Warme im Bild. Ohne Verbindung ist die Zahl nur
   noch der letzte bekannte Stand - dann in der Farbe der Warnung. */
.an-zahl, .an-marke, .zahlen b.an { color: var(--an); }
.offline .an-zahl, .offline .an-marke, .offline .zahlen b.an { color: var(--warn); }

/* Die Tafel der Ebene: neben dem Schnitt auf der Wandtafel, von unten
   ueber ihm am Telefon. Schliessen fuehrt auf den Schnitt zurueck. */
/* Der Griff gehoert der Schublade am Telefon; daneben gibt es ihn nicht. */
.tafelgriff { display: none; }
.ebenentafel { border: 1px solid var(--linie-stark); border-radius: var(--rund-m);
  background: var(--flaeche); padding: var(--raum-4); }
.ebenentafel.zu { display: none; }
@media (min-width: 980px) { .ebenentafel { position: sticky; top: 72px; } }
@media (max-width: 979px) {
  .ebenentafel { position: fixed; left: 0; right: 0; bottom: 0; z-index: 21; max-height: 78vh;
    overflow: auto; overscroll-behavior: contain;
    border-radius: var(--rund-l) var(--rund-l) 0 0; border-bottom: 0; }
  /* Im Haus in 3D fliegt die Kamera zur Platte - die Tafel laesst den
     oberen Teil frei, damit man das auch sieht (app.js rueckt die Buehne
     hoch). Wie hoch sie steht, sagt --tafel-hoehe: am Griff gezogen oder
     mit einem Druck ganz auf (app.js: tafelHoeheSetzen). Das Polster der
     Seite liest dieselbe Zahl, damit man hinter der Tafel weiterblaettert. */
  .ebenentafel.ueber-haus { max-height: var(--tafel-hoehe, 58vh); }
  body.tafel-unten { padding-bottom: var(--tafel-hoehe, 58vh); }
  .tafelgriff { display: block; position: sticky; top: calc(-1 * var(--raum-4)); z-index: 1;
    width: 100%; height: 26px; margin: calc(-1 * var(--raum-4)) 0 var(--raum-2);
    padding: 0; border: 0; background: var(--flaeche); cursor: grab;
    touch-action: none; }
  .tafelgriff::before { content: ""; display: block; width: 44px; height: 4px;
    margin: 11px auto; border-radius: 2px; background: var(--linie-stark); }
  .tafelgriff:focus-visible { outline: 2px solid var(--akzent); outline-offset: -2px; }

}
/* Das Haus in 3D (Entwurf 12, Bewegung nach horizonte-village und
   hubtown): Platten in CSS 3D, keine Bibliothek. Gerechnet wird in
   haus.js in Plattenbreiten; hier wird mit --platte multipliziert.
   Verblassen (opacity unter 1) nur an Teilen, die selbst flach sind: an
   einem Element mit preserve-3d legte es alles darin in eine Ebene. */
.hausart { display: inline-flex; gap: var(--raum-2); margin-bottom: var(--raum-4); }
.hausart .knopf[aria-pressed="true"] { background: var(--akzent-flaeche); border-color: var(--akzent); }
.haus3d { position: relative; overflow: hidden; border: 1px solid var(--linie);
  border-radius: var(--rund-m); background: var(--grund);
  /* Die Buehne nimmt, was der Schirm hergibt ("auf Tablet und PC ist der Schirm groesser,
     das 3D-Fenster waechst nicht mit", sinngemaess, Besitzer, 22.09.2026) -
     aber nur, was WIRKLICH uebrig ist. Mit 80 % der ganzen Fensterhoehe
     stand sie hoeher als der Platz unter der Kopfzeile, und die unteren
     Platten lagen unter dem Fensterrand (Besitzer, 25.09.2026). Was ueber
     ihr steht, misst app.js in --buehne-oben; am Telefon bleibt sie nicht
     hoeher als breit, damit das Haus nicht in leerer Flaeche steht. */
  height: clamp(320px,
    min(calc(100vh - var(--buehne-oben, 200px) - var(--raum-5)), 110vw),
    1000px);
  /* Ohne Fluchtpunkt: die Rechnung in haus.js ist parallel (jede Platte
     ist 1 mal 1), eine Perspektive aber machte die vordere Platte bis zum
     Doppelten der hintersten und schob sie dazu zur Seite - "verschieden
     gross oder seitlich verschoben" (Besitzer, 23.09.2026). Parallel stimmen
     Bild und Rechnung ueberein; die Tiefe zeigt die Staffelung selbst. */
  perspective: none; transform-style: preserve-3d;
  /* Der Finger dreht und neigt das Haus in jede Richtung, die Seite
     blaettert daneben weiter - der Besitzer wollte beides ("mit dem Finger
     am Telefon geht das Senkrechte nicht"). */
  touch-action: none; user-select: none; cursor: grab;
  /* 62 Grad Neigung: die Ebenen stehen weit genug auseinander, dass keine
     den Plan der darunter verdeckt (bei 56 lag das Obergeschoss halb auf
     dem Erdgeschoss). */
  /* Nur der Anfangswert: app.js rechnet die Breite einer Platte aus dem
     Umriss des Hauses und der Buehne (haus.js: plattenGroesse), damit das
     ganze Haus die Buehne fuellt - gleich, wie viele Ebenen es hat. */
  --platte: clamp(130px, 46vw, 230px); --neigung: 62deg; --blick: -32deg; --drehung: 0deg;
  /* --nah: so nah, dass die gewaehlte Platte die Buehne fuellt (haus.js:
     plattenNah); --zoom: dazu von Hand, 1 bis 2,5 (Kneifen, Strg+Rad). */
  --ziel-x: 0; --ziel-y: 0; --ziel-z: 0; --nah: 1; --mass: 1; --zoom: 1;
  /* In Ruhe steht das Haus mittig auf der Buehne: seine gemessene Mitte
     liegt wegen der Perspektive nicht im Ursprung (app.js: hausEinpassen). */
  --mitte-x: 0px; --mitte-y: 0px;
  --neigung-wirk: var(--neigung); --blick-wirk: calc(var(--blick) + var(--drehung)); }
.haus3d.innen { --neigung-wirk: 0deg; --blick-wirk: 0deg; }
.haus3d.zieht { cursor: grabbing; }
.haus3d:focus-visible { outline: 2px solid var(--akzent); outline-offset: 3px; }
.haus3d .welt { position: absolute; left: 50%; top: 44%; width: 0; height: 0;
  transform-style: preserve-3d;
  transform: translate(var(--mitte-x), var(--mitte-y))
    scale(calc(var(--mass) * var(--nah) * var(--zoom))) rotateX(var(--neigung-wirk))
    rotateZ(var(--blick-wirk))
    translate3d(calc(var(--ziel-x) * var(--platte)), calc(var(--ziel-y) * var(--platte)),
                calc(var(--ziel-z) * var(--platte)));
  transition: transform var(--zeit-nah) var(--kurve-weit), top var(--zeit-nah) var(--kurve-weit); }
/* Die gewaehlte Platte steht in der Mitte der Buehne; das ganze Haus etwas
   hoeher, weil die oberen Ebenen nach oben ragen. */
.haus3d.gewaehlt .welt { top: 50%; }
.haus3d.innen .welt { transition-duration: var(--zeit-heraus); }
/* Die Welt der Schilder liegt genau auf der der Platten, faengt aber
   keinen Druck ab: getippt wird auf die Platte. */
.haus3d .schilder { pointer-events: none; }
/* Der Auftritt: das Haus blendet auf und kommt naeher - die Blende am
   flachen Rahmen, die Annaeherung an der Welt (scale, nicht opacity). */
.haus3d.auftritt { animation: haus-blende var(--zeit-nah) var(--kurve-weit) both; }
.haus3d.auftritt .welt { animation: haus-nah var(--zeit-nah) var(--kurve-weit) both; }
@keyframes haus-blende { from { opacity: 0; } to { opacity: 1; } }
@keyframes haus-nah { from { scale: .94; } to { scale: 1; } }

.haus3d .platte { position: absolute; left: calc(var(--platte) / -2); top: calc(var(--platte) / -2);
  width: var(--platte); height: var(--platte); transform-style: preserve-3d;
  --richtung-wirk: var(--richtung); --heben: 0px; --gross: 1;
  transform: translate3d(calc(var(--x) * var(--platte)), calc(var(--y) * var(--platte)),
                         calc(var(--z) * var(--platte)))
    rotateZ(var(--richtung-wirk)) translateZ(var(--heben)) scale(var(--gross));
  transition: transform var(--zeit-weg) var(--kurve-weit); }
.haus3d.gewaehlt .platte { --gross: .97; }
.haus3d.gewaehlt .platte.gewaehlt { --heben: 24px; --gross: 1.04;
  transition: transform var(--zeit-heraus) var(--kurve-pruzhina); }
.haus3d.innen .platte.gewaehlt { --richtung-wirk: 0deg; --heben: 0px; --gross: 1;
  transition: transform var(--zeit-heraus) var(--kurve-weit); }
/* Die anderen Platten verblassen. Nicht mit opacity an .flaeche: sie traegt
   preserve-3d, und Mauer wie Punkte fielen flach auf die Platte. Es
   verblassen Grund und Rand (Farbe) und jedes flache Blatt darauf. */
.haus3d.gewaehlt .platte:not(.gewaehlt) .flaeche {
  border-color: color-mix(in srgb, var(--linie-stark) 25%, transparent); }
.haus3d.gewaehlt .platte:not(.gewaehlt):not(.leer) .flaeche {
  background-color: color-mix(in srgb, var(--platte-grund) 20%, transparent); }
.haus3d.gewaehlt .platte:not(.gewaehlt) .blatt > * { opacity: .2; }
.haus3d.innen .platte:not(.gewaehlt) { pointer-events: none; }
/* :not(.leer) wie oben - sonst gewoenne dort der Grund mit 20 %. */
.haus3d.innen .platte:not(.gewaehlt):not(.leer) .flaeche, .haus3d.innen .platte.leer:not(.gewaehlt) .flaeche {
  background-color: transparent; border-color: transparent; }
.haus3d.innen .platte:not(.gewaehlt) .blatt > * { opacity: 0; }

.haus3d .flaeche { position: absolute; inset: 0; display: grid; place-items: center; padding: 0;
  background: var(--platte-grund); border: 1px solid var(--platte-rand); border-radius: 4px;
  cursor: pointer; color: inherit; font: inherit; transform-style: preserve-3d;
  transition: background-color var(--zeit-weg) var(--kurve-weit),
              border-color var(--zeit-weg) var(--kurve-weit); }
.haus3d .platte.leer .flaeche { background: transparent; border: 1px dashed var(--linie-stark); }
.haus3d .platte.nur-weg .flaeche { border-style: dotted; }
.haus3d .platte.gewaehlt .flaeche { border-color: var(--akzent); }
.haus3d .flaeche:focus-visible { outline: 2px solid var(--akzent); outline-offset: 4px; }
.haus3d .blatt { position: relative; display: block; transform-style: preserve-3d; }
.haus3d .blatt > * { transition: opacity var(--zeit-weg) var(--kurve-weit); }
.haus3d .blatt .grundriss { display: block; max-width: var(--platte); max-height: var(--platte); }
/* Der Satz an einer Platte, deren Bild nicht kam (wennBildBricht). */
.haus3d .blatt .leer { display: block; max-width: var(--platte); padding: var(--raum-3); }
/* Ohne Bild saessen die Punkte in Prozent eines Rahmens von der Hoehe des
   Satzes - also nirgends, wo sie hingehoeren. */
.haus3d .platte.leer .warm { display: none; }
.plan.ohne-bild .punkt { display: none; }
/* Ohne sauberen Plan liegt das Original des Architekten auf der Platte:
   Papier weiss -> dunkel, Linien schwarz -> hell, durchscheinend auf dem
   Blau der Platte. Fest, nie bewegt (kein transition), nur am
   Bild selbst - ein Blatt ohne 3D-Kinder, nichts wird flach. Fotos kommen
   nie auf eine Platte (haus.js: plattenAnsicht nur "grundriss"). */
.haus3d .platte:not(.sauber):not(.leer) .blatt .grundriss:not(.hell) {
  filter: invert(1) contrast(.85) brightness(1.1) opacity(.8); }
.haus3d .wand { position: absolute; inset: 0; width: 100%; height: 100%; pointer-events: none;
  opacity: .5; transform: translateZ(calc(var(--stufe) * var(--platte) * .009)); }
.haus3d .warm { position: absolute; inset: 0; pointer-events: none;
  transform: translateZ(calc(var(--platte) * .03)); }
/* Warm ist nur, was die Anlage als an meldet - ohne Uebergang, ohne Puls. */
.haus3d .warm span { position: absolute; width: 10px; height: 10px; margin: -5px 0 0 -5px;
  border-radius: 50%; background: var(--an-punkt); box-shadow: 0 0 12px var(--an-linie); }
/* Das ausgeschaltete Licht liegt eben gerade noch sichtbar da: halb so
   gross, ohne Schein, stark abgeblendet. Aus der Entfernung antwortet die
   Platte weiter auf "wo brennt Licht" - die matten Punkte sagen nur, wo
   ueberhaupt welches haengt, und duerfen die warmen nicht uebertoenen. */
.haus3d .warm span.aus { width: 5px; height: 5px; margin: -2.5px 0 0 -2.5px;
  background: var(--punkt-muted); box-shadow: none; opacity: .45; }
/* Veraltet (die eine Meldung oder die ganze Verbindung): Farbe wie bei den
   Zaehlern - aber nur, was brennt: ein matter Punkt meldet nichts. */
.haus3d.offline .warm span:not(.aus),
.haus3d .warm span.veraltet:not(.aus) { background: var(--punkt-warn); box-shadow: none; }
/* Modul fehlt: kein matter Punkt wie bei einem Geraet, das bloss aus ist,
   sondern ein gestrichelter Ring - derselbe Unterschied wie auf dem flachen
   Plan (.plan .punkt.ohne-modul). Das Unterpaket laeuft nicht, und die
   Platte darf das nicht wie einen gesunden, dunklen Punkt zeigen. */
.haus3d .warm span.ohne-modul {
  background: transparent; border: 1px dashed var(--punkt-muted);
  box-shadow: none; opacity: .8; }

/* Dieselben Formen wie auf dem flachen Plan (.plan .punkt.zeichen-*).
   Bis zum 25.09.2026 trug die Platte nur warm oder matt, und das war eine
   Entscheidung mit Begruendung: ein Grundriss aus der Ferne trage nicht
   mehr. Der Besitzer hat sie am 25.09.2026 umgestossen, und zu Recht -
   hat etwas ausgeloest, ist "wo" die halbe Auskunft, und Rauch und eine
   offene Tuer sind zweierlei.

   Die Werte stehen hier zum zweiten Mal und nicht als gemeinsame Regel:
   die Punkte der Platte sind halb so gross wie die des Plans, und
   dieselbe Rundung in Punkten sieht an einem 10-px-Punkt anders aus als
   an einem 16-px-Punkt. Eine gemeinsame Regel haette die Formen auf der
   Platte zu Kreisen verschliffen. */
.haus3d .warm span.zeichen-bogen { border-radius: 50% 50% 3px 3px; }
.haus3d .warm span.zeichen-welle { border-radius: 60% 40% 60% 40%; }
.haus3d .warm span.zeichen-flamme { border-radius: 50% 50% 50% 3px; }
.haus3d .warm span.zeichen-hand { border-radius: 30%; }
.haus3d .warm span.zeichen-tropfen { border-radius: 50% 50% 50% 20%; }
.haus3d .warm span.zeichen-horn { border-radius: 50% 3px 50% 50%; }
.haus3d .warm span.zeichen-knoten { border-radius: 3px; }

/* Das Schild schaut immer zum Betrachter: es hebt die Drehungen von
   Platte, Blick und Neigung in umgekehrter Reihenfolge wieder auf. */
.haus3d .fahne { position: absolute; left: 50%; top: 50%; pointer-events: none; white-space: nowrap;
  /* Das Schild bleibt lesbar gross: nicht kleiner mit einem grossen Haus
     (--mass), nicht groesser beim Heranfliegen und Zoomen - um seinen
     Ankerpunkt, daher transform-origin 0 0. */
  /* --schild-ab hebt das Schild ueber die Platte und weicht dem Schild
     der Nachbarebene aus (app.js: schilderSetzen). Es steht nach der
     Gegenskalierung, also in Bildpunkten auf dem Schirm. */
  --schild-ab: 0px;
  /* --schild-quer holt das Schild unter einem Bedienteil hervor
     (haus.js: schilderQuer). Nur nach links: die Teile stehen rechts. */
  --schild-quer: 0px;
  transform: translateZ(calc(var(--platte) * .14)) rotateZ(calc(-1 * var(--richtung-wirk)))
    rotateZ(calc(-1 * var(--blick-wirk))) rotateX(calc(-1 * var(--neigung-wirk)))
    scale(calc(1 / var(--mass) / var(--nah) / var(--zoom)))
    translate(var(--schild-quer), var(--schild-ab)) translate(-50%, -50%);
  transform-origin: 0 0;
  font-size: var(--schrift-s); color: var(--text); background: var(--flaeche);
  border: 1px solid var(--linie-stark); border-radius: var(--rund-s); padding: 2px var(--raum-2);
  transition: transform var(--zeit-nah) var(--kurve-weit), opacity var(--zeit-weg) var(--kurve-weit); }
.haus3d .fahne .an-zahl:not(:empty) { margin-left: var(--raum-2); }
.haus3d.gewaehlt .platte:not(.gewaehlt) .fahne, .haus3d.innen .fahne { opacity: 0; }

.haus3d .haus3d-zurueck { position: absolute; left: var(--raum-4); top: var(--raum-4); z-index: 2; }
/* Neigen mit zwei Knoepfen - neben dem Finger, der dasselbe tut: auf der
   Wandtafel im Kiosk ist der genaue Winkel mit dem Finger muehsam. */
.haus3d .neigen { position: absolute; right: var(--raum-4); top: calc(var(--raum-5) + 56px);
  z-index: 2; display: flex; flex-direction: column; gap: 4px; }
.haus3d .neigen .knopf { width: var(--griff); height: var(--griff); display: grid; place-items: center; padding: 0; }
/* Der Pfeil ist gezeichnet, nicht geschrieben: ein Zeichen im Quelltext
   waere eine Zeile, die der Mensch sieht (Regel des Projekts). */
.haus3d .neigen .pfeil { width: 0; height: 0; border-left: 6px solid transparent;
  border-right: 6px solid transparent; border-bottom: 7px solid currentColor; }
.haus3d .neigen .knopf.runter .pfeil { transform: rotate(180deg); }
/* Der Weg zurueck zum Anfangsblick steht unter dem Kompass - dort, wo
   auch die Drehung zu sehen ist. */
.haus3d .haus3d-blick { position: absolute; right: var(--raum-4); top: calc(var(--raum-5) + 160px);
  z-index: 2; font-size: var(--schrift-s); padding: 4px var(--raum-3); }
.haus3d .kompass { position: absolute; right: var(--raum-4); top: var(--raum-5); z-index: 2;
  width: 44px; height: 44px; border: 1px solid var(--linie-stark); border-radius: 50%;
  transform: rotate(var(--blick-wirk)); transition: transform var(--zeit-nah) var(--kurve-weit); }
.haus3d .kompass .nadel { position: absolute; left: 50%; top: 6px; width: 2px; height: 16px;
  margin-left: -1px; background: var(--akzent); }
.haus3d .kompass b { position: absolute; left: 50%; top: -20px; transform: translateX(-50%);
  font-family: var(--schrift-zahl); font-size: var(--schrift-marke); color: var(--akzent); }
.haus3d.zieht .welt, .haus3d.zieht .fahne, .haus3d.zieht .kompass { transition: none; }
/* Beim Zoomen von Hand folgt die Welt dem Finger ohne Verzug. */
.haus3d.zoomt .welt, .haus3d.zoomt .fahne { transition: none; }

/* Ein Druck mitten im Uebergang: fuer einen Augenblick keine Uebergaenge,
   alles steht am Ziel (app.js: hausSofort). */
html.sofort .haus3d, html.sofort .haus3d *, html.sofort .raumtafel {
  transition: none !important; animation: none !important; }

.tafelkopf { display: flex; align-items: flex-start; gap: var(--raum-3); margin-bottom: var(--raum-4); }
.tafelkopf h2 { margin: 0; font-size: var(--schrift-xxl); font-weight: 300; letter-spacing: -.02em; }
.tafelkopf h2:focus { outline: none; }
.schliessen { margin-left: auto; flex: none; min-width: var(--griff); min-height: var(--griff);
  border: 1px solid var(--linie); border-radius: var(--rund-s); background: none; color: var(--text);
  font-size: var(--schrift-l); cursor: pointer; }
/* Die Vorschau des Grundrisses oben in der Tafel: dieselbe dunkle Platte
   wie beim grossen Plan (.plan img), aber begrenzt in der Hoehe - sie ist
   ein Fingerzeig, kein Ersatz fuer "Ganze Ebene". */
.ebenenplan-vorschau { display: block; width: 100%; padding: 0; margin: 0 0 var(--raum-4);
  border: 1px solid var(--linie-stark); border-radius: var(--rund-s); background: var(--grund);
  cursor: pointer; overflow: hidden; }
.ebenenplan-vorschau:hover { border-color: rgba(213, 224, 255, .5); }
.ebenenplan-vorschau img { display: block; width: 100%; max-height: 220px; object-fit: contain; }
/* Am Telefon ist die Tafel eine Schublade: der Plan darf darin nicht die
   halbe Hoehe fressen, sonst bleibt die Liste unter dem Rand. */
@media (max-width: 979px) { .ebenenplan-vorschau img { max-height: 110px; } }
/* Dasselbe dunkle Original wie auf der Platte - nur fuer das Original eines
   Grundrisses (app.js setzt .original), nie auf dem flachen Plan des Raumes. */
.ebenenplan-vorschau.original img:not(.hell) {
  filter: invert(1) contrast(.85) brightness(1.1); opacity: .8; }
.zahlen { display: grid; grid-template-columns: repeat(2, 1fr); gap: 1px; background: var(--linie);
  border: 1px solid var(--linie); border-radius: var(--rund-s); overflow: hidden;
  margin: 0 0 var(--raum-4); }
.zahlen div { background: var(--flaeche); padding: var(--raum-3); }
.zahlen b { display: block; font-family: var(--schrift-zahl); font-size: var(--schrift-xl); font-weight: 400; }
.zahlen span { font-size: var(--schrift-xs); color: var(--text-still); }
.raumliste { list-style: none; margin: 0; padding: 0; border-top: 1px solid var(--linie); }
.raumliste li { border-bottom: 1px solid var(--linie); }
.raumliste button { width: 100%; min-height: var(--griff); display: flex; align-items: center;
  gap: var(--raum-2); background: none; border: 0; color: var(--text); font-family: inherit;
  font-size: var(--schrift-s); text-align: left; padding: 0 var(--raum-2); cursor: pointer; }
.raumliste button:hover { background: var(--flaeche-hoch); }
.raumliste .an-marke { margin-left: auto; font-family: var(--schrift-zahl); font-size: var(--schrift-xs); }
.alle-raeume { margin-bottom: var(--raum-5); }
.alle-raeume summary { cursor: pointer; min-height: var(--griff); display: flex; align-items: center;
  color: var(--text-leise); list-style: none; }
.alle-raeume summary::-webkit-details-marker { display: none; }
/* display:flex nimmt Safari das eingebaute Dreieck weg - eins von Hand,
   damit sichtbar bleibt, dass sich die Liste aufklappen laesst. */
.alle-raeume summary::before { content: ""; flex: none; width: 0; height: 0; margin-right: var(--raum-2);
  border-style: solid; border-width: 5px 0 5px 7px;
  border-color: transparent transparent transparent currentColor;
  transition: transform var(--zeit-antwort) var(--kurve); }
.alle-raeume[open] summary::before { transform: rotate(90deg); }

/* Die gesprochenen Namen eines Raumes: dieselbe aufklappbare Gestalt
   wie die Liste aller Raeume darueber - ein zweites Aussehen fuer
   dieselbe Handlung waere eine zweite Sprache. */
.raumnamen { margin-top: var(--raum-5); }
.raumnamen summary { cursor: pointer; min-height: var(--griff); display: flex;
  align-items: center; color: var(--text-leise); }
.raumname { display: flex; align-items: center; gap: var(--raum-3);
  justify-content: space-between; }
.namenform { display: flex; align-items: center; gap: var(--raum-2);
  flex-wrap: wrap; margin-top: var(--raum-3); }
.namenfeld { flex: 1 1 10rem; min-width: 0; }
@media (max-width: 560px) {
  .schnitt { padding-left: 48px; }
  .schnitt .hoehe span { left: -44px; width: 38px; }
  .ebene .name { font-size: var(--schrift-m); }
  /* Die zwei Regeln, die hier standen - Marke statisch, kein Platz
     reserviert -, gelten seit dem 26.09.2026 ueberall und nicht nur am
     Telefon. Was fuer die schmale Kachel richtig war, war es fuer die
     breite auch. */
  /* Am Telefon eine Spalte von oben nach unten: vier Straenge zu je 70px
     brachen Namen Buchstabe fuer Buchstabe um und legten Ebenen
     uebereinander. Die Reihenfolge setzt hausZeichnen (style.order). */
  .schnitt .kopfzeile { display: none; }
  .schnitt .raster { display: flex; flex-direction: column; }
  .schnitt .hoehe { margin-top: var(--raum-2); }
  .schnitt .fach { flex-wrap: wrap; }
  .ebene { flex: 1 1 130px; }
  /* Fuenf Spalten passen nicht auf 390px: der Name steht als Zeile ueber
     seinen vier Feldern, die Felder tragen ihren Namen als Platzhalter. */
  .schnittzeilen { grid-template-columns: 1fr 1fr; }
  .schnittzeilen .schnittname { grid-column: 1 / -1; font-weight: 600; margin-top: var(--raum-2); }
  .schnittzeilen .schnittkopf { display: none; }
  /* Ohne Koepfe gibt es nichts zu kleben, und eine eigene Hoehe waere
     nur ein zweiter Rollbalken im ersten. */
  .schnittform { max-height: none; }
  .schnittzeilen input::placeholder { color: var(--text-still); }
}

/* Bewegung nur an drei Stellen: das Haus erscheint, eine Tafel kommt
   herein, ein Knopf gibt nach. Der Zustand selbst bewegt sich nie - er
   wechselt, wenn die Anlage es meldet. */
@keyframes auftritt {
  from { opacity: 0; transform: translateY(14px); }
  to   { opacity: 1; transform: none; }
}
.schnitt.auftritt { animation: auftritt var(--zeit-auftritt) var(--kurve) both; }
.ebenentafel:not(.zu) { animation: auftritt var(--zeit-wechsel) var(--kurve) both; }
.ebene, .plan .punkt, .raumliste button, .schliessen {
  transition: transform var(--zeit-antwort) var(--kurve),
              background var(--zeit-antwort) var(--kurve),
              border-color var(--zeit-antwort) var(--kurve); }
.ebene:active, .raumliste button:active, .schliessen:active {
  transform: scale(.97); }
/* .plan .punkt sitzt mittig ueber seinem Punkt auf dem Bild (translate
   -50%/-50%) - ohne eigene Regel spraenge er beim Druecken aus der Mitte. */
.plan .punkt:active { transform: translate(-50%, -50%) scale(.97); }

/* Die Tafel des Raumes (Entwurf 14): von unten ueber das Haus am Telefon,
   von rechts daneben auf der Wandtafel. Geschlossen ist sie unsichtbar,
   damit die Tabulatortaste nicht in einen verborgenen Raum faellt. */
.schleier { position: fixed; inset: 0; z-index: 20; background: rgba(1, 6, 15, .6); }
@media (min-width: 980px) { .schleier { display: none; } }
/* overscroll-behavior: die Kette bricht am Rand - sonst nimmt die Seite
   dahinter den Finger weiter mit (app.js: seiteSperren haelt sie zusaetzlich fest). */
/* Beide Kanten statt einer Rechnung: am Telefon zaehlt 100vh den Schirm
   ohne die Adresszeile des Browsers, also mehr, als man sieht. Die Tafel
   stand unten an und war um diesen Unterschied zu hoch - ihr Kopf mit
   "Zurueck" und dem Kreuz schob sich unter die Kopfzeile, und im Raum gab
   es keinen sichtbaren Weg hinaus (Besitzer, 23.09.2026). Mit top und
   bottom misst der Browser die Hoehe selbst. */
.raumtafel { position: fixed; z-index: 21; left: 0; right: 0; bottom: 0;
  top: var(--kopfhoehe, 0px); overflow: auto; overscroll-behavior: contain;
  background: var(--grund);
  border-top: 1px solid var(--linie-stark); border-radius: var(--rund-l) var(--rund-l) 0 0;
  padding: var(--raum-4); transition: transform var(--zeit-wechsel) var(--kurve); }
.raumtafel.zu { transform: translateY(100%); visibility: hidden;
  transition: transform var(--zeit-wechsel) var(--kurve), visibility 0s linear var(--zeit-wechsel); }
@media (min-width: 980px) {
  .raumtafel { left: auto; top: var(--kopfhoehe, 0px); width: min(540px, 46vw); border-top: 0;
    border-left: 1px solid var(--linie-stark); border-radius: 0; }
  .raumtafel.zu { transform: translateX(100%); }
  /* main ist sonst mittig mit fester Hoechstbreite: ein Padding darin
     zwaengte den Schnitt auf ein paar Pixel zusammen, statt Platz zu
     machen. Stattdessen weicht main selbst nach links, in die Breite, die
     neben der Tafel bleibt. */
  body.tafel-offen main { max-width: none; margin-right: min(540px, 46vw); }
}
/* Aus dem Haus: erst dreht die Platte in die Aufsicht, dann blendet der
   flache Plan darueber auf - zurueck in umgekehrter Folge. */
.raumtafel.blende { transform: none; opacity: 1;
  transition: opacity var(--zeit-blende) var(--kurve-weit) var(--zeit-heraus); }
.raumtafel.blende.zu { transform: none; opacity: 0; visibility: hidden;
  transition: opacity var(--zeit-blende) var(--kurve-weit), visibility 0s linear var(--zeit-blende); }
/* Der Kopf traegt die beiden einzigen Ausgaenge. In einem langen Raum -
   Form zum Hochladen und ein Dutzend Funktionen - rollte er mit weg; wie
   beim Griff der Ebenentafel zieht ihn ein negativer Rand ueber das
   Polster der Tafel, damit nichts darunter durchscheint. */
.raumtafel .tafelkopf { align-items: center;
  position: sticky; top: calc(-1 * var(--raum-4)); z-index: 2;
  margin: calc(-1 * var(--raum-4)) calc(-1 * var(--raum-4)) var(--raum-4);
  padding: var(--raum-4); background: var(--grund);
  border-bottom: 1px solid var(--linie); }
/* Plaene per Ziehen. Die Flaeche faengt keinen Zeiger ab (pointer-events:
   none): das Ziehen kommt so weiter am Fenster an, wo es gezaehlt wird. */
.ziehflaeche { position: fixed; inset: 0; z-index: 60; pointer-events: none;
  display: flex; align-items: center; justify-content: center; padding: var(--raum-5);
  background: rgba(1, 6, 15, .72); }
.ziehflaeche p { margin: 0; max-width: 520px; padding: var(--raum-6) var(--raum-5);
  border: 2px dashed var(--akzent); border-radius: var(--rund-l);
  background: var(--flaeche); color: var(--text); font-size: var(--schrift-l);
  text-align: center; }
.zuordnung { position: fixed; inset: 0; z-index: 55; overflow: auto;
  overscroll-behavior: contain;
  display: flex; align-items: flex-start; justify-content: center;
  padding: var(--raum-7) var(--raum-4); background: rgba(1, 6, 15, .6); }
.zuordnung-fenster { width: min(760px, 100%); padding: var(--raum-5);
  background: var(--flaeche); border: 1px solid var(--linie-stark);
  border-radius: var(--rund-l); }
.zuordnung h2 { margin: 0 0 var(--raum-1); font-size: var(--schrift-xl); }
.zuordnungsliste { list-style: none; margin: 0 0 var(--raum-4); padding: 0;
  display: flex; flex-direction: column; gap: var(--raum-2); }
/* Datei, Ziel, Aktion nebeneinander am Bildschirm; am Telefon untereinander. */
.zuordnungszeile { display: grid; gap: var(--raum-2); align-items: center;
  grid-template-columns: minmax(0, 1.2fr) minmax(0, 1.4fr) minmax(0, 1fr);
  padding: var(--raum-3); border: 1px solid var(--linie); border-radius: var(--rund-s);
  background: var(--flaeche-hoch); }
.zuordnungszeile .dateiname { overflow-wrap: anywhere; color: var(--text); }
.zuordnungszeile select { font-family: inherit; font-size: 14px; min-height: var(--griff);
  padding: 0 10px; width: 100%; background: var(--panel); border: 1px solid var(--line);
  border-radius: 6px; color: var(--text); }
.zuordnungszeile .stand { grid-column: 1 / -1; font-size: var(--schrift-s); color: var(--muted); }
.zuordnungszeile .stand:empty { display: none; }
.zuordnungszeile .stand.gut { color: var(--gut); }
.zuordnungszeile .stand.fehler { color: var(--fehler); }
.zuordnung .hinweis-text { font-size: var(--schrift-s); color: var(--muted); }
/* Die Knoepfe bleiben unten sichtbar, auch wenn die Liste laenger ist als
   der Bildschirm des Telefons - der Ausgang scrollt nicht weg. */
.zuordnung .leiste { display: flex; gap: var(--raum-2); flex-wrap: wrap;
  position: sticky; bottom: 0; padding: var(--raum-3) 0;
  border-top: 1px solid var(--linie); background: var(--flaeche); }
@media (max-width: 640px) {
  .zuordnung { padding: var(--raum-4) var(--raum-4); }
  .zuordnung-fenster { padding: var(--raum-4); }
  .zuordnungszeile { grid-template-columns: minmax(0, 1fr); }
}
/* "An" ist auf der Karte dasselbe Warme wie auf dem Punkt. */
.karte.an { border-color: var(--an-linie); }
.karte.an .rueckmeldung .wert { color: var(--an); }

/* Die Tafel des Helfers zu den Einstellungen.
 *
 * Am Bildschirm steht sie rechts neben den Feldern: wer "Zum Feld"
 * drueckt, soll das Feld sehen, ohne dass etwas zugeht. Am Telefon gibt es
 * diesen Platz nicht - dort liegt sie ueber der ganzen Seite, und die
 * Seite dahinter wird festgehalten (seiteSperren in app.js), damit nicht
 * zwei Dinge zugleich blaettern. overscroll-behavior haelt die Bewegung
 * in der Tafel: am Ende der Liste zieht sie nicht die Seite mit.
 */
.helfer { position: fixed; z-index: 56; overflow: auto;
  overscroll-behavior: contain;
  inset: var(--kopfhoehe, 56px) 0 0 auto;
  width: min(440px, 100%);
  border-left: 1px solid var(--linie-stark);
  background: var(--flaeche);
  padding: var(--raum-4); }
.helfer-fenster { display: flex; flex-direction: column; gap: var(--raum-3); }
.helfer h2 { margin: 0; font-size: var(--schrift-xl); }
.helfer .unterzeile { margin: 0; }
.helfer .hinweis-text { margin: 0; font-size: var(--schrift-s); color: var(--muted); }
.helfer label { font-size: var(--schrift-s); color: var(--muted); }
.helfer textarea { width: 100%; box-sizing: border-box; min-height: 96px;
  font-family: inherit; font-size: var(--schrift-m); padding: var(--raum-2);
  background: var(--panel); color: var(--text);
  border: 1px solid var(--linie-stark); border-radius: var(--rund-s); }
/* Haken und Text in einer Zeile - und die Zeile selbst gross genug zum
   Antippen, auch mit dem Daumen auf einer Wandtafel. */
.helfer .hakenzeile { display: flex; align-items: center; gap: var(--raum-2);
  min-height: var(--griff); color: var(--text); font-size: var(--schrift-m); }
/* Die Knoepfe bleiben unten sichtbar, auch wenn die Antwort lang ist -
   der Ausgang scrollt nicht weg. */
.helfer .leiste { display: flex; gap: var(--raum-2); flex-wrap: wrap;
  position: sticky; bottom: 0; padding: var(--raum-3) 0;
  border-top: 1px solid var(--linie); background: var(--flaeche); }
.helferkarte .leiste { position: static; border-top: 0; padding: 0;
  background: transparent; }
/* Der Text der KI: gewoehnlicher Fliesstext, der auch ohne Umbrueche
   nirgends hinauslaeuft. */
.helfertext { margin: 0; white-space: pre-wrap; overflow-wrap: anywhere;
  color: var(--text); font-size: var(--schrift-m); line-height: 1.5; }
.helferliste { list-style: none; margin: 0; padding: 0;
  display: flex; flex-direction: column; gap: var(--raum-2); }
.helferkarte { display: flex; flex-direction: column; gap: var(--raum-2);
  padding: var(--raum-3); border: 1px solid var(--linie);
  border-radius: var(--rund-s); background: var(--flaeche-hoch); }
.helferkarte .feldname { font-family: var(--schrift-zahl); font-size: var(--schrift-xs);
  color: var(--muted); word-break: break-all; }
/* Was war und was wuerde, nebeneinander: die Entscheidung braucht beides
   im Blick. Der Pfeil steht hier und nicht im Quelltext - ein Zeichen
   ohne Sprache gehoert nicht in ein Sprachpaket. */
.helferkarte .werte { display: flex; align-items: baseline; gap: var(--raum-2);
  flex-wrap: wrap; font-family: var(--schrift-zahl); font-size: var(--schrift-m); }
.helferkarte .vorher { color: var(--muted); text-decoration: line-through;
  overflow-wrap: anywhere; }
.helferkarte .vorher:empty::before { content: "\2014"; text-decoration: none; }
.helferkarte .pfeil::before { content: "\2192"; color: var(--muted); }
.helferkarte .nachher { color: var(--akzent); overflow-wrap: anywhere; }
.helferkarte .grund { margin: 0; color: var(--text); font-size: var(--schrift-s);
  overflow-wrap: anywhere; }
.helferkarte .grund:empty { display: none; }
/* Der hereingezogene Plan: klein genug, dass die Knoepfe darunter noch
   auf den Schirm passen - und gross genug, dass man erkennt, was da
   hinausginge. */
.helferbild { display: block; width: 100%; max-height: 30vh;
  object-fit: contain; border: 1px solid var(--linie);
  border-radius: var(--rund-s); background: var(--flaeche-hoch); }
.helferplan { border-color: var(--akzent); }
/* Was hinausgeht, steht da, wie es hinausgeht: unveraendert, umbrechbar,
   und hoch genug begrenzt, dass die Knoepfe darunter erreichbar bleiben. */
.helfer details { border: 1px solid var(--linie); border-radius: var(--rund-s);
  background: var(--flaeche-hoch); padding: var(--raum-2); }
/* Das Dreieck des Browsers bleibt stehen: es sagt ohne Wort, dass sich
   hier etwas aufklappt. Die Zeile ist hoch genug zum Antippen. */
.helfer summary { cursor: pointer; min-height: var(--griff);
  padding: var(--raum-3) 0 var(--raum-3) var(--raum-1);
  color: var(--text); font-size: var(--schrift-s); }
.helfer .rohtext { margin: var(--raum-2) 0 0; max-height: 40vh; overflow: auto;
  overscroll-behavior: contain;
  font-family: var(--schrift-zahl); font-size: var(--schrift-xs);
  color: var(--muted); white-space: pre-wrap; overflow-wrap: anywhere; }
/* Ein Feld, das der Helfer gerade gefuellt oder gezeigt hat. Es faellt
   auf, bis der Mensch es ansieht - gespeichert ist damit nichts.
   Nur der Rahmen leuchtet: der Grund des Feldes bleibt, wie er ist -
   sonst stuende der eingetragene Wert dunkel auf dunkel. */
.einstellung input.vom-helfer, .einstellung input.vom-helfer:focus {
  border-color: var(--akzent); box-shadow: 0 0 0 2px var(--akzent);
}
@media (min-width: 980px) {
  /* Die Felder ruecken zur Seite, statt unter der Tafel zu verschwinden -
     wie die Seite es schon tut, wenn die Raumtafel offensteht. */
  body.helfer-offen main { max-width: none; margin-right: min(460px, 42vw); }
}
@media (max-width: 979px) {
  .helfer { inset: var(--kopfhoehe, 56px) 0 0 0; width: auto; border-left: 0; }
}

/* Der Dialog fuer ein Passwort.
 *
 * Er liegt ueber allem, auch ueber der Zuordnung: er ist das zuletzt
 * Geoeffnete. Dahinter wird die Seite festgehalten (seiteSperren), und
 * alles andere ist inert - Tab kommt nicht an verdeckte Knoepfe.
 */
.passwortdialog { position: fixed; inset: 0; z-index: 60; display: flex;
  align-items: center; justify-content: center; padding: var(--raum-4);
  background: rgba(1, 6, 15, .72); overflow: auto; }
.passwort-fenster { display: flex; flex-direction: column; gap: var(--raum-3);
  width: min(460px, 100%); padding: var(--raum-5);
  background: var(--flaeche); border: 1px solid var(--linie-stark);
  border-radius: var(--rund-m); box-shadow: 0 16px 48px rgba(0, 0, 0, .45); }
.passwort-fenster h2 { margin: 0; font-size: var(--schrift-xl); font-weight: 300; }
.passwort-fenster .tafelkopf { display: flex; align-items: center;
  gap: var(--raum-3); }
.passwort-fenster .schliessen { margin-left: auto; }
.passwortzeile { display: flex; flex-direction: column; gap: var(--raum-1);
  font-size: 13px; color: var(--muted); }
.passwortzeile input { font-family: inherit; font-size: var(--schrift-m);
  min-height: var(--griff); padding: 8px 10px; width: 100%;
  background: var(--panel); border: 1px solid var(--line);
  border-radius: var(--rund-s); color: var(--text); }
.passwort-fenster .hinweis-text { margin: 0; font-size: 12px; color: var(--text-still); }
.passwort-fenster .knopf { align-self: flex-start; }
/* Was danach geschieht, steht vor dem Druck da - nicht danach in einer
   Meldung: "alle anderen Geraete abgemeldet" ist keine Ueberraschung wert. */
.passwort-folge { margin: 0; padding: var(--raum-3);
  border: 1px solid var(--warn); border-radius: var(--rund-s);
  background: rgba(227, 169, 75, .08); color: var(--warn); font-size: 13px; }
.passwort-einwand { margin: 0; padding: var(--raum-3);
  border: 1px solid var(--fehler); border-radius: var(--rund-s);
  background: var(--fehler-flaeche); color: var(--fehler); font-size: 13px; }
.passwort-fenster .leiste { display: flex; gap: var(--raum-2); flex-wrap: wrap; }
.passwort-fenster .leiste .knopf { align-self: auto; }

/* Der Neustart des Dienstes. Die Karte steht ueber den Feldern und faellt
   auf: sie erscheint nur, wenn der Dienst beim Speichern gesagt hat, dass
   eine Einstellung erst danach gilt. */
.karte.neustart { border-color: var(--warn); }

/* Eine Bedienung ohne Rueckmeldung: der Rand der Fehlfarbe sagt aus der
   Entfernung, DASS etwas fehlt; WAS fehlt, sagt das Feld des Wertes in
   Worten - Farbe allein traegt hier nichts.

   Diese Regel steht mit Absicht UNTER allen anderen ".karte.<wort>", die
   einen Rand setzen: sie sind gleich stark, also gewinnt die letzte. Stand
   sie weiter oben, verlor die Karte den Rand genau dann, wenn ein Punkt
   vom Plan sie aufschlug (".karte.vom-punkt") - das Zeichen verschwand
   beim Hinsehen. Ein Waechter haelt die Reihenfolge fest. */
.karte.ohne-rueckmeldung { border-color: var(--err); }
.karte.neustart .name { color: var(--warn); }
.neustart-leib { display: flex; flex-wrap: wrap; align-items: center;
  gap: var(--raum-3); }
.neustart-leib .unterzeile { margin: 0; flex: 1 1 260px; }

/* --- Der Bildschirm eines Moduls ---------------------------------------
   Bis zum 26.09.2026 gab es hier nichts. Ein Modul druckte Zeile unter
   Zeile in blanke <p> und blanke <button>: vom Titel bis zum
   achtzigsten Auswahlfeld sah alles gleich aus. Wer an der Wandtafel
   steht, liest nicht - er sucht mit dem Blick eine halbe Sekunde lang
   und geht weiter. Da war nichts zu finden.

   Diese Regeln nennen KEIN Modul. Sie duerfen es nicht: der Kern kennt
   die Namen der Module nicht und soll sie nicht kennen - sonst muesste
   jedes neue Modul hier eingetragen werden, und das naechste steht
   schon fest. Also gibt der Kern ein Vokabular und das Modul waehlt
   daraus:

     .modulbildschirm   die Wurzel dessen, was ein Modul zurueckgibt
     .modul-teil        ein Abschnitt; .wichtig oder .leise sagt sein Gewicht
     .modul-lage        die eine Zeile, wegen der man den Schirm aufmacht
     .modul-griffe      eine Reihe Knoepfe
     .knopf.jetzt       der Knopf, der den GELTENDEN Zustand nennt

   "wichtig" und "leise" sind Gewichte und keine Bedeutungen. Welcher
   Teil schwer wiegt, weiss allein das Modul - beim Schutz ist es das
   Feuer, bei einer Kamera waere es etwas anderes. Der Kern gibt nur
   die zwei Groessen her. */
.modulbildschirm {
  display: flex; flex-direction: column; gap: var(--raum-4);
}

/* Der Name des Moduls und der Ausgang in EINER Zeile. Vorher standen
   sie untereinander, und mit dem Titel der Liste darueber waren es vier
   Zeilen Vorspann, ehe die erste kam, die etwas ueber das Haus sagt. */
.modul-kopfzeile { display: flex; align-items: center; flex-wrap: wrap;
  justify-content: space-between; gap: var(--raum-3); }

/* Zwei Auswahlen, und die erste ist NICHT tot: .modulbildschirm ist die
   Wurzel dessen, was ein fremdes Modul zurueckgibt, und ein Modul darf
   darin eine eigene Ueberschrift setzen. Der Kern schreibt ihm nicht
   vor, die Kopfzeile zu benutzen - er sorgt nur dafuer, dass beide
   Ueberschriften gleich aussehen. */
.modulbildschirm > h2,
.modul-kopfzeile > h2 { margin: 0; font-size: var(--schrift-xl);
  font-weight: 300; letter-spacing: -.02em; }

/* Das eine Wort eines Moduls ueber sich selbst, neben seinem Namen in
   der Liste. Leise: es ist eine Auskunft und kein Alarm - der Alarm
   steht auf dem Bildschirm des Moduls, gross und rot. */
.modul-kurzlage { color: var(--text-leise); font-size: var(--schrift-s); }

/* Derselbe Satz noch einmal ueber dem Haus (B0.1). Dieselbe leise
   Schrift wie in der Liste und ausdruecklich NICHT das Rot des
   Busbandes darueber: das Band meldet einen Ausfall unserer eigenen
   Verbindung, diese Zeile sagt nur, wie es im Haus steht. Zwei rote
   Streifen uebereinander liessen den Menschen den einen lesen, auf
   den es ankommt, und den anderen uebersehen. */
.modul-streifen {
  display: flex; flex-wrap: wrap; gap: var(--raum-3);
  margin-bottom: var(--raum-4);
}
.modul-streifen-zeile {
  display: flex; align-items: baseline; gap: var(--raum-2);
  padding: var(--raum-2) var(--raum-3);
  background: var(--panel); border: 1px solid var(--linie);
  border-radius: var(--rund-m); font-size: var(--schrift-s);
}
.modul-streifen-zeile .name { color: var(--text-leise); }

.modul-teil {
  background: var(--panel); border: 1px solid var(--linie);
  border-radius: var(--rund-m); padding: var(--raum-4);
  display: flex; flex-direction: column; gap: var(--raum-3);
}
/* Die Ueberschrift eines Abschnitts ist eine Marke und keine zweite
   Titelzeile: sie soll den Abschnitt abgrenzen und nicht mit dem
   Namen des Moduls um Aufmerksamkeit streiten. */
.modul-teil > h3 {
  margin: 0; font-family: var(--schrift-zahl); font-size: var(--schrift-marke);
  letter-spacing: .14em; text-transform: uppercase;
  color: var(--text-still); font-weight: 500;
}
.modul-teil p { margin: 0; }
/* Ein schwerer Teil traegt einen kraeftigeren Rand und mehr Luft. Kein
   Rot und keine Farbe: was hier faerbt, ist die Lage darin, nicht der
   Rahmen. Ein Rahmen, der immer warnt, warnt bald nicht mehr. */
.modul-teil.wichtig {
  border-color: var(--linie-stark); padding: var(--raum-5);
  background: var(--panel-2);
}
/* Und ein leiser Teil tritt zurueck: er steht da, wenn man ihn sucht,
   und nimmt dem Wichtigen nicht den Platz weg. */
.modul-teil.leise { background: transparent; padding: var(--raum-3) var(--raum-4); }
.modul-teil.leise > h3 { color: var(--text-still); }

/* Die Zeile, wegen der jemand diesen Bildschirm ueberhaupt aufschlaegt.
   Gross, weil sie schraeg und aus zwei Schritt Abstand lesbar sein
   muss - so steht eine Wandtafel im Flur. */
.modul-lage { display: flex; align-items: baseline; flex-wrap: wrap;
  gap: var(--raum-2) var(--raum-3); }
.modul-lage .wert { font-size: var(--schrift-xxl); font-weight: 300;
  letter-spacing: -.02em; color: var(--text); }
.modul-lage .dazu { font-size: var(--schrift-s); color: var(--text-leise); }
/* Drei Groessen und keine vierte. "gut" bleibt absichtlich farblos: ein
   ruhiges Haus soll ruhig aussehen, und Gruen an jeder ruhigen Stelle
   macht das eine Gruen wertlos, das wirklich etwas heisst. */
.modul-lage.warnt .wert { color: var(--warn); }
.modul-lage.schlecht .wert { color: var(--fehler); }

.modul-griffe { display: flex; flex-wrap: wrap; gap: var(--raum-2); }
.modul-griffe .knopf { min-height: var(--griff); }
/* Der Knopf, der den geltenden Zustand nennt. Er bleibt ein Knopf - wer
   "Abgeschaltet" nochmals drueckt, darf das -, aber er sieht nicht mehr
   aus wie die zwei daneben. Drei gleich aussehende Knoepfe sagen nicht,
   welcher gerade gilt, und genau das war die Frage des Menschen. */
.modul-griffe .knopf.jetzt {
  border-color: var(--akzent); background: var(--akzent-flaeche);
  color: var(--text); font-weight: 600;
}

/* Die eine Stelle, an der ein Modul auf einen Druck antwortet: unter den
   Griffen, wo der Finger ohnehin hinsieht. Sie wird ersetzt und nie
   angehaeuft - drei gleichlautende Klagen untereinander sagen nicht,
   welche von jetzt ist. */
.modul-antwort { display: flex; flex-wrap: wrap; align-items: center;
  gap: var(--raum-2); min-height: 0; color: var(--text-leise);
  font-size: var(--schrift-s); }
.modul-antwort:empty { display: none; }
