/* ═══════════════════════════════════════════════════════════════
   StarshipOS — Responsive Layer v2 (Smartphone & Tablet)

   Eingebunden in templates/layout/base.html hinter tokens-v2.css,
   controls-v2.css und dem head-extra-Fragment.

   ── Warum jede Regel mit `.station-body` beginnt ───────────────
   Die Ladereihenfolge allein reicht hier nicht. Der Thymeleaf
   Layout-Dialect haengt die Stylesheets der Stationsseite hinter den
   gesamten Layout-Head; /css/damage-control.css steht im gelieferten
   HTML also NACH dieser Datei und wuerde bei gleicher Spezifitaet
   gewinnen.

   Deshalb ist jeder Selektor mit `.station-body` praefixiert: (0,2,0)
   schlaegt die Ein-Klassen-Regeln der Stationen (0,1,0) unabhaengig
   von der Reihenfolge — und das ohne ein einziges `!important`, das
   spaeter niemand mehr gezielt uebersteuern koennte. Wer hier etwas
   ergaenzt, haelt sich an dieses Muster.

   ── Entwurfsgedanke ────────────────────────────────────────────
   Zielgeraete laut CC_158 sind 10–15"-Android-Tablets im Kiosk-Modus
   (Steuer-Stationen) plus gelegentlich ein Smartphone (GM unterwegs,
   kleine Nebenstation, Prop). Die Stationen sind als zwei- bis
   dreispaltige Cockpits gebaut — „1fr + 320px Seitenspalte" ist das
   durchgaengige Muster. Unter ~1000 px gibt es dafuer keinen Platz.

   Die Antwort ist deshalb nicht „alles kleiner skalieren", sondern
   eine Stufe weniger Dimension pro Breite:

     Breit  (>= 1024px)  Cockpit:  Spalten nebeneinander, Randleisten
                                   als vertikale Schienen links/rechts.
     Tablet ( 600–1023)  Stapel:   eine Spalte, Randleisten wandern
                                   an die Unterkante als Dock.
     Phone  (<=  599px)  Kompakt:  wie Tablet, dazu kompakter Kopf,
                                   volle Breite fuer jedes Panel,
                                   Tabellen scrollen horizontal.

   Was NICHT passiert: kein Feature verschwindet. Auf dem Telefon ist
   dieselbe Station bedienbar wie auf der Bruecke, nur gestapelt. Eine
   Station, auf der ein Regler fehlt, ist im Spiel schlimmer als eine,
   auf der man scrollen muss.
   ═══════════════════════════════════════════════════════════════ */


/* ═══════════════════════════════════════════════════════════════
   0. BREAKPOINT-VERTRAG

   Diese drei Breiten sind die einzigen, die im Projekt verwendet
   werden sollen. Neue Stationsseiten schreiben ihre Ausnahmen mit
   denselben Grenzen, sonst entstehen wieder Zwischenzustaende, in
   denen ein Panel halb umgebrochen ist.

     max-width:  599px   Phone
     max-width: 1023px   Phone + Tablet hochkant ("schmal")
     min-width: 1024px   Tablet quer + Desktop + Beamer

   Zusaetzlich (orthogonal, nicht als Breitenersatz):
     (pointer: coarse)   Touch-Metrik — greift auch am 22"-Touchmonitor
   ═══════════════════════════════════════════════════════════════ */

:root {
    /* Breite der fixierten Randschienen im Cockpit-Modus.
       Quelle: .gsp-tab (34px) und .ots-strip-tab (36px). */
    --rail-left-w:  34px;
    --rail-right-w: 36px;

    /* Hoehe des unteren Docks im schmalen Modus (Reiterleiste). */
    --dock-h: 44px;

    /* Sichere Bereiche (Notch / Home-Indicator). Ohne
       viewport-fit=cover sind alle env() 0 — die Rechnung bleibt
       also auch auf Geraeten ohne Aussparung korrekt. */
    --safe-l: env(safe-area-inset-left, 0px);
    --safe-r: env(safe-area-inset-right, 0px);
    --safe-b: env(safe-area-inset-bottom, 0px);
    --safe-t: env(safe-area-inset-top, 0px);
}


/* ═══════════════════════════════════════════════════════════════
   1. SHELL — Viewport-Hoehe und Platz fuer die Randschienen

   Zwei Fehler, die in jeder Groesse auftreten und hier zentral
   behoben werden:

   a) 100vh ist auf Mobilgeraeten nicht die sichtbare Hoehe. Solange
      die Adressleiste eingeblendet ist, ist 100vh groesser als das
      Fenster; der untere Rand der Seite liegt unter der Browser-UI.
      100dvh ("dynamic viewport height") ist die tatsaechlich freie
      Hoehe. Die 100vh-Zeile bleibt als Fallback davor stehen.

   b) Die beiden fixierten Randschienen (Spielstatus links, OTS-Tasks
      rechts) liegen UEBER dem Inhalt, ohne dass der Inhalt Platz fuer
      sie freihaelt. Deshalb ist auf jeder Station das erste Zeichen
      der Alarmleiste verdeckt ("REEN ALERT" statt "GREEN ALERT") und
      am rechten Rand fehlen 36px. Das ist keine Mobil-Eigenheit —
      es passiert auch am Desktop, faellt dort nur weniger auf.
      Die Shell bekommt daher einen Innenabstand in Schienenbreite.
   ═══════════════════════════════════════════════════════════════ */

.station-body {
    min-height: 100vh;
    min-height: 100dvh;
}

.station-shell {
    min-height: 100vh;
    min-height: 100dvh;
    /* Platz fuer die Randschienen. Wird im schmalen Modus (§3) auf 0
       gesetzt, weil die Schienen dort nach unten wandern. */
    padding-left:  calc(var(--rail-left-w)  + var(--safe-l));
    padding-right: calc(var(--rail-right-w) + var(--safe-r));
}

/* Ist das Spielstatus-Panel abgeschaltet (.gsp--off = display:none),
   waere der linke Innenabstand ungenutzt. :has() wird vom Projekt
   bereits vorausgesetzt (siehe ots-task-strip.css); faellt es aus,
   bleiben lediglich 34px Rand stehen — kein Layoutfehler. */
.station-shell:has(> .gsp.gsp--off) { --rail-left-w: 0px; }

/* Niemand soll seitlich scrollen muessen, nur weil ein einzelnes
   Panel zu breit rechnet. Die eigentlichen Ursachen behandeln §4–§6;
   das hier ist die Grenze, an der ein uebersehener Fall auffaellt,
   ohne die Seite unbedienbar zu machen. */
.station-main {
    max-width: min(var(--shell-max), 100%);
    overflow-x: clip;
}


/* ═══════════════════════════════════════════════════════════════
   1b. BEDIENELEMENTE, DIE IHRE SPALTE SPRENGEN — gilt in JEDER Breite

   Ein <select> ist so breit wie seine laengste Option, ein <input>
   so breit wie sein `size`-Default (rund 20 Zeichen). Beides zaehlt
   als Mindestbreite, beides ignoriert die Spalte, in der das Element
   steht. Das Sprungziel-Dropdown der Navigation ("SEC-04 — Tannhaeuser
   Rift") ist 397px breit und steht in einer 300px-Spalte.

   Diese Regel steht bewusst OHNE Media Query: ein 11"-Tablet im
   Querformat hat 1194px und faellt damit in den Cockpit-Modus — der
   Fehler tritt also genau dort auf, wo die Breakpoints nicht greifen.
   Sie kann nichts kaputtmachen: sie erlaubt Schrumpfen, sie erzwingt
   es nicht.
   ═══════════════════════════════════════════════════════════════ */

.station-body .station-main select,
.station-body .station-main input,
.station-body .station-main textarea {
    max-width: 100%;
    min-width: 0;
}

/* Derselbe Mechanismus eine Ebene hoeher: Grid- und Flex-Elemente haben
   per Default `min-width: auto` und koennen deshalb nicht unter ihre
   Inhaltsbreite schrumpfen. Eine Spalte, in der eine breite Tabelle
   steht, waechst dann ueber ihre Rasterbreite hinaus und schiebt das
   ganze Layout auf — bei der Spielerverwaltung auf einem 12,9"-Tablet
   quer um 177px.

   Auch das gilt in jeder Breite: die Spalten existieren oberhalb von
   1023px ja gerade erst. Ohne Media Query, weil `min-width: 0` nur
   Schrumpfen erlaubt und nie erzwingt. */
.station-body [class*="-layout"] > *,
.station-body [class*="-columns"] > *,
.station-body .survey-main > *,
.station-body .station-panel > * {
    min-width: 0;
}

/* Deutsche Komposita sind der zweite Dauerfall: „Atmosphaerendichtungen"
   ist ein einziges Wort von 278px und passt in keine 240px-Spalte. Ohne
   Umbruchpunkt laeuft es aus dem Panel heraus — im Cockpit genauso wie
   auf dem Telefon, nur faellt es dort frueher auf.

   `break-word` allein reicht nicht: es bricht zwar die Zeile, aendert
   aber nicht die Mindestbreite (min-content) des Elements. Als
   Flex-Element im Panelkopf schrumpft der Titel deshalb gar nicht erst
   unter seine Wortbreite — es gibt nie eine zu enge Zeile, die
   gebrochen werden koennte. Erst `min-width: 0` erlaubt das Schrumpfen,
   dann greift der Umbruch. */
.station-body .station-main :is(h1, h2, h3, h4, .panel-title, [class*="-label"], [class*="-name"]) {
    hyphens: auto;            /* <html lang="de"> — trennt „Atmosphaeren-dichtungen" */
    overflow-wrap: break-word; /* Notbremse, wenn die Trennung nicht reicht */
    min-width: 0;
}


/* ═══════════════════════════════════════════════════════════════
   2. KOPFZEILE — vom Einzeiler zum Zweizeiler

   .station-header ist eine Flex-Zeile mit vier Gruppen: Titelblock,
   Bemannung, Gefahren-Badges, Ton. Nebeneinander brauchen die
   ~900px. Die bisherige Regel in styles.css stellt sie unter 768px
   komplett untereinander (flex-direction: column) — das kostet auf
   einem Telefon rund 160px Hoehe, bevor die Station ueberhaupt
   anfaengt.

   Stattdessen: Titelblock belegt Zeile 1 ueber die volle Breite, die
   drei Statusgruppen teilen sich Zeile 2. Das sind zwei Zeilen statt
   vier, ohne dass etwas entfaellt.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 1023px) {
    .station-body .station-header {
        flex-direction: row;
        flex-wrap: wrap;
        align-items: center;
        justify-content: flex-start;
        row-gap: var(--space-sm);
        column-gap: var(--space-sm);
        padding: var(--space-sm) var(--space-md);
    }

    /* Zeile 1 */
    .station-body .station-heading {
        flex: 1 1 100%;
        flex-wrap: wrap;
        row-gap: 2px;
        column-gap: var(--space-sm);
        min-width: 0;
    }

    .station-body .station-heading h1 {
        font-size: var(--text-lg);
        min-width: 0;
        overflow-wrap: anywhere;
    }

    /* Zeile 2: Bemannung, Gefahren, Ton nebeneinander.
       `.station-crew` schiebt sich im Cockpit per `margin-left: auto` nach
       rechts. In der zweiten Zeile wuerde das eine Luecke aufreissen und
       die drei Gruppen auseinanderziehen — hier beginnen sie links. */
    .station-body .station-crew,
    .station-body .hazard-indicator,
    .station-body .sound-panel {
        flex: 0 1 auto;
        min-width: 0;
        margin-left: 0;
    }
}

@media (max-width: 599px) {
    /* Der Breadcrumb wiederholt, was Code + Titel schon sagen.
       Auf dem Telefon ist die Zeile wertvoller als die Redundanz. */
    .station-body .station-breadcrumb { display: none; }

    .station-body .station-heading h1 { font-size: var(--text-md); }

    /* Der Lautstaerkeregler darf schrumpfen — die Stummtaste nicht. */
    .station-body .sound-panel { padding: 2px 4px; }

    /* Die Alarmleiste ist die wichtigste Zeile der Station. Sie bleibt
       beim Scrollen stehen, damit „RED ALERT" nicht weggescrollt wird. */
    .station-body .alert-bar {
        position: sticky;
        top: 0;
        z-index: 800;
        padding-top: calc(var(--space-xs) + var(--safe-t));
    }
    /* Stehend muss sie deckend sein — sonst scheint der Inhalt darunter durch
       (die Farbe der Leiste ist nur ein Hauch über dem Hintergrund). */
    .station-body .alert-bar--GREEN  { background: color-mix(in srgb, var(--alert-green) 10%, var(--bg-primary)); }
    .station-body .alert-bar--YELLOW { background: color-mix(in srgb, var(--alert-yellow) 15%, var(--bg-primary)); }
    .station-body .alert-bar--RED    { background: color-mix(in srgb, var(--alert-red) 15%, var(--bg-primary)); }
}


/* ═══════════════════════════════════════════════════════════════
   3. RANDSCHIENEN → UNTERES DOCK

   Spielstatus-Panel (links) und OTS-Task-Strip (rechts) sind im
   Cockpit-Modus vertikale Schienen ueber die volle Hoehe. Auf einem
   Telefon nehmen die beiden Reiter zusammen 70 von 390 px Breite —
   18 % des Bildschirms fuer zwei Griffe.

   Im schmalen Modus werden daraus zwei kleine Reiter an der
   Unterkante (links Status, rechts Tasks); aufgeklappt fahren sie als
   Bottom-Sheet nach oben. Das ist die Stelle, die ein Daumen auf
   einem gehaltenen Geraet erreicht.

   Das geht ohne Markup-Aenderung: beide Fragmente haben dieselbe
   Struktur — versteckte Checkbox, <label> als Reiter, dann das Panel.
   `flex-direction: column-reverse` kehrt die Achse so um, dass der
   Reiter unten und das Panel darueber liegt.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 1023px) {

    /* Kein seitlicher Platzhalter mehr — dafuer unten. */
    .station-shell {
        padding-left:  var(--safe-l);
        padding-right: var(--safe-r);
        padding-bottom: calc(var(--dock-h) + var(--safe-b));
    }

    /* ── gemeinsame Dock-Geometrie ─────────────────────────────── */
    .station-body .gsp,
    .station-body .ots-task-strip {
        top: auto;
        bottom: 0;
        height: auto;
        width: auto;
        max-height: calc(100dvh - 3rem);
        flex-direction: column-reverse;  /* Reiter unten, Panel darueber */
        align-items: stretch;
        border: 1px solid rgba(0, 229, 255, 0.3);
        border-bottom: 0;
        border-radius: 10px 10px 0 0;
        box-shadow: 0 -6px 20px rgba(0, 0, 0, 0.55);
        transition: none;                /* Breiten-Transition ergibt hier keinen Sinn */

        /* Als Randschiene liegt das Panel ueber einem leeren Streifen und
           darf durchscheinen. Als Bottom-Sheet liegt es mitten auf der
           Station — dann liest man die Schildwerte dahinter durch den
           Text hindurch. Hier deckt es. */
        background: var(--bg-panel, #101825);
    }

    .station-body .gsp {
        left: var(--safe-l);
        right: auto;
        border-radius: 0 10px 0 0;
    }

    .station-body .ots-task-strip {
        right: var(--safe-r);
        left: auto;
        border-radius: 10px 0 0 0;
    }

    /* ── Reiter: aus der Vertikalen in die Horizontale ─────────── */
    .station-body .gsp-tab,
    .station-body .ots-strip-tab {
        width: auto;
        min-height: var(--dock-h);
        flex-direction: row;
        align-items: center;
        justify-content: center;
        gap: var(--space-sm);
        padding: 0 var(--space-md) var(--safe-b);
    }

    /* Der Reiter bleibt an seiner Bildschirmkante, auch wenn das Sheet
       darueber auf volle Breite aufgeht. Sonst wandert der Griff beim
       Aufklappen in die Bildschirmmitte — und beim Zuklappen wieder
       zurueck, direkt unter den Daumen des anderen Reiters. */
    .station-body .gsp-tab       { align-self: flex-start; }
    .station-body .ots-strip-tab { align-self: flex-end; }

    .station-body .gsp-tab-text {
        writing-mode: horizontal-tb;
        letter-spacing: var(--tracking-wide);
        font-size: var(--text-xs);
    }

    /* Die Pfeile zeigten zur Seite (Schiene) — jetzt nach oben, denn das
       Panel faehrt nach oben aus. Die beiden Fragmente verwenden dafuer
       gegenlaeufige Glyphen: der Spielstatus &#9654; (nach rechts), der
       Task-Strip &#9664; (nach links). Sie muessen also entgegengesetzt
       gedreht werden, sonst zeigt einer von beiden nach unten. */
    .station-body .gsp-tab-arrow  { transform: rotate(-90deg); }  /* ▶ → ▲ */
    .station-body .ots-strip-arrow { transform: rotate(90deg); }  /* ◀ → ▲ */

    .station-body .gsp-checkbox:checked ~ .gsp-tab .gsp-tab-arrow {
        transform: rotate(90deg);                                  /* ▶ → ▼ */
    }
    .station-body .ots-strip-checkbox:checked ~ .ots-strip-tab .ots-strip-arrow {
        transform: rotate(-90deg);                                 /* ◀ → ▼ */
    }

    /* ── Panel: Bottom-Sheet ───────────────────────────────────── */
    .station-body .gsp-panel,
    .station-body .ots-strip-panel {
        width: min(100vw - 1rem, 380px);
        max-height: min(60dvh, 30rem);
        border-left: 0;
        border-bottom: 1px solid rgba(0, 229, 255, 0.18);
    }

    /* Der OTS-Strip versteckt sein Panel nur per opacity und klemmt es
       ueber die feste Breite der Schiene ab. Im Dock gibt es keine
       Breite zum Abklemmen — das Panel muss wirklich aus dem Fluss. */
    .station-body .ots-strip-panel { display: none; opacity: 1; }
    .station-body .ots-strip-checkbox:checked ~ .ots-strip-panel { display: flex; }
    .station-body .ots-task-strip:has(.ots-strip-checkbox:checked) { width: auto; }

    .station-body .gsp-body,
    .station-body .ots-strip-body { overscroll-behavior: contain; }

    /* Zuklapp-Pfeile im Panel-Kopf zeigen jetzt nach unten.
       Auch hier gegenlaeufige Glyphen: Spielstatus &#9664;, Task-Strip &#9654;. */
    .station-body .gsp-close       { transform: rotate(-90deg); }  /* ◀ → ▼ */
    .station-body .ots-strip-close { transform: rotate(90deg); }   /* ▶ → ▼ */

    /* Der Task-Reiter traegt in der Schiene nur einen Pfeil und eine Zahl —
       das reicht, weil er ganzseitig am Rand klebt und wiedererkennbar ist.
       Im Dock steht er neben dem Status-Reiter und braucht seinen Namen. */
    .station-body .ots-strip-text { display: inline; }
}


/* ═══════════════════════════════════════════════════════════════
   4. STATIONS-LAYOUTS — Spalten stapeln

   Das Projekt benennt jeden Layout-Container konsequent `*-layout`
   (62 Klassen) bzw. `*-columns` (8 Klassen). Darum reicht ein
   Attributselektor statt 70 Einzelregeln — und neue Stationen sind
   automatisch mitversorgt, solange sie sich an die Namenskonvention
   halten. Das ist der eigentliche Grund, diese Konvention zu pflegen.

   `min-width: 0` auf den Kindern ist kein Kosmetikzusatz: Grid- und
   Flex-Elemente haben per Default `min-width: auto`, koennen also
   nicht unter ihre Inhaltsbreite schrumpfen. Genau daran platzen
   Tabellen und lange Codes aus ihrer Spalte heraus.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 1023px) {
    .station-body [class*="-layout"],
    .station-body [class*="-columns"],
    .station-body .survey-main,
    .station-body .targeting-main-grid {
        grid-template-columns: minmax(0, 1fr);
        grid-template-areas: none;
        min-width: 0;
    }

    /* Drei Layoutcontainer sind keine Grids, sondern Flex-Zeilen
       (.ciws-dashboard-columns, .map-dashboard-columns,
       .emergency-dashboard-columns). Bei ihnen greift
       grid-template-columns nicht — sie brauchen die Achsendrehung.
       Alle uebrigen Flex-Layouts stehen ohnehin schon auf `column`,
       fuer die ist die Zeile ein No-op. */
    .station-body [class*="-layout"],
    .station-body [class*="-columns"] {
        flex-direction: column;
    }

    /* Harte Mindestbreiten aus dem Cockpit-Entwurf: im Stapel gibt es
       keine Nachbarspalte mehr, von der sie sich abgrenzen muessten. */
    .station-body .map-dashboard-columns > .map-main,
    .station-body .map-dashboard-columns > .map-sidebar {
        min-width: 0;
    }

    /* Layouts mit benannten Bereichen (z. B. .security-layout) setzen
       grid-area auf ihren Kindern. Ohne Bereichsraster ist die Angabe
       ungueltig und das Kind landet ausserhalb des Rasters. */
    .station-body [class*="-layout"] > [style*="grid-area"],
    .station-body [class*="-layout"] > * { grid-area: auto; }

    /* Seitenspalten, die als „Zusatzinfo" gedacht sind, gehoeren im
       Stapel unter die Hauptspalte — nicht davor. */
    .station-body .command-right { order: 3; }
}


/* ═══════════════════════════════════════════════════════════════
   5. KACHELRASTER — Spaltenzahl an die Breite koppeln

   Raster mit `repeat(auto-fill, minmax(Npx, 1fr))` regeln sich selbst
   und brauchen hier nichts. Problematisch sind nur die mit fester
   Spaltenzahl: repeat(4, 1fr) heisst auf 390px vier Kacheln zu 88px.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 599px) {
    .station-body .system-matrix,
    .station-body .systems-grid,
    .station-body .status-grid,
    .station-body .clamp-panel,
    .station-body .overlay-mode-grid,
    .station-body .slot-grid {
        grid-template-columns: repeat(2, minmax(0, 1fr));
        gap: var(--space-sm);
    }

    /* Drei gleich breite Schubstufen bleiben drei — nebeneinander
       gelesen sind sie eine Skala, untereinander nur eine Liste. */
    .station-body .throttle-presets {
        grid-template-columns: repeat(3, minmax(0, 1fr));
    }

    /* Zweispaltige Innenraster mit Fliesstext statt Knoepfen. Sie sind
       nicht die „grossen" Layouts aus §4, sondern sitzen in einem Panel
       — und sprengen es, weil ihre Kacheln (Deckname + Messzeilen,
       Stationsposten + Badge) mehr Mindestbreite haben als die halbe
       Panelbreite hergibt.

       Knopfpaare (.maneuver-buttons, .puzzle-options, .helm-form-grid)
       bleiben bewusst zweispaltig: zwei Knoepfe nebeneinander sind auch
       auf 360px noch gross genug und sparen eine Zeile. */
    .station-body .atmosphere-grid-inner,
    .station-body .station-presence-grid,
    .station-body .session-info,
    .station-body .cooling-readouts,
    .station-body .scan-candidates-grid,
    .station-body .field-row {
        grid-template-columns: minmax(0, 1fr);
    }

    .station-body .atmosphere-grid-inner > *,
    .station-body .station-presence-grid > *,
    .station-body .session-info > *,
    .station-body .cooling-readouts > * { min-width: 0; }
}


/* ═══════════════════════════════════════════════════════════════
   5b. EINZEILIGE LEISTEN — umbrechen lassen

   Reiterleisten, Kennzahlenzeilen und Knopfgruppen sind Flex-Zeilen
   ohne `flex-wrap`. Im Cockpit passen sie; im Stapel schieben sie ihre
   letzten Elemente aus dem Panel heraus — beim GM-Konsolen-Reiter sind
   das auf 390px fuenf von acht Reitern, die schlicht nicht mehr
   erreichbar sind.

   Statt die betroffenen Klassen einzeln zu sammeln, greift die Regel
   ueber die Namenskonvention des Projekts (`*-tabs`, `*-metrics`,
   `*-controls`, `*-actions`, `*-buttons`). Umbrechen ist die
   gutmuetige Variante: passt die Zeile, passiert nichts.

   Die Ausnahme ist wichtig: `.nav-layout--controls`,
   `.comms-layout--main` und Geschwister sind SPALTEN, keine Zeilen.
   `flex-wrap: wrap` macht aus einem Spalten-Flexcontainer einen
   mehrzeiligen — und dann richtet sich die Breite jeder Zeile nach
   dem breitesten Kind statt nach dem Container. Die Panels der
   Navigation wurden dadurch 36px breiter als ihre Spalte.

   Ohne Media Query, aus demselben Grund wie §1b: die Kennzahlenzeile
   der Kuehlpumpe laeuft auch im Cockpit-Modus aus ihrer Karte heraus.
   Wo die Zeile passt, aendert `wrap` nichts.
   ═══════════════════════════════════════════════════════════════ */

.station-body .station-main :is(
    [class*="-tabs"],
    [class*="-metrics"],
    [class*="-controls"],
    [class*="-actions"],
    [class*="-buttons"],
    [class*="-toolbar"]
):not([class*="-layout"]):not([class*="-columns"]) {
    flex-wrap: wrap;
}


/* ═══════════════════════════════════════════════════════════════
   6. ZEILEN-RASTER — Wert-Zeilen umbrechen lassen

   `.repair-item` (24px 1fr 48px auto auto auto) und `.breach-item`
   (1fr 120px 60px auto) sind Tabellenzeilen in Grid-Form: Name,
   Kennzahlen, Aktionsknopf. Sechs Spalten auf 360px ergeben
   unlesbare 40px-Saeulen.

   Im Kompaktmodus werden sie zu umbrechenden Flex-Zeilen: Name auf
   eine eigene Zeile, darunter die Kennzahlen, der Knopf rechts
   aussen. Kein Inhalt geht verloren, die Zeile wird nur zwei hoch.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 599px) {
    .station-body .repair-item,
    .station-body .breach-item,
    .station-body .alloc-row,
    .station-body .vital-item,
    .station-body .event-entry,
    .station-body .gm-activity-entry {
        display: flex;
        flex-wrap: wrap;
        align-items: center;
        gap: var(--space-xs) var(--space-sm);
    }

    /* Der Name traegt die Zeile — er bekommt sie ganz. */
    .station-body .repair-item > .repair-name,
    .station-body .breach-item > .breach-section {
        flex: 1 0 100%;
        font-weight: 600;
    }

    /* Aktionen an den rechten Rand, damit der Daumen sie findet. */
    .station-body .repair-item > button,
    .station-body .breach-item > button {
        margin-left: auto;
    }
}


/* ═══════════════════════════════════════════════════════════════
   6b. FORMULARE IM STAPEL

   Sobald die Seitenspalte unter die Hauptspalte rutscht, steht jedes
   Eingabefeld ueber die volle Panelbreite. Ein 760px breites Feld fuer
   einen Vornamen sieht nicht nach „mehr Platz" aus, sondern nach
   kaputtem Layout — und der Blick muss zwischen Label links und
   Cursor ganz links doppelt so weit springen.

   Auf dem Telefon bleibt volle Breite richtig: dort ist sie ohnehin
   schmal genug, und ein angeschnittenes Feld waere schlimmer.
   ═══════════════════════════════════════════════════════════════ */

@media (min-width: 600px) and (max-width: 1023px) {
    .station-body .station-main input[type="text"],
    .station-body .station-main input[type="number"],
    .station-body .station-main input[type="search"],
    .station-body .station-main select,
    .station-body .station-main textarea {
        max-width: 32rem;
    }
}


/* ═══════════════════════════════════════════════════════════════
   7. TABELLEN — horizontal scrollen statt die Seite sprengen

   Eine Spielerliste mit acht Spalten laesst sich auf 390px weder
   umbrechen noch sinnvoll kuerzen. Sie bekommt einen eigenen
   Scrollbereich: die Tabelle scrollt, die Seite nicht.

   `display: block` auf dem <table> erzeugt die Scrollbox; die
   Zeilengruppen bilden darin eine anonyme Tabelle und behalten ihre
   Spaltenausrichtung.
   ═══════════════════════════════════════════════════════════════ */

/* Als einzige Regel bis 1366px statt bis 1023px: ein 12,9"-Tablet im
   Querformat hat 1366px und steht damit im Cockpit-Modus — die
   Spielerliste (8 Spalten) passt aber auch dort nicht in ihre Spalte
   neben dem Anlegen-Formular. Oberhalb bleibt die Tabelle unveraendert,
   damit schmale Tabellen am Bruecken-Bildschirm weiter die Panelbreite
   fuellen statt auf Inhaltsbreite zusammenzufallen. */
@media (max-width: 1366px) {
    .station-body .station-main table {
        display: block;
        width: 100%;
        max-width: 100%;
        overflow-x: auto;
        overscroll-behavior-x: contain;
    }

    /* Ueberschriften duerfen nicht umbrechen — eine einzeilige
       Kopfzeile ist der Ankerpunkt beim seitlichen Scrollen. */
    .station-body .station-main thead th { white-space: nowrap; }
}


/* ═══════════════════════════════════════════════════════════════
   8. GRAFIKEN — SVG, Radar, Karten

   Sektorkarte, Radar und Schildsektoren sind SVGs mit viewBox. Ohne
   `width: 100%` rendern sie in ihrer intrinsischen Breite und ziehen
   die Seite auf.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 1023px) {
    .station-body .station-main svg:not([class*="icon"]):not(.ds-icon) {
        max-width: 100%;
        height: auto;
    }

    .station-body .station-main canvas,
    .station-body .station-main img {
        max-width: 100%;
    }

    /* Vorformatierte Blöcke (Logausgaben, Telemetrie-Dumps) scrollen
       in sich, statt die Seite breit zu machen. */
    .station-body .station-main pre { overflow-x: auto; }
}


/* ═══════════════════════════════════════════════════════════════
   9. TOUCH-METRIK

   controls-v2.css hebt bereits die benannten Button-Klassen auf 48px.
   Was dort fehlt, sind die namenlosen Bedienelemente: <button> ohne
   Klasse, Checkboxen, Radios, Links in Tabellenzellen.

   Bewusst an `pointer: coarse` und nicht an die Breite gehaengt: ein
   22"-Touchmonitor auf der Bruecke ist breit UND wird mit dem Finger
   bedient.
   ═══════════════════════════════════════════════════════════════ */

@media (pointer: coarse) {
    .station-body .station-main button,
    .station-body .station-main a[class*="btn"],
    .station-body .station-main label[for] {
        min-height: 44px;
    }

    .station-body .station-main input[type="checkbox"],
    .station-body .station-main input[type="radio"] {
        width: 22px;
        height: 22px;
    }

    /* Schieberegler sind mit dem Finger nur zu treffen, wenn die
       Bahn dick genug ist. */
    .station-body .station-main input[type="range"] { height: 32px; }

    /* Links in Tabellen: Zeilenhoehe statt Schriftgroesse vergroessern,
       damit die Tabelle nicht auseinanderfaellt. */
    .station-body .station-main td a { display: inline-block; padding: 6px 0; }

    /* Der Reiter des unteren Docks ist ein Daumenziel. */
    .station-body .gsp-tab,
    .station-body .ots-strip-tab { min-height: 48px; }
}


/* ═══════════════════════════════════════════════════════════════
   10. DIALOGE & OVERLAYS

   Notfallprozeduren, Puzzle-Blocker und Stations-Blocker sind
   zentrierte Boxen mit fester Breite. Auf dem Telefon muessen sie die
   Breite nutzen und selbst scrollen koennen — ein Puzzle, dessen
   Bestaetigungsknopf unter der Bildschirmkante liegt, blockiert die
   Station dauerhaft.
   ═══════════════════════════════════════════════════════════════ */

@media (max-width: 1023px) {
    .station-body .puzzle-overlay-blocker,
    .station-body .station-block-overlay,
    .station-body .emergency-overlay {
        padding: var(--space-sm);
        padding-bottom: calc(var(--dock-h) + var(--safe-b));
        overflow-y: auto;
        overscroll-behavior: contain;
    }

    .station-body .puzzle-blocker-content,
    .station-body .station-block-card,
    .station-body .emergency-dialog {
        width: 100%;
        max-width: 100%;
        max-height: 80dvh;
        overflow-y: auto;
        overscroll-behavior: contain;
    }

    .station-body .emergency-dialog { padding: var(--space-lg); }
}


/* ═══════════════════════════════════════════════════════════════
   11. QUERFORMAT AUF DEM TELEFON

   Ein Telefon quer hat ~390px Hoehe. Alarmleiste + Kopfzeile fressen
   davon die Haelfte, bevor die Station anfaengt. Dort wird der Kopf
   auf eine Zeile eingedampft.
   ═══════════════════════════════════════════════════════════════ */

@media (max-height: 460px) and (orientation: landscape) {
    .station-body .station-header {
        flex-wrap: nowrap;
        padding: 2px var(--space-sm);
    }

    .station-body .station-heading { flex: 0 1 auto; }
    .station-body .station-heading h1 { font-size: var(--text-base); }
    .station-body .station-crew-sub,
    .station-body .station-breadcrumb { display: none; }
    .station-body .alert-bar { padding-block: 1px; }
    .station-body .station-main { padding-top: var(--space-sm); }
}


/* ═══════════════════════════════════════════════════════════════
   12. DRUCK

   GM-Karten und BDA-Berichte werden am Spieltisch ausgedruckt. Das
   Dock und die Statusleisten gehoeren nicht aufs Papier.
   ═══════════════════════════════════════════════════════════════ */

@media print {
    .station-shell { padding: 0; }
    .gsp,
    .ots-task-strip,
    .sound-panel,
    .station-crew { display: none; }
}
