/* ============================================================
   Split din app.css pe layer/audienta (audit 2026-08-06 SF, ADR 0023).
   Precedenta layerelor (ultimul castiga): vendor < app < kf (tokens..utilities).
   Ordinea @layer e declarata IDENTIC in capul fiecarui fisier -
   prima declaratie stabileste ordinea, repetarea e no-op.
   ATENTIE: ordinea <link>-urilor e CONTRACT de cascada (intra-layer
   castiga ultimul incarcat): tokens, scoreboard, components, admin,
   base-layout, site-palette; juratul: tokens, judge, base-layout.
   NU adauga/reordona <link>-uri fara audit de coliziuni (ADR 0023).
   scoreboard.css - S8 BRACKET/scorecard/podium + S10c CATEGORY SHOW.
   ============================================================ */
@layer vendor, app, tokens, base, layout, components, utilities;

@layer app {
/* === 8. BRACKET ============================================ */

/* ── Pagina categorie LATĂ (fără sidebar, container extins pt bracket) ──
   Regula `.page-wide .app-wrap { max-width: 1600px }` a plecat de aici (B68): a devenit un remap de
   `--container-max` pe `body.page-wide` (base-layout.css § 2 LAYOUT), ca bara și subsolul să urce
   odată cu conținutul — altfel conținutul ieșea cu 400px în afara lor.
   ⚠ NU o reintroduce aici: are specificitate 0-2-0 și ar bate tăcut tokenul (0-1-0), indiferent că
   base-layout.css se încarcă mai târziu. Rezultatul ar fi bara și subsolul late, wrapperul condus
   din altă sursă, și orice reglaj din token părând fără efect. */

/* Filtrul „Ale mele" (mine-filter.js): body[data-mine-only] ascunde cardurile străine.
   CSS-driven — compune cu archive-filter.js (care umblă la style.display pe altă axă). */
body[data-mine-only] [data-mine="0"] { display: none !important; }
/* Starea goală a filtrului (B197): serverul o randează doar când nimic de pe tab nu e al tău; se vede doar sub filtru. */
.mine-empty { display: none; }
body[data-mine-only] .mine-empty { display: block; }

/* ── Banda de categorii = NAVIGAȚIA paginii de concurs, și SUBTITLUL ei: pastila selectată poartă numele
      categoriei, formatul și diviziunile, fiindcă `h2.res-cat-name` le repeta exact (șters 2026-08-15).
      Antetul mare de concurs = .res-hero via _contest_head. ──

   UN SINGUR RÂND CARE SCROLLEAZĂ, niciodată două rânduri stivuite: cu wrap, poziția fiecărui element
   se mută la orice redimensionare, deci memoria spațială moare (NN/g „Use Only One Row of Tabs";
   Material 3 „when a set of tabs cannot fit on screen, use scrollable tabs").

   Mecanica de derulare + estomparea + capul de bandă (etichetă/număr/săgeți) + butonul „›" de la capăt NU
   stau aici: sunt `.rail` / `.rail-fade` / `.rail-nav__*` în components.css, refolosite de toate benzile
   (categorii, tab-uri admin, clasament). Aici rămâne DOAR ce e al categoriilor.

   PASTILE, nu taburi „folder" (B218, ADR 0059 — prototipul v4 aprobat de owner pe 2026-10-05, pe randarea
   reală; sinteza B158 Mo2/Mo3/M7). Tabul folder avea trei defecte MĂSURATE: ținta de 33px (sub pragul de
   deget), activul cu ~10% mai LAT decât inactivii (banda se rearanja la fiecare click) și o șină de jos
   care, prelungită în „L"-ul lui `.cat-block`, desena un cadru în jurul conținutului (cast-ui: fără rame
   decorative). Pastila: 44px, ACEEAȘI mărime, greutate și familie în ambele stări (Material 3 / Carbon /
   Apple HIG: selecția schimbă culoarea, nu mărimea), selectată = umplerea de identitate (ADR 0057 — „starea
   activă"), inactivă = treapta tonală s2. Au murit odată cu șina: linia de bază a benzii (`inset 0 -3px`),
   treapta de 3px („folder"), firul de 1px dintre taburi și regula „frații de după activ" (`--on ~`).
   ⚠️ Tipografia pastilei stă AICI, într-o singură regulă pentru ambele stări — nu mai e în registrul de
   roluri din components.css (ETICHETĂ pentru inactiv / SUBTITLU pentru activ), tocmai ca activul și inactivul
   să nu mai poată diverge ca mărime. */

/* LIPITĂ sub bara de navigație: pe telefon categoriile rămân la un deget distanță oricât de jos derulezi în
   bracket (prototipul v3; ownerul: „cât mai multe indicii că acolo avem o bandă de scrollat"). `z-index` peste
   conținut (bracketul are stacking contexts proprii); fundal OPAC, altfel conținutul derulat se vede prin ea.
   ⚠️ NICIUN `position: relative` mai jos pe `.cat-nav`: ar anula lipirea și, cu `top` rămas, ar coborî banda
   cu `--nav-h` (prins la măsurătoarea prototipului v2). Butonul „›" absolut își ia blocul conținător chiar din
   `sticky`. Pe proiector banda e ascunsă (components.css, `.live-projector .cat-nav`). */
.cat-nav {
    position: sticky; top: var(--nav-h); z-index: 20;
    background: var(--ui-page);
    margin-top: 0; margin-bottom: 0; padding-top: .3rem;
}
/* Rândul de pastile: 8px între ele (B158 Mo2); aer sus/jos ca inelul de focus să nu fie tăiat de
   `overflow-x: auto` (memoria „inelul de focus tăiat de overflow-ul strămoșului"). `stretch` (B219, alegerea
   ownerului „egale"): când o pastilă are două rânduri (diviziuni), toate iau înălțimea ei — un rând uniform,
   nu dințat; conținutul se centrează vertical în fiecare. */
.cat-strip { display: flex; align-items: stretch; gap: .5rem; padding-block: .2rem .45rem; }
.cat-strip__item {
    flex: 0 0 auto; scroll-snap-align: start;
    /* COLOANĂ (B219): rândul 1 = punct · nume · format · [Live]; rândul 2 (`.cat-strip__l2`), DOAR unde există
       diviziuni. Pe un rând rămâne 44px; cu două ≈ 52px (11.2 padding + 16.8 nume + 4 gap + 20.4 cip), măsurat 52. */
    display: inline-flex; flex-direction: column; align-items: flex-start; justify-content: center; gap: .25rem;
    /* ⚠️ ȚINTĂ DE TAP: pastila e un link întreg; 44px e podeaua, paddingul dă lățimea de citire. */
    min-height: var(--tap-min); padding: .35rem 1rem;
    /* B234 (Arena): categoriile = PLĂCI (colț de card), nu pastile — pastila rămâne pentru stare (Live, diviziuni). */
    border-radius: var(--radius-card, 4px);
    background: var(--ui-raised); color: var(--ui-ink);   /* B226: pastila stă pe pagină — tonul cardului (pe s2: 1.09) */
    text-decoration: none; white-space: nowrap;
}
/* Hoverul = doar treapta de fundal: fără ramă (B195 L4), nu are ce muchii să aprindă. */
.cat-strip__item:hover { background: var(--ui-quiet); color: var(--ui-ink); }
/* Punctul de STIL (B195 L4) · numele · formatul · diviziunile · [Live] — un singur rând, pe linia de bază. */
/* 16px (B219, ownerul după validarea pe telefon: numele se citea slab la 14 / 600 lângă cipul de diviziune). B234 (macheta Arena):
   numele = titlu de afiș — majuscule, 900, CONDENSAT. Lățimea condensată (75%) ține banda cât era în sentence case (majusculele
   o lățeau cu ~12% — argumentul vechi M3 / HIG / Carbon pentru sentence case); cipul de diviziune rămâne mono, deci se deosebește
   prin familie. Formatul rămâne la 500 — ierarhia din placă. */
.cat-strip__l1 {
    display: inline-flex; align-items: baseline; gap: .35rem;
    font-family: var(--font-display); font-weight: 900; font-stretch: var(--ar-wdth); font-size: var(--font-lg); line-height: 1.2;
    text-transform: uppercase; letter-spacing: 0;
}
.cat-strip__fmt { color: var(--ui-ink-muted); font-weight: 500; }
/* SELECTATĂ = umplerea de identitate + cerneala ei (ADR 0054 §5: „categoria = umplere, vederea = subliniere").
   Nimic altceva nu se schimbă — lățimea pastilei rămâne, vecinii nu se mișcă. */
.cat-strip__item--on,
.cat-strip__item--on:hover { background: var(--ui-accent-fill); color: var(--ui-on-accent-fill); }
/* Pe umplerea violet punctul de stil primește un INEL ALB — altfel o nuanță de stil apropiată de violet s-ar
   topi în pastilă. */
.cat-strip__item--on .style-dot { box-shadow: 0 0 0 2px var(--ui-on-accent-fill); }
/* G1b: formatul ATENUAT pe umplere (ownerul: „nu se mai vede fade-ul de culoare pe format") — 4.73, peste prag. */
.cat-strip__item--on .cat-strip__fmt { color: var(--ui-on-accent-fill-muted); opacity: 1; }
/* „LIVE" pe pastila categoriei care SE DANSEAZĂ (B218; B158 J6: roșu + cuvântul scris; H5: singura stare care
   variază între surori, deci fără „✓ GATA" pe fiecare). Nu e `.now-tag`: acela spune „aici se întâmplă", ăsta
   doar marchează CARE. Umplerea = `--sm-live-mark` (roșul care URMEAZĂ tema: pe dark urcă pe scara tonală,
   fiindcă `--sm-live` dă 2.54 pe s2), cu cerneala ei `--sm-on-live-mark`; perechile sunt în contrast-audit.php. */
.cat-strip__live {
    display: inline-flex; align-items: center; gap: .3rem; align-self: center;
    padding: .1rem .5rem; border-radius: var(--radius-status, 999px);
    background: var(--ui-live-mark); color: var(--ui-on-live-mark);
    font-family: var(--font-display); font-weight: 800; font-size: var(--font-2xs); line-height: 1.3;
    text-transform: uppercase; letter-spacing: .06em;
}
.cat-strip__live::before { content: ""; width: .4rem; height: .4rem; border-radius: 50%; background: currentColor; }
/* Pe pastila SELECTATĂ (violet, aceeași în ambele teme) insigna se INVERSEAZĂ: alb cu roșu — roșu plin pe violet
   ar fi fost o pată (1.5:1), iar albul e deja cerneala umplerii (6.04). */
.cat-strip__item--on .cat-strip__live { background: var(--ui-on-live); color: var(--ui-live); }
/* RÂNDUL 2 = DIVIZIUNILE (B219): cipurile `.cat-disc` ale categoriei — rețeta („pe negativ", 12px, fără chenar) e a
   COMPONENTEI, în components.css § CHIPS, aceeași pe cardul de pe /concursuri și în titlul modalului de înscriere (SSOT);
   aici doar așezarea. Perechile text-hi / s2 și on-primary / primary sunt în audit. */
.cat-strip__l2 { display: flex; flex-wrap: wrap; gap: .3rem; }
/* Pe pastila SELECTATĂ: alb cu violet — cerneala umplerii (6.04, perechea „tab activ / buton plin"). (0,3,0): peste baza
   componentei (0,1,0) și peste orice (0,2,0) care ar mai apărea în components.css, foaie încărcată după. */
.cat-strip__item--on .cat-strip__l2 .cat-disc { background: var(--ui-on-accent-fill); color: var(--ui-accent-fill); }

/* ── CONȚINUTUL CATEGORIEI SELECTATE. Până la B218 blocul purta „L"-ul verde (șină în stânga + linia benzii)
   ca legătură vizuală între tabul aprins și conținutul lui. Legătura o face acum ORDINEA: comutatorul
   Calificare | Bracket stă primul, sub pastile, apoi line-up + juriu, apoi conținutul vederii alese.
   RITMUL: secțiunile dinăuntru nu se ating (raport user: „calificările și bracketul sunt lipite de line-up").
   `--cat-gap` = pasul fluid, din aceeași scară peste tot — declarat și pe `.cat-panels`, care îl citea fără
   să-l aibă (regulă MOARTĂ până la B218: `var()` nedefinit → 0; aerul venea din `pt-2`, azi șters). */
.cat-block, .cat-panels { --cat-gap: clamp(.85rem, 2.5vw, 1.5rem); }
.cat-block { padding: var(--cat-gap) 0; }
/* `margin-block`, NU shorthandul `margin`: pe proiector capul e centrat cu `margin-inline: auto` (components.css), aceeași
   specificitate — un `margin` de aici l-ar bate sau nu după ordinea foilor, nu după intenție. */
.cat-block .res-cat-head { margin-block: .35rem 0; }
/* Aerul dintre juriu și conținutul vederii = DOUĂ trepte (paddingul de jos al blocului + paddingul de sus al panourilor,
   27px la 360 / 48px pe lat) — geometria prototipului aprobat, care o avea tot din două bucăți (marginea capului + blocul)
   plus `pt-2`. `pt-2` a plecat; dacă aerul pare prea mare, scoate O treaptă, nu adăuga alta. */
.cat-panels .tab-content { padding-top: var(--cat-gap); }

/* ── „ACUM SE ÎNTÂMPLĂ AICI" (public/_live_signpost.html.twig) — semn, nu redirect.
   Bandă lată, apăsabilă pe toată suprafața: e singurul lucru din pagină care răspunde la „ce
   trebuie să fac eu acum". Volt DOAR aici și pe tabul activ; punctul pulsă ca `.page-state__dot`,
   fiindcă aici înseamnă chiar LIVE.

   UN SINGUR RÂND, până la 320px (raport user: ocupa patru rânduri pe telefon și anula exact
   înălțimea câștigată în antet). `nowrap` peste tot + `min-width: 0` pe numele categoriei, care e
   singurul element elastic: el absoarbe strâmtoarea cu `…`, restul rămân întregi.
   Pragul la care cade starea e o INTEROGARE DE CONTAINER, nu `@media`: banda stă în antet ca o
   coloană de ~16rem chiar și pe un ecran de 1600px, deci lățimea ecranului n-are ce spune despre ea. */
.live-sign {
    container-type: inline-size;
    display: flex; flex-wrap: nowrap; align-items: center; gap: .35rem clamp(.4rem, 2vw, 1.2rem);
    margin: 0 0 .85rem; padding: .5rem .75rem;
    /* ⚠️ ȚINTĂ DE TAP: linkul ăsta e un control întreg; podeaua e EXPLICITĂ (`--tap-min`), nu dedusă
       din padding + chenar ca înainte de B218 (estimarea de atunci: 44.4px la 390px). */
    min-height: var(--tap-min);
    /* B218 (ADR 0059): ACELAȘI aspect ca bannerul de stare de deasupra bracketului (`.live-status--live`,
       B195 L3, validat de owner) — tenta de live ca fundal, FĂRĂ chenar, FĂRĂ umbră: e un semnal despre
       „ce se întâmplă acum", nu un card. Chenarul de 1px și `--sm-elev-card` au fost ȘTERSE (nu puse pe 0).
       Hoverul nu schimbă fundalul: semnul nu e o suprafață care se ridică. */
    background: var(--ui-live-tint);
    color: var(--ui-ink); text-decoration: none;
    border-radius: var(--radius-lg); }
.live-sign:hover { background: var(--ui-live-tint); color: var(--ui-ink); }
/* ── `.now-tag` = SSOT pentru marcajul „ACUM SE ÎNTÂMPLĂ AICI". Apare în două locuri: banda de
   semnalizare de pe pagina de concurs și rândul categoriei care rulează, în cardurile de pe
   /concursuri. Un singur loc, ca cele două să nu poată diverge.
   Umplere `--status-active-bg` (volt) cu cerneală deasupra — volt-ul ca FUNDAL e corect (14.65:1);
   pulsul e cel de la `.page-state__dot`, fiindcă aici chiar înseamnă LIVE. */
.now-tag {
    display: inline-flex; align-items: center; gap: .4rem; flex: none;
    font-family: var(--font-display); font-weight: var(--type-status-weight, 900);
    text-transform: var(--type-status-case, uppercase); letter-spacing: var(--type-status-tracking, .08em); font-size: var(--font-sm);
    background: var(--ui-live); color: var(--ui-on-live);
    padding: .1rem .5rem;
border-radius: var(--sm-r-pill); }
.now-tag__dot {
    width: .5rem; height: .5rem; border-radius: 50%; background: currentColor;
    animation: page-state-pulse 1.2s ease-in-out 3;
}
.live-sign__what { display: flex; flex-wrap: nowrap; align-items: baseline; gap: .15rem .5rem; min-width: 0; }
/* Singurul element elastic din bandă: se taie cu `…` când nu mai e loc. Mărimea e fluidă fiindcă la
   320px un titlu de 18px ar mânca singur jumătate din rând. */
.live-sign__cat {
    min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
    font-family: var(--font-display); font-weight: var(--type-title-weight, 700); font-stretch: var(--ar-wdth);
    text-transform: var(--type-title-case, uppercase); letter-spacing: var(--type-title-tracking, .02em);
    font-size: clamp(var(--font-base), 3.2vw, var(--font-xl));
}
.live-sign__st {
    flex: none; color: var(--ui-ink-muted);
    font-family: var(--font-mono); font-weight: 700; font-size: var(--font-2xs); letter-spacing: var(--type-status-tracking, .04em);
}
.live-sign__st::before { content: "·"; margin-inline-end: .35rem; }
.live-sign__go {
    flex: none; margin-inline-start: auto;
    display: inline-flex; align-items: center; gap: .35rem;
    font-family: var(--font-display); font-weight: 700;
    text-transform: var(--type-control-case, uppercase); letter-spacing: var(--type-control-tracking, .05em); font-size: var(--font-xs);
    background: var(--ui-ink); color: var(--ui-page);
    padding: .3rem .7rem; white-space: nowrap;
border-radius: var(--sm-r-pill); }
/* Sub pragul ăsta rămân numele categoriei și butonul — starea e derivabilă în două secunde, după ce
   omul ajunge acolo; numele și acțiunea nu sunt. */
@container (max-width: 26rem) {
    .live-sign__st { display: none; }
}
.live-sign:hover .live-sign__go { background: var(--ui-ink); color: var(--ui-page); font-weight: 700; border-radius: var(--sm-r-pill); }

/* Coloana își ia baza din scala comună (`--bk-colw`), nu dintr-o pereche de px fixe. Podeaua de
   2.4rem e ce face un Top-32 să încapă pe telefon; plafonul e exact lățimea de dinainte (190px). */
/* ⚠️ Plafonul trebuie să urce cu `--scale-cap`, ca `--bk-colw`. Până pe 2026-08-27 era `11.875rem`
   FIX, iar `max-width` bate `flex-basis` — deci amendamentul 1 din ADR 0041 (scara ×2 pe proiector)
   era ANULAT exact pe lățimea coloanei: un Top-8 (5 coloane) nu putea trece de ~950px oricât de lat
   era ecranul. Așa arătau amândouă reclamațiile userului — „baleierea poate ocupa mai mult
   stânga-dreapta" și „un Top 8 rămâne în mijlocul ecranului": o singură cifră, două simptome.
   Pe public `--scale-cap` e 1, deci nimic nu se schimbă — podeaua de 2.4rem, cea care face un Top-32
   să încapă pe telefon, rămâne neatinsă. */
.bk-col {
    display: flex;
    flex-direction: column;
    flex: 1 1 var(--bk-colw, 96px);
    min-width: 2.4rem;
    max-width: calc(11.875rem * var(--scale-cap, 1));
}
.bk-col-label {
    font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .07), calc(var(--font-xs) * var(--scale-cap, 1)));
    /* B234 (Arena): eticheta de coloană = titlu de afiș (condensat, 900, majuscule), nu etichetă. */
    font-family: var(--font-display); font-weight: 900; font-stretch: var(--ar-wdth);
    text-transform: uppercase;
    letter-spacing: -.005em;
    color: var(--ui-ink-muted);
    text-align: center;
    padding: clamp(.1rem, calc(var(--bk-u, 12rem) * .035), calc(.35rem * var(--scale-cap, 1))) clamp(.1rem, calc(var(--bk-u, 12rem) * .05), calc(.5rem * var(--scale-cap, 1))) clamp(.15rem, calc(var(--bk-u, 12rem) * .05), calc(.5rem * var(--scale-cap, 1)));
    border-bottom: 1px solid var(--ui-hair);
    margin-bottom: .5rem;
}
.bk-col-label--active { color: var(--ui-ink); background: transparent; border-bottom-color: var(--ui-live-mark); }
.bk-col-label--done   { color: var(--ui-ink-muted); border-bottom-color: var(--ui-hair); }

.bk-col-body {
    display: flex;
    flex-direction: column;
    flex: 1;
}

/* Fiecare battle = un slot flex egal, conținut centrat → runda cu N/2 matchuri
   pică fix la mijlocul dintre cei 2 feederi din runda dinainte. */
.bk-match {
    flex: 1;
    display: flex;
    flex-direction: column;
    justify-content: center;
    position: relative;
}

/* ── PRIMUL RÂND (T32) = FĂRĂ overlap → conector OUTGOING curat din marginea feederului.
   Brațul pleacă din muchia dreaptă a cardului (left:100%) și ajunge la bara verticală (merge point)
   la --bk-firstarm. De acolo, o linie de legătură (--bk-childlink) merge până în cardul T16. */
.bk-col--first .bk-match--up::after,
.bk-col--first .bk-match--down::after {
    content: '';
    position: absolute;
    left: 100%;
    width: var(--bk-firstarm);
    height: 50%;
    border-right: 2px solid var(--ui-line);
}
.bk-col--first .bk-match--up::after   { top: 50%;    border-top: 2px solid var(--ui-line); border-top-right-radius: 6px; }
.bk-col--first .bk-match--down::after { bottom: 50%; border-bottom: 2px solid var(--ui-line); border-bottom-right-radius: 6px; }
.bk-col--first .bk-match--straight::after {
    content: '';
    position: absolute;
    left: 100%;
    top: 50%;
    width: var(--bk-firstarm);
    border-top: 2px solid var(--ui-line);
}
/* ⚠️ BUG VECHI, reparat de skin si coborat aici la B159 L10 (F2): cele TREI reguli de deasupra
   (`--up`, `--down`, `--straight`) au (0,2,1) si bat `.bk-match--resolved::after` (0,1,1), deci
   bratele primului tur ramaneau GRI si dupa meci. Regula asta are aceeasi specificitate ca ele si
   vine DUPA toate trei — de aceea castiga. Doar culoarea: geometria conectorilor
   (left/top/width/height) ramane mai sus.
   ⚠️ ORDINEA E REGULA, nu o intamplare. La coborarea din `@layer skin` regula a aterizat intre
   `--down` si `--straight`, iar `--straight` isi rescria `border-top` — deci pe meciurile DREPTE din
   prima coloana bratul castigatorului ramanea gri. Gasit abia de sonda pe paginile AUTENTIFICATE
   (2026-09-24): bracketul cu meci drept rezolvat in prima coloana apare doar pe concursul live al
   organizatorului. Daca adaugi inca o regula de conector in prima coloana, pune-o INAINTEA asteia. */
.bk-col--first .bk-match--resolved::after { border-color: var(--ui-win-ink); }
/* linia de legătură de la merge point în cardul copil (T16) — ca să nu fie lipit de bracket */
.bk-col--second .bk-match::before {
    content: '';
    position: absolute;
    left: calc(var(--bk-childlink) * -1);
    top: 50%;
    width: var(--bk-childlink);
    border-top: 2px solid var(--ui-line);
}
.bk-col--second .bk-match--resolved::before { border-color: var(--ui-win-ink); }

/* ── COLOANELE 3+ = overlap → conector „merge" (.bk-merge) pe matchul avansat:
   o LINIE verticală întinsă între CENTRELE celor 2 feederi (25%→75%) + cot scurt în card.
   Capetele sunt pur PROCENTUALE (sloturile flex egale țin centrele la 25%/75% indiferent de
   înălțimea cardului — ex. nume pe 2 rânduri); linia trece PE SUB cardurile feeder
   (z-index: .bk-battle=2 peste .bk-merge=1) → pare că iese din muchia cardului. */
.bk-merge {
    position: absolute;
    left: calc(var(--bk-arm) * -1);
    top: 25%;
    bottom: 25%;
    z-index: 1;
    border-left: 2px solid var(--ui-line);
}
/* cot scurt din linie în card, la jumătatea matchului avansat */
.bk-col:not(.bk-col--first):not(.bk-col--second):not(.bk-col--final):not(.bk-col--plain) .bk-match::after {
    content: '';
    position: absolute;
    left: calc(var(--bk-arm) * -1);
    top: 50%;
    width: var(--bk-arm);
    border-top: 2px solid var(--ui-line);
}
/* match rezolvat → linie + cot verzi (calea câștigătorului) */
.bk-match--resolved .bk-merge,
.bk-match--resolved::after { border-color: var(--ui-win-ink); }

/* Card battle — z-index 2 = peste liniile merge (vezi comentariul .bk-merge)
   B195 (prototipul fluxului live, confirmat de owner): nodul se desprinde prin SUPRAFAȚĂ + UMBRĂ, fără ramă
   (ADR 0057 §4; rolul `--sm-node-edge` a plecat odată cu ea). Rămâne un contur TRANSPARENT, pe `outline` cu
   offset negativ: nu ia loc și nu lasă un inel de card în jurul rândului lime, iar în forced-colors
   transparentul devine CanvasText — acolo nodul își păstrează conturul (tehnica „transparent outline").
   ⚠️ FĂRĂ `overflow: hidden` (B195): eticheta LIVE / URMEAZĂ stă călare pe muchia de sus, iar brațele
   finalei (`.bk-col--final .bk-battle::before/::after`) ies în lateral — amândouă erau tăiate. Colțurile
   rotunde ale rândurilor colorate le dau rândurile însele (`.bk-entry:first-of-type` / `:last-of-type`). */
.bk-battle {
    outline: 1px solid transparent; outline-offset: -1px;
    border-radius: var(--radius-sm);
    background: var(--ui-raised);
    /* Aerul dintre battle-uri în aceeași coloană. Coeficientul și tavanul au crescut pe 2026-08-27
       (userul: „să mărim puțin spațiul dintre bracketuri, că e foarte strâns") — înainte ieșeau
       maximum 6px pe proiector, adică practic lipite. Podeaua de 1px rămâne: ea ține Top-32 pe
       telefon. E singura pârghie de spațiere verticală — coloanele sunt flex cu sloturi egale
       (`.bk-match { flex: 1 }`), fără `gap`. */
    margin: clamp(1px, calc(var(--bk-u, 12rem) * .04), calc(7px * var(--scale-cap, 1))) 0;
    position: relative;
    z-index: 2;
    transition: box-shadow .1s;
    box-shadow: var(--ui-shadow-raised);
    /* Mărimea etichetei de stare (`.state-tag`) — din aceeași scală ca restul nodului (`--bk-u`). */
    --state-tag-fs: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .055), calc(var(--font-3xs) * var(--scale-cap, 1)));
}
/* Stările (B195): LIVE = tenta live + muchia roșie de sus; URMEAZĂ = muchia violet de identitate (starea
   „selectată" din bugetul violetului, cast-ui regula 2) peste umbra obișnuită. Nejucat și terminat = nodul
   de bază: terminatul se citește din rândul câștigătorului și din căsuțele de scor, nu din fundal. */
.bk-battle--active    { background: var(--ui-live-tint); color: var(--ui-ink); box-shadow: inset 0 3px 0 var(--ui-live-mark); }
.bk-battle--golden    { box-shadow: inset 0 3px 0 var(--ui-warning); color: var(--ui-ink); background: var(--ui-live-tint); }
.bk-battle--next      { box-shadow: inset 0 3px 0 var(--ui-accent-fill), var(--ui-shadow-raised); }
/* ---- Hover pe cardul de meci ----
   Doar pe cardul care SE DESCHIDE (`--expandable`): un hover pe un nod nejucat promitea un click care nu face
   nimic. Ridicarea = umbra de plutire, nu o ramă.
   ⚠️ Ordinea din blocul asta e CONTRACT: `.bk-battle--expandable:hover` și `.bk-battle--active:hover` au
   aceeași specificitate (0,2,0), deci decide poziția. Stările (LIVE, departajare) se repetă cu `:hover`
   tocmai ca hoverul neutru să nu le stingă — de-aia stau DUPĂ el. */
.bk-battle--expandable:hover { box-shadow: var(--ui-shadow-float); }
.bk-battle--active:hover { background: var(--ui-live-tint); color: var(--ui-ink); box-shadow: inset 0 3px 0 var(--ui-live-mark); }
.bk-battle--golden:hover { background: var(--ui-live-tint); color: var(--ui-ink); box-shadow: inset 0 3px 0 var(--ui-warning); }
/* ── Eticheta de STARE pe muchie (`.state-tag`, B195) — SSOT pentru nodul de bracket ȘI cardul de grupă din
   calificare (extrasă din `.bk-battle__tag` când a apărut a doua gazdă). Călare pe muchia de sus, centrată,
   absolută: nu ia nimic din lățimea numelui (ADR 0040) și nu mută cardul. Gazda trebuie să fie `position:
   relative` și îi dă MĂRIMEA prin `--state-tag-fs` (nodul din `--bk-u`, grupa din lățimea cardului, `cqi`).
   Pe aripa dreaptă a bracketului nodul e deja re-întors (`scaleX(-1)` dublu), deci textul se citește normal. */
.state-tag {
    position: absolute; left: 50%; top: 0; z-index: 4;
    transform: translate(-50%, -55%);
    padding: 0 .5em; border-radius: var(--radius-status, 0);
    font-size: var(--state-tag-fs, var(--font-3xs));
    font-weight: 800; letter-spacing: .07em; line-height: 1.5; white-space: nowrap;
    pointer-events: none;
}
.state-tag--live { background: var(--ui-live); color: var(--ui-on-live); }
.state-tag--next { background: var(--ui-accent-fill); color: var(--ui-on-accent-fill); }
/* DEPARTAJAREA Smoke (ADR 0026 am.9) — chihlimbarul = „egal / atenție" din harta culorilor; perechea `--sm-bg` pe `--sm-warning`
   e deja în audit (nu există `--sm-on-warning`, nu se inventează). */
.state-tag--tiebreak { background: var(--ui-warning); color: var(--ui-page); }

/* ── PLACEHOLDER (schelet bracket pregătit din start, ca finala „urmează") ──
   B195 (prototipul fluxului live): nodul viitor are aceeași SUPRAFAȚĂ + UMBRĂ ca unul real, fără conturul
   punctat — îl deosebește conținutul estompat (clepsidra), nu o ramă. Suprafața (opacă) vine din baza
   `.bk-battle`: linia merge trece pe sub carduri, deci fără mască s-ar vedea prin el.
   Stă SUB `.bk-battle`: are aceeași specificitate (modificatorul ÎNLOCUIEȘTE clasa de bază în
   selector), deci decide ordinea din fișier (prins de gate-ul css-structure, B148). */
.bk-battle--ph {
    min-height: clamp(18px, calc(var(--bk-u, 12rem) * .22), calc(40px * var(--scale-cap, 1)));
    display: flex; align-items: center; justify-content: center;
}
.bk-battle--ph i { font-size: var(--font-xs); color: var(--ui-ink-muted); opacity: .5; }
/* conectorii estompați ai placeholderului stau SUB brațele finalei (`.bk-col--final .bk-battle::before`),
   mai jos în fișier — aceeași capcană de ordine ca mai sus. */

/* Entry row în battle */
/* Rândul de concurent = purtătorul de text al bracketului. Mărimea lui vine din ACEEAȘI scală
   (`--bk-u`) ca geometria conectorilor, deci numele se micșorează exact cât se micșorează cardul.
   Fallback-ul din `var(--bk-u, 12rem)` acoperă coloana standalone de la locul 3: ea stă în afara
   mirror-ului (ADR 0009), deci nu moștenește scala — fără fallback ar rămâne la podea. */
.bk-entry {
    /* Paddingul e pe proprietăți ca să-l poată anula CĂSUȚA DE SCOR (`.bk-entry__score`), care stă lipită de
       muchia nodului. Doar rem / px / `--bk-u` — nimic în `em`, deci copilul le rezolvă la aceeași valoare. */
    --bk-entry-pb: clamp(.08rem, calc(var(--bk-u, 12rem) * .03), calc(.3rem * var(--scale-cap, 1)));
    --bk-entry-pi: clamp(.12rem, calc(var(--bk-u, 12rem) * .05), calc(.5rem * var(--scale-cap, 1)));
    display: flex;
    align-items: center;
    gap: clamp(.1rem, calc(var(--bk-u, 12rem) * .03), calc(.3rem * var(--scale-cap, 1)));
    padding: var(--bk-entry-pb) var(--bk-entry-pi);
    font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .085), calc(var(--font-base) * var(--scale-cap, 1)));
    font-weight: 600;
    /* B195: rândurile se despart printr-un fir de PAGINĂ (suprafața de dedesubt), nu printr-o linie desenată. */
    border-bottom: 1px solid var(--ui-page);
    line-height: 1.25;
    min-height: clamp(14px, calc(var(--bk-u, 12rem) * .17), calc(28px * var(--scale-cap, 1)));
}
/* Nodul nu mai taie (`overflow` a plecat pentru eticheta de stare), deci colțurile rotunde ale rândurilor
   colorate le poartă rândurile. `inherit` = raza nodului; `:first/last-of-type` numără doar `div`-urile —
   marcajele de pe nod (departajare, eticheta) sunt `span`. Rândul NU taie (`overflow`): ar fi tăiat inelul de
   focus al declanșatorului de corecții; căsuța de scor își ia colțul prin aceeași moștenire (vezi `.bk-entry__score`). */
.bk-entry:first-of-type { border-start-start-radius: inherit; border-start-end-radius: inherit; }
.bk-entry:last-of-type  { border-end-start-radius: inherit; border-end-end-radius: inherit; }
/* `border-bottom-style`, nu prescurtarea `border-bottom: none`: prescurtarea resetează ȘI culoarea
   la `currentColor`, iar skinul o dădea pe a lui (`--sm-hair`) prin layer. Linia nu se desenează
   oricum (stil `none` ⇒ lățime folosită 0), deci pe ecran e identic — dar dump-ul de stiluri nu
   mai minte. B159 L10 (F2). */
.bk-entry:last-of-type { border-bottom-style: none; }
/* ── BUGETUL DE COLȚURI al cardului de bracket (iter. 2o) ──
   Cardul e cel mai strâmt loc din tot produsul: pe un Top-32, un rând are ~40px lățime. Orice
   etichetă care stă ÎN FLUX fură lățime exact de la singura informație care contează — numele.
   De aceea toate marcajele sunt ABSOLUTE și au fiecare colțul lui, ca să nu se calce între ele:
     sus EXTERIOR → `.bk-golden-mark` (colțul pliat cu rundele de departajare) — al CARDULUI
     sus CENTRU   → `.state-tag` (LIVE / URMEAZĂ, călare pe muchie, B195) — al CARDULUI
     muchia INTERIOARĂ → `.bk-entry__score` (căsuța de scor, ÎN FLUX, lipită de muchie) — al RÂNDULUI
     jos EXTERIOR → `.e-chip__out` (RETRAS) / `.bk-wo-mark` (W.O.)            — al RÂNDULUI
   „Exterior" = departe de centrul bracketului; se inversează pe aripa dreaptă, ca numele.
   Marcajele de JOS stau SUB text (`z-index: 0` vs numele la 1): la nume scurte se văd întregi, la
   nume lungi textul trece peste ele — informația portantă câștigă mereu (cerința userului).
   ⚠️ RETRAS și W.O. împart același colț fiindcă sunt marcaje ale unei PERSOANE, nu ale meciului, iar
   într-un walkover cad pe rânduri diferite: RETRAS pe cel care a ieșit, W.O. pe cel care a avansat.
   Vezi `_bracket_column` — W.O. a stat pe card până în iter. 2o și ateriza vizual tocmai pe rândul
   retrasului, adică pe omul care NU beneficiase de el. */
.bk-entry { position: relative; }
.bk-entry .e-chip__out,
.bk-entry .bk-wo-mark {
    position: absolute; bottom: 0; left: 0; right: auto; top: auto; z-index: 0;
    font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .05), calc(var(--font-3xs) * var(--scale-cap, 1)));
    padding: 0 2px; line-height: 1.15; pointer-events: none;
}
.bk-half--right .bk-entry .e-chip__out,
.bk-half--right .bk-entry .bk-wo-mark { left: auto; right: 0; }
/* Rezervă intrată pe locul unui retras (ADR 0042) — colțul de jos INTERIOR, singurul rămas liber:
   exteriorul e luat de RETRAS/W.O., iar un promovat POATE avea W.O., deci n-au voie să împartă colțul.
   Semn, nu nume: numele înlocuitorului ar mânca exact bugetul de lățime care ține un Top-32 pe telefon
   (de-aia săgețile din listele de calificare NU au intrat aici, 2026-08-28). Rămâne VIZIBIL pe
   proiector — o înlocuire e informație publică de concurs (decizia ownerului, 2026-08-30). */
.bk-entry .bk-sub-mark {
    position: absolute; bottom: 0; right: 0; left: auto; top: auto; z-index: 0;
    font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .05), calc(var(--font-3xs) * var(--scale-cap, 1)));
    line-height: 1.15; padding: 0 2px; color: var(--ui-ink-muted); pointer-events: none;
}
.bk-half--right .bk-entry .bk-sub-mark { right: auto; left: 0; }
/* Pe rândul cu CĂSUȚĂ DE SCOR colțul interior e al ei → săgeata trece în colțul EXTERIOR, liber aici: RETRAS și
   W.O. apar doar pe walkover / battle nejucat, iar acelea n-au scor. */
.bk-entry--scored .bk-sub-mark { right: auto; left: 0; }
.bk-half--right .bk-entry--scored .bk-sub-mark { left: auto; right: 0; }
/* Declanșatorul de corecții (⋮) stă la COADA rândului, pe latura exterioară: numele se aliniază
   spre centru, deci acolo e spațiul care prisosește. Așa butonul nu mai taie din mijlocul rândului. */
.bk-entry .cm-trigger {
    order: -1; flex: none;
    padding: 0 1px;
    font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .06), calc(var(--font-xs) * var(--scale-cap, 1)));
}
.bk-half--right .bk-entry .cm-trigger { order: 1; }
/* Trofeul rămâne pe latura INTERIOARĂ, lângă capătul numelui — deci se oglindește invers față de ⋮. */
.bk-half--right .bk-entry__trophy { order: -1; }
/* Câștigătorul = rândul pe LIME PLIN (B195, prototipul fluxului live; aceeași umplere de verdict ca latura
   câștigătoare din scorecard) — calea lui prin bracket se urmărește dintr-o privire. Perdantul se retrage. */
.bk-entry--winner { background: var(--ui-win); color: var(--ui-on-win); font-weight: 800; }
.bk-entry--loser  { color: var(--ui-ink-muted); font-weight: 500; }   /* lizibil, dar clar secundar */
/* Marcajele mici de pe rândul lime își iau cerneala de pe umplere: `--text` (declanșatorul de corecții),
   `--fg3` (săgeata de rezervă) și aurul trofeului sunt deschise pe dark — pe lime ar fi dispărut (aurul:
   1.9:1). Trofeul rămâne semn prin FORMĂ; aurul lui stă pe banda CAMPION de deasupra. */
.bk-entry--winner :is(.cm-trigger, .bk-sub-mark, .bk-entry__trophy) { color: var(--ui-on-win); }
/* CĂSUȚA DE SCOR (B195) — cifra din capul scorecardului (runde sau criterii câștigate), pe muchia INTERIOARĂ a
   nodului, lipită de ea (convenția bracketurilor sportive), nu pe fundalul rândului lângă nume. Câștigătorul =
   căsuță OLIVE cu cifra lime (`--sm-verdict-deep`, 5.52 pe ambele teme; L1a: negrul de 15:1 era „foarte urât" —
   ownerul — și cântărea mai mult decât numele); perdantul = căsuță neutră. Anulează paddingul rândului ca să atingă muchiile. Colțul: moștenește razele de pe latura ei de la rând,
   care sunt nenule doar la colțurile nodului (primul / ultimul rând) — deci se rotunjește exact acolo. */
.bk-entry__score {
    flex: none; align-self: stretch;
    display: grid; place-items: center;
    min-width: 1.9em;
    margin-block: calc(var(--bk-entry-pb) * -1);
    margin-inline: 0 calc(var(--bk-entry-pi) * -1);
    font-weight: 900; font-variant-numeric: tabular-nums;
    background: var(--ui-quiet); color: var(--ui-ink);
    border-start-end-radius: inherit; border-end-end-radius: inherit;
}
.bk-entry--winner .bk-entry__score { background: var(--ui-win-deep); color: var(--ui-win); }
/* Pe aripa dreaptă muchia interioară e STÂNGA: căsuța trece prima (`order`), înaintea trofeului (-1). */
.bk-half--right .bk-entry__score {
    order: -2; margin-inline: calc(var(--bk-entry-pi) * -1) 0;
    border-start-end-radius: 0; border-end-end-radius: 0;
    border-start-start-radius: inherit; border-end-start-radius: inherit;
}
.bk-entry--bye    { color: var(--ui-ink-muted); font-style: normal; letter-spacing: .08em; font-weight: 500; } /* avans liber — fără win/lose */
/* numele se aliniază spre CENTRUL bracketului: aripa stângă → dreapta, aripa dreaptă → stânga.
   Finala = centru. Nume lungi / 2v2 → maxim 2 RÂNDURI apoi taie (line-clamp); geometria nu se
   strică — sloturile .bk-match rămân egale, conectorii sunt procentuali. */
.bk-entry__name {
    /* PODEA DE LIZIBILITATE DOAR PE NUME (B158, 2026-09-16, cererea ownerului): cutiile și scala rămân
       ale ADR 0040 — bracketul se mulează în continuare pe ecran, fără derulare laterală — dar NUMELE
       concurentului nu coboară sub `--font-xs` (11.2px) pe ecran mic. Pe ecran lat `1em` (scala
       rândului) e deja mai mare, deci acolo nu se schimbă nimic. Costul asumat: pe un Top 32 la 360px
       cutia are ~38px → câteva litere pe rând, două rânduri, apoi „…" (line-clamp de mai jos). */
    font-size: max(var(--font-xs), 1em);
    /* Cu litere mai mari decât cutia, un cuvânt lung se rupe („Particip/ant" la 390px, Top 8). `hyphens`
       pune cratimă unde browserul are dicționar pentru `lang="ro"`; altfel rămâne ruptura de mai jos. */
    hyphens: auto;
    /* `position/z-index`: numele trece PESTE marcajele de jos (RETRAS, W.O.), nu invers. */
    position: relative; z-index: 1;
    flex: 1; min-width: 0; text-align: right;
    display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical;
    overflow: hidden; overflow-wrap: anywhere;
}
.bk-half--right .bk-entry__name { text-align: left; }
.bk-col--final .bk-entry__name  { text-align: center; }
.bk-col--plain .bk-entry__name  { text-align: center; }   /* coloană standalone (ex. „Locul 3") */
.bk-entry__trophy { color: var(--ui-rank-gold-ink); font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .075), calc(var(--font-sm) * var(--scale-cap, 1))); flex-shrink: 0; }

/* Badge golden round */
/* marcaj departajare = COLȚ PLIAT (triunghi) cu nr de runde suplimentare (1/2/3) pe colț.
   Stă pe latura EXTERIOARĂ (opusă numelui, care e aliniat spre centru): stânga pe aripa
   stângă, dreapta pe aripa dreaptă → nu acoperă numele. Absolut → nu mărește înălțimea. */
.bk-golden-mark {
    position: absolute; top: 0; left: 0; z-index: 3;
    /* Colțul urmează scala cardului: la 190px acoperă un sfert de nume, la 40px l-ar acoperi tot. */
    width: clamp(11px, calc(var(--bk-u, 12rem) * .16), 26px); height: clamp(11px, calc(var(--bk-u, 12rem) * .16), 26px);
    background: var(--ui-warning); color: var(--ui-page);
    clip-path: polygon(0 0, 100% 0, 0 100%);
    /* Nodul nu mai taie (B195): colțul pliat își rotunjește singur vârful, după raza nodului. */
    border-start-start-radius: inherit;
    font-size: clamp(var(--font-4xs), calc(var(--bk-u, 12rem) * .055), var(--font-2xs)); font-weight: 800; line-height: 1;
    text-align: left; padding: 1.5px 0 0 2.5px;
}
/* Marcaj W.O. (walkover, ADR 0039) — a avansat fără să joace: neutru, nu accent, e o consemnare, nu
   o victorie. Doar ASPECTUL stă aici; POZIȚIA vine din regula comună cu `.e-chip__out` de la
   `.bk-entry` („bugetul de colțuri"), fiindcă ambele sunt marcaje ale unei persoane, pe rândul ei. */
.bk-wo-mark {
    font-weight: 700; border-radius: var(--radius-sm);
    background: var(--ui-ink-muted); color: var(--ui-flat);
}
.bk-half--right .bk-golden-mark {
    left: auto; right: 0;
    border-start-start-radius: 0; border-start-end-radius: inherit;
    clip-path: polygon(100% 0, 0 0, 100% 100%);
    text-align: right; padding: 1.5px 2.5px 0 0;
}

/* ── Cronometru mare pe proiector (numărătoare inversă, ADR 0010) ── */
.battle-timer {
    display: flex; justify-content: center; align-items: center;
    margin: 0 0 .75rem; padding: .35rem 1rem;
    /* Perechea inversă COMPLETĂ. Era `background: var(--ink)` (raw, fix închis) cu
       `color: var(--paper)` — dar --paper e remapat la o SUPRAFAȚĂ, care în dark devine tot
       închisă: 1.15:1, adică cronometrul de pe proiector dispărea exact în tema în care se
       proiectează. --paper NU e „text pe închis" (vezi nota de la token); aia e --text-on-inverse. */
    background: var(--ui-quiet); color: var(--ui-ink);
    border: 2px solid var(--ui-quiet); box-shadow: var(--shadow-hard-sm);
}
.battle-timer__val {
    font-family: var(--font-mono); font-weight: 700; line-height: 1;
    font-size: clamp(2.5rem, 12vw, 6rem); letter-spacing: var(--type-number-tracking, .04em); font-variant-numeric: tabular-nums;
}
/* Timp expirat: fundal flash brand (roșu) — semnal vizual că runda s-a terminat. */
.battle-timer--done { background: var(--ui-inverse); border-color: var(--ui-inverse); color: var(--ui-on-inverse); }
/* Placeholder: element identic dar invizibil (spațiu REZERVAT — ecranul nu saltă când cronometrul
   de rundă pornește/se oprește pe ecranul smoke). */
.battle-timer--idle { visibility: hidden; }
/* Varianta MICĂ a cronometrului. Pe ecranul smoke (ADR 0026 am.4, timerele INVERSATE): ceasul de
   SESIUNE poartă --round (mic, în mijlocul perechii), cronometrul de RUNDĂ e cel mare de bază,
   sub pereche. Starea --done se moștenește. */
.battle-timer--round { margin: 0; padding: .2rem .6rem; }
.battle-timer--round .battle-timer__val { font-size: clamp(1.1rem, 3.5vw, 2rem); }
/* Cronometrul de sală a URCAT în clusterul de categorie, între Line-up și Juriu (2026-08-27, cererea
   userului). Înainte era `sticky bottom` sub scorecard și sub bracket — pe un Top-32 ajungea mai jos
   decât bracketul și risca să iasă din imagine. Sus, în antet, nu-l mai poate împinge nimic afară,
   iar antetul se randează pe toate presetările `?vezi=` (ADR 0041).
   Deci: FĂRĂ `position`/`z-index`/centrare — e un element de flex, vecinii îi fac loc din `gap`-ul
   clusterului. Scara coboară de la „cel mai mare bloc din pagină" la „a treia piesă de pe rând".
   ⚠️ `vw`, NU `cqi` — deliberat, ca la vecinii lui (`.people__lbl`, fost `.res-jury__lbl`, `body.kf .res-jury .j-pill`).
   `.res-cat-cluster` NU e container de interogare: a fost încercat și RETRAS în iter. 2o (e un flex
   item `flex: 0 1 auto`, deci containment-ul îl prăbușea) — motivul e scris lângă selector în
   components.css. Fără container ancestor, `cqi` ar fi căzut pe viewport, adică o scară care nu
   spune nimic. Iar aici `vw` chiar spune ceva: antetul categoriei e un rând de PAGINĂ, pe toată
   lățimea, nu o componentă dintr-un panou. `--scale-cap` rămâne — el ridică tavanul pe proiector. */
.battle-timer--venue { margin: 0; padding: .2rem .7rem; align-self: center; }
.battle-timer--venue .battle-timer__val {
    font-size: clamp(var(--font-2xl), 3.2vw, calc(2.5rem * var(--scale-cap, 1)));
}


/* ── Split: bracket (STÂNGA) + battle curent (DREAPTA), stivuite pe mobil — bracketul DEASUPRA ──
   Iter. 2o: cele patru declarații `order` de aici au fost ȘTERSE, nu inversate. Ele făceau exact
   pe dos față de comentariile din cod (panoul ajungea stânga, bracketul dreapta) — o contradicție
   tăcută care a trăit luni de zile. Fără `order`, ordinea vizuală E ordinea din DOM
   (`.bk-layout__bracket` apoi `.bk-layout__current`, vezi `_bracket_section`), deci comentariul nu
   mai poate minți, iar stivuirea pe mobil pune bracketul deasupra scoreboardului fără nicio regulă
   în plus — exact ce a cerut userul.
   ADR 0041: ordinea se ALEGE tot în Twig (presetul „Scor sus" emite panoul primul în DOM), NICIODATĂ
   prin `order`/`*-reverse` aici — spec-ul Flexbox le declară non-conformante pentru ordine logică
   (§ „Reordering and Accessibility"), iar WCAG 1.3.2/2.4.3 cer ca ordinea de citire să fie DOM-ul.
   CSS-ul primește doar modificatorii de ARANJAMENT (`--solo`, `--panel-only`, `--stacked`). */
/* CONTAINERUL de măsurare al bracketului (ADR 0040) stă AICI, pe rând, nu pe `.bk-scroll`.
   De ce tocmai aici: `.bk-layout` e un bloc în flux normal, deci lățimea LUI vine oricum de la
   părinte, niciodată din conținut — adică se poate contoriza fără să se rupă nimic. Orice element
   mai adânc (`.bk-scroll`, `.bk-mirror`) e, dimpotrivă, exact sursa din care coloana de bracket își
   calculează `flex-basis: auto`; contorizat, ar contribui cu ZERO și ar prăbuși coloana.
   Regula generală, plătită de două ori în iter. 2o: **containerul de interogare trebuie să fie un
   element a cărui lățime NU depinde de conținutul lui.**
   --bk-share = cât din rând îi revine bracketului. E o PROPORȚIE declarată de layout (singurul care
   o știe), nu o lățime ghicită: scala din `.bk-mirror` o folosește ca să nu-și calculeze cutiile ca
   și cum ar avea tot rândul la dispoziție. Sub-plafonată deliberat — dacă iese ceva mai mic decât
   spațiul real, panoul se umflă (comportamentul dorit); dacă ar ieși mai mare, bracketul ar începe
   să se tragă lateral degeaba. */
.bk-layout { display: flex; flex-direction: column; gap: 1rem; align-items: stretch; container-type: inline-size; --bk-share: 1; }
/* --bk-padb = respirația de sub bracket. Trăiește AICI, pe părintele comun, fiindcă o citesc două
   elemente frați: mirror-ul (ca padding) și căsuța „Locul 3" (ca tragere în sus). Legată într-un
   singur loc, căsuța nu poate ajunge niciodată peste cardurile bracketului. */
.bk-layout__bracket { min-width: 0; --bk-padb: 1.5rem; }
/* Locul 3 stă sub bracket (standalone, ca să nu strice centrarea și conectorii finalei — ADR 0009),
   dar tras în sus în spațiul gol de sub finală ca să se citească ca parte din final, nu ca anexă.
   Plafonul e chiar padding-ul de jos al mirror-ului: peste el ar începe să se suprapună. */
.bk-third-slot { display: flex; justify-content: center; margin-top: calc(var(--bk-padb) * -0.8); }
.bk-layout__current { min-width: 0; }
@media (min-width: 992px) {
    /* Pe un rând, bracketul primește ~60% (panoul are bază 33% + creștere). Stivuit (sub prag) are
       tot rândul, deci `--bk-share` rămâne 1 din regula de bază. */
    .bk-layout { flex-direction: row; align-items: flex-start; --bk-share: .6; }
    .bk-layout--solo { --bk-share: 1; }
    /* Împărțirea NU mai e fixă 33/67 — o dictează cât loc cere efectiv bracketul.
       Bracketul primește `flex-basis: auto`, adică lățimea CONȚINUTULUI lui, care depinde direct de
       câte runde are (Top 32 = multe coloane, Top 4 = două). Panoul de jurizare are bază 33%, poate
       CREȘTE, dar NU se micșorează.
         · bracket mare  → bazele depășesc containerul; doar bracketul se strânge (scroll intern),
                           panoul rămâne fix pe 33% — exact ca înainte.
         · bracket mic   → rămâne spațiu liber; ambele cresc, deci panoul se umflă până la plafon
                           și nu mai rămâne gol lângă un bracket de 4.
       Zero JS, zero reguli per-mărime: mărimea bracketului se citește singură din conținut.
       Plafonul de 60%: peste atât, cei doi concurenți ajung prea depărtați pe orizontală, cu mijlocul
       pierdut între ei — devine mai greu de citit, nu mai ușor.
       align-self: center = panoul mai scund stă pe MIJLOCUL înălțimii bracketului, nu lipit sus;
       sticky rămâne → la scroll tot se lipește sub marginea de sus. */
    .bk-layout__current { flex: 1 0 33%; max-width: 60%; min-width: 0; align-self: center; position: sticky; top: .75rem; }
    .bk-layout__bracket { flex: 1 1 auto; min-width: 0; }
    .bk-layout--solo .bk-layout__bracket { flex: 1 1 100%; }
    /* Presetările ecranului de sală (ADR 0041) — blocurile lipsă NU se ascund, nu se randează;
       aici stau doar consecințele de aranjament pentru cele rămase:
         · `--panel-only` (doar scoreboard-ul): fără bracket lângă el, plafonul de 60% n-are cui lăsa
           loc — umple rândul. Literele vin din `cqi` pe `.bk-layout`, deci un rând întreg = litere
           mai mari (exact scopul: TV mic, sală mare), cu plafoanele proprii ale scorecardului.
         · `--stacked` (scor SUS): coloana se păstrează și pe lat — scoreboard-ul pe tot rândul,
           bracketul dedesubt cu tot rândul (`--bk-share: 1`). `sticky`/`align-self: center` n-au sens
           când panoul e primul și lat cât rândul. */
    .bk-layout--panel-only .bk-layout__current { flex: 1 1 100%; max-width: 100%; }
    .bk-layout--stacked { flex-direction: column; align-items: stretch; --bk-share: 1; }
    .bk-layout--stacked .bk-layout__current { flex: 1 1 100%; max-width: 100%; position: static; align-self: stretch; }
    .bk-layout--stacked .bk-layout__bracket { flex: 1 1 100%; }
}
/* Familia `.cmd-bar*` (bara volt a battle-ului curent) a fost ȘTEARSĂ în iter. 2n: toate controalele
   organizatorului au urcat pe linia taburilor (`.tab-actions`), iar starea LIVE de pe ea dubla banda
   scorecardului. Ce a rămas util din ea — contorul de voturi și butonul de cronometru — e mai jos.
   Rundele + cronometrul fazei (ADR 0039, editabile doar la primul start) se cer o SINGURĂ dată, în
   modalul de confirmare — iter. 2m; familia `.bk-start-rounds*` a ieșit atunci, `.cf-*` din
   base-layout.css îi ține locul. */
/* Contorul „X/Y" de pe Finalizează dezactivat (iter. 2h) — câți jurați au votat TOT. */
.bk-votes-cnt { font-family: var(--font-mono); font-size: var(--font-2xs); font-weight: 700; opacity: .85; }
.bk-timer-btn { display: inline-flex; align-items: center; gap: .25rem; }
.bk-timer-btn__s { font-size: var(--font-2xs); font-weight: 700; opacity: .85; }
/* Previzualizarea deciziei finalei pe ecranul organizatorului (B30) — `<details>` nativ, zero JS.
   Acoperită implicit: verdictul e la un click, ca o privire peste umăr să nu-l ia. Aceeași mecanică
   de summary ca .panel-acc (marker propriu, nu cel al browserului), dar componentă separată — una e
   un acordeon de listă, cealaltă o dezvăluire unică. */
.fp { border: 1px solid var(--ui-win); border-radius: var(--radius-sm); background: var(--ui-win-tint); margin-bottom: .5rem; overflow: hidden; }
.fp--tie { border-color: var(--ui-warning); background: var(--ui-warning-soft); }
.fp > summary {
    display: flex; align-items: center; gap: .3rem;
    padding: .35rem .55rem; cursor: pointer; user-select: none;
    font-size: var(--font-xs); font-weight: 700; color: var(--ui-ink-muted);
    list-style: none;
}
.fp > summary::-webkit-details-marker { display: none; }
.fp > summary::after { content: "\F282"; font-family: "bootstrap-icons"; margin-left: auto; font-size: .8em; transition: transform .15s ease; color: var(--ui-ink-muted); }
.fp[open] > summary::after { transform: rotate(180deg); }
.fp > summary:hover { filter: brightness(.97); }
.fp__body { display: flex; align-items: center; gap: .5rem; padding: .1rem .55rem .5rem; }
.fp__icon { font-size: var(--font-lg); flex-shrink: 0; color: var(--ui-ink); }
.fp--tie .fp__icon { color: var(--ui-warning); }
.fp__body strong { font-size: var(--font-sm); color: var(--ui-ink); }
.fp--tie .fp__body strong { color: var(--ui-warning); }
.fp__sub { font-size: var(--font-2xs); color: var(--ui-ink-muted); }

/* Scorecard focus în coloana din DREAPTA (iter. 2o — laturile au fost schimbate): umple lățimea,
   scară redusă vs panoul mare;
   fără umbră dură — panoul stă lipit de bracket, umbra adăuga zgomot */
.bk-layout__current .sc--focus { width: 100%; max-width: 100%; margin-bottom: 0; box-shadow: var(--ui-shadow-float); }
/* Plafoanele separate pe lățimea coloanei au dispărut 2026-08-15: existau fiindcă `cqi` măsura
   RÂNDUL, deci într-o coloană strâmtă numele ieșeau prea mari și trebuiau plafonate de mână. De când
   containerul e CELULA (vezi `.sc__nm`), îngustimea se reglează singură. Mărimea se diferențiază
   acum pe SUPRAFAȚĂ (antet de așteptare vs. cap de scorecard final), nu pe coloană. */
.bk-layout__current .sc--focus .sc-jt__skv { font-size: var(--font-sm); }
.bk-layout__current .sc--focus .sc-jt__arrow,
.bk-layout__current .sc--focus .sc-jt__net,
.bk-layout__current .sc--focus .sc-round__pts { font-size: var(--font-md); }
/* Plafonul separat pe coloana asta a dispărut 2026-08-21, din același motiv ca vecinii de mai sus:
   `.sc-jt__row` își măsoară acum mijlocul pe CONTAINER (`clamp(..., 16cqi, ...)`), deci lățimea
   reală a coloanei o dictează singură — cele trei cifre fixe erau aproximări ale ei. */

/* ── Bracket OGLINDIT (mirrored: stânga → FINALĂ ← dreapta) ──
   FLUID: mirror = 100% din container, coloanele elastice (min 96 / max 190px) → Top 32 încape
   fără scroll pe ecrane late; sub ~1250px coloanele ating minimul și .bk-scroll preia (fallback). */
/* Derularea laterală rămâne, dar ca PLASĂ de siguranță (Top-64 sub ~340px), nu ca mecanism
   principal — scala din `.bk-mirror` face bracketul să încapă singur.
   ⚠️ AICI NU are voie să stea `container-type` (încercat și retras în iter. 2o). `.bk-scroll` e
   conținutul din care `.bk-layout__bracket` își calculează `flex-basis: auto` — adică exact
   mecanismul care lasă panoul să se umfle lângă un bracket mic. Cu `contain: inline-size`, aportul
   lui la lățimea intrinsecă a părintelui devine ZERO, deci coloana de bracket se prăbușea (iar în
   modul proiector, unde bracketul e `flex: 0 1 auto`, dispărea de tot). Containerul stă pe
   `.bk-layout` — vezi comentariul de acolo. */
.bk-scroll { overflow-x: auto; padding-bottom: .5rem; }
.bk-mirror {
    /* ── O SINGURĂ SCALĂ pentru tot bracketul (iter. 2o) ──
       --bk-u = lățimea care îi revine unei coloane dacă bracketul ar încăpea exact în panou.
       TOATE mărimile de mai jos (cutii, brațe, suprapunere, fonturi din regulile copiilor) se
       derivă din ea, fiecare cu clamp-ul ei. De-aia FORMA se păstrează la orice mărime: brațele și
       suprapunerea scad odată cu cardurile, nu rămân în urmă.
       Maximele sunt exact valorile de dinainte → pe ecran lat nu se schimbă nimic — pe PAGINA
       PUBLICĂ. Pe SALĂ (B114, ADR 0041 am.1) tavanul se RIDICĂ: fiecare maxim e înmulțit cu
       `--scale-cap` (1 implicit, 2 sub `body.live-projector` — „fără tavan" = 100 a fost
       dezastruos, vezi secțiunea „Scara de SALĂ"), deci acolo un Top 8 umple share-ul. Un singur
       token, remapat într-un singur loc.
       Podeaua e joasă deliberat (decizia userului: „facem literele mici să se potrivească") — un
       Top-32 intră întreg pe 360px. Sub ~8px numele se citesc ca forme, nu ca text; ăsta e
       compromisul asumat, cu `.bk-scroll` în spate pentru cazurile extreme.
       --bk-overlap = cât trage coloana 3+ PESTE feederul ei (mai mare = mai compact);
       --bk-firstgap = spațiul normal T32→T16 (primul rând rămâne fără overlap);
       --bk-arm = cotul scurt în card. */
    --bk-u: calc(100cqi * var(--bk-share, 1) / var(--bk-cols, 9));
    --bk-colw:      clamp(2.4rem, var(--bk-u), calc(11.875rem * var(--scale-cap, 1)));
    --bk-overlap:   clamp(10px, calc(var(--bk-u) * .19), calc(36px * var(--scale-cap, 1)));
    --bk-firstgap:  clamp(5px, calc(var(--bk-u) * .095), calc(18px * var(--scale-cap, 1)));   /* T32→T16 total = brațul bracketului + linia de legătură spre copil */
    --bk-firstarm:  clamp(3px, calc(var(--bk-u) * .047), calc(9px * var(--scale-cap, 1)));    /* brațul bracketului (din cardul T32 până la bara verticală/merge point) */
    --bk-childlink: clamp(3px, calc(var(--bk-u) * .047), calc(9px * var(--scale-cap, 1)));    /* linia care leagă merge point-ul de copil (cardul T16) — ca să nu fie lipit */
    --bk-arm:       clamp(3px, calc(var(--bk-u) * .042), calc(8px * var(--scale-cap, 1)));
    --bk-gap:       clamp(4px, calc(var(--bk-u) * .074), calc(14px * var(--scale-cap, 1)));
    display: flex;
    align-items: stretch;
    gap: 0;
    min-height: 200px;
    padding: .5rem .25rem var(--bk-padb, 1.5rem);
    width: 100%;
    min-width: 0;
}
/* aripile împart spațiul egal; când coloanele ating max-width, spațiul liber merge spre
   marginile exterioare (justify flex-end + flip pe dreapta) → bracketul se strânge spre finală.
   min-width: MIN-CONTENT (nu 0!): aripa refuză să se strângă sub suma minimelor coloanelor →
   overflow-ul cade la DREAPTA mirror-ului (scrollabil), nu în stânga aripii (de neatins în LTR). */
.bk-half { display: flex; align-items: stretch; gap: 0; flex: 1 1 0; min-width: min-content; justify-content: flex-end; }
.bk-half--center { align-items: center; padding: 0 var(--bk-gap); flex: 0 0 auto; }
/* coloanele 3+ se suprapun pe orizontală → matchul avansat tras sub feederi (diagonal compact).
   Ordinea DOM (coloana mai centrală = mai târzie) o pune pe ea deasupra → conectorul „merge" se vede. */
.bk-col + .bk-col { margin-left: calc(var(--bk-overlap) * -1); }
/* a 2-a coloană (T16) NU se suprapune peste primul rând (T32) → spațiu normal pt conectorii outgoing */
.bk-col--first + .bk-col { margin-left: var(--bk-firstgap); }

/* Jumătatea dreaptă = oglindită prin CSS: scaleX flip pe coloane + conectori,
   iar conținutul (carduri + etichete) e re-flipuit ca textul să rămână normal. */
.bk-half--right { transform: scaleX(-1); }
.bk-half--right .bk-battle,
.bk-half--right .bk-col-label { transform: scaleX(-1); }

/* Finala primește din AMBELE laturi → brațe scurte stânga + dreapta */
.bk-col--final .bk-battle::before,
.bk-col--final .bk-battle::after {
    content: '';
    position: absolute;
    top: calc(50% - 1px);
    width: var(--bk-gap);
    border-top: 2px solid var(--ui-line);
}
.bk-col--final .bk-battle::before { left: calc(var(--bk-gap) * -1); }
.bk-col--final .bk-battle::after  { right: calc(var(--bk-gap) * -1); }
/* …iar bratele FINALEI n-aveau deloc regula de „rezolvat". Acelasi fix, aceeasi pozitie: dupa cele
   care dau geometria. Coborat din `@layer skin` la B159 L10 (F2). */
.bk-col--final .bk-match--resolved .bk-battle::before,
.bk-col--final .bk-match--resolved .bk-battle::after { border-color: var(--ui-win-ink); }
/* conectorii unui placeholder = estompați (nu negru plin). Stau SUB brațele finalei de mai sus:
   `border-color` de aici și `border-top` de acolo împart `border-top-color` la aceeași specificitate,
   deci decide ordinea din fișier (prins de gate-ul css-structure, B148). */
.bk-match--ph .bk-merge,
.bk-col--second .bk-match--ph::before,
.bk-col--final .bk-battle--ph::before,
.bk-col--final .bk-battle--ph::after { border-color: var(--ui-hair); }

/* ── SCORECARD (battle reveal: runde × jurați × participant) ── */
.sc {
    /* FĂRĂ RAMĂ (B195 L2, prototipul fluxului live; ADR 0057 §4): rama citește rolul stins `--sm-card-edge`, ca
       restul cardurilor după G1 — în forced-colors transparentul redevine contur. Cardul alb pe crem (1.11:1) se
       desprinde prin umbra de plutire de mai jos; pe dark, prin treapta tonală (s2 pe pagină). Rama `--sm-line`
       (3.85 / 3.90) data din B159 L10, dinainte de decizia „fără rame". */
    border: 1px solid var(--ui-frame);
    border-radius: var(--radius-lg);
    background: var(--ui-raised);
    box-shadow: var(--ui-shadow-float);
    margin-bottom: .75rem;
    max-width: 680px;
    overflow: hidden;
}
/* `.sc--live` nu mai are marcaj propriu pe panou — rosul sta doar pe cardul din bracket (cererea
   ownerului). Regula a ramas fara nicio declaratie proprie si a disparut la B159 L10 (F2). */
/* Battle-ul terminat NU mai primește chenar verde pe toată cutia: verdele aprins în jurul întregului
   scoreboard concura cu însuși câștigătorul, care e deja marcat verde + trofeu ÎNĂUNTRU. Un semnal
   repetat pe toată rama nu adaugă informație, doar zgomot. `.sc--live` rămâne (acolo chenarul chiar
   distinge un battle ÎN CURS de restul listei). Clasa `.sc--done` se emite în continuare din Twig,
   intenționat: e marcaj de stare, util dacă mai târziu vrem alt semnal — doar chenarul a picat. */

/* Panou FOCUS — battle curent/rezultat */
.sc--focus { max-width: 960px; width: 100%; margin-bottom: 1rem; box-shadow: var(--ui-shadow-float); }
.sc--focus .sc__meta { font-size: var(--font-sm); padding: .55rem .9rem; }
/* Plafon la vârful scării (feedback 2026-08-12 ×2: numele erau tot mici) — cqi-ul conduce, cu
   coeficientul de lungime; pe mobil coboară spre floor; line-clamp 2 = plasa finală. */
/* Netul e CONCLUZIA celulei — scalează în ACELEAȘI selectoare ca săgeata și suma din subsol, nu în
   reguli paralele care pot diverge la următoarea calibrare. Sub-notele (registrul) stau o treaptă
   mai jos, ca la mărimea de bază (sm → md). */
.sc--focus .sc-jt__skv { font-size: var(--font-md); }
.sc--focus .sc-jt__arrow,
.sc--focus .sc-jt__net,
.sc--focus .sc-round__pts { font-size: var(--font-lg); }
.sc--focus .sc-jt__cell { min-height: 1.8rem; }
.sc--focus .sc-round__hd { font-size: var(--font-sm); }

/* LINIA DE CONTEXT (B195 L3a) — la BAZA cardului, CENTRATĂ: CE battle (faza) · CE se numără · CUM stă. Ownerul: „jos
   pe mijloc, ca să nu se bată cap în cap cu numele concurenților de sus". Text estompat PE card, nu bandă: banda
   neagră de jos (`.sc__bar`, ștearsă la L2) „atrăgea atenția prea mult". `flex-wrap` + `gap`: la 360px starea pică
   pe rândul doi, tot centrată. */
.sc__meta {
    display: flex; flex-wrap: wrap; justify-content: center; align-items: center;
    gap: .15rem clamp(.4rem, 2vw, 1rem);
    padding: .45rem .75rem;
    color: var(--ui-ink-muted);
    font-family: var(--font-display);
    font-size: var(--font-xs); font-weight: 700; text-transform: var(--type-label-case, uppercase); letter-spacing: var(--type-label-tracking, .06em);
}
/* Unitatea de numărare e CONTEXT, nu verdict: o treaptă de greutate sub fază. Fără opacitate — pe text-mid ar fi
   coborât sub prag. */
.sc__unit { font-weight: 500; }
.sc__state { display: inline-flex; align-items: center; gap: .35rem; font-weight: 800; }
/* Starea colorată ca în prototip: rezultatul = olive-ul de accent. LIVE-ul nu se mai scrie în card (B195 L3, decizia
   ownerului „un singur loc"): pe pagină îl poartă bannerul `.live-status`, pe sală antetul de sală. Punctul `.sc__dot`
   (cu `@keyframes sc-pulse`) și `.sc__state--live` au plecat odată cu el; banda `.sc__next` (L2) la fel. */
.sc__state--done { color: var(--ui-win-ink); }
/* LINIA DE RUNDĂ (B195 L3b) — doar pe ecranul de sală, cât rulează battle-ul: „Runda 1/2" · „Juriul votează" ·
   „Decizie" · „Runda extra". Ownerul: „să nu fie așa imens… mărime adaptabilă după cât de mare e scorecardul".
   ⚠️ Cauza lui „imens" la L3: `cqi` se rezolva pe `.bk-layout`, adică pe TOT rândul de sală (bracket + scorecard) —
   ~42px pe 1920px. Acum GAZDA de container e linia însăși: un bloc cât lățimea scorecardului, nedimensionat din
   conținut (deci nu poate prăbuși panoul — „gazda containerului ≠ conținut"), iar textul se măsoară pe ea (`cqi` în
   COPIL, ADR 0040). ~14px pe un scorecard de 500px, ~23px la 900px, tavan `--font-lg` × `--scale-cap` (32px pe sală).
   Roșul de live ca TEXT pe `.sc-jg` (`--card` = s1): 5.62 / 6.11. */
.sc__round-state { container-type: inline-size; padding: calc(.5rem * var(--scale-cap, 1)) .75rem 0; text-align: center; }
.sc__round-state-txt {
    display: block;
    font-family: var(--font-display); font-weight: 900; line-height: 1.1;
    text-transform: var(--type-label-case, uppercase); letter-spacing: .04em;
    font-size: clamp(var(--font-sm), 2.6cqi, calc(var(--font-lg) * var(--scale-cap, 1)));
    color: var(--ui-live-mark);
}

/* ═══ STAREA LIVE A CATEGORIEI (B195 L3, prototipul fluxului live) — `_live_status.html.twig` ═══
   Pe PAGINĂ: bannerul de deasupra bracketului — emitentul UNIC al lui LIVE pe pagină (decizia ownerului „un singur
   loc", 2026-09-29). Pe SALĂ: banda de jos, doar ce vine. Pilula LIVE = `.now-tag` (SSOT-ul pentru „acum"), nu una
   nouă. `flex-wrap`: pe telefon textul pică sub pilulă, nu se înghesuie. */
.live-status {
    display: flex; flex-wrap: wrap; align-items: center; gap: .35rem .7rem;
    margin: 0 0 .85rem; padding: .55rem .8rem;
    border-radius: var(--radius-lg);
    background: var(--ui-raised); color: var(--ui-ink-muted);   /* B226: bannerul stă pe pagină — tonul cardului */
    font-size: var(--font-sm); font-weight: 600; line-height: 1.3;
}
.live-status b { color: var(--ui-ink); font-weight: 800; }
/* Cât rulează un battle, bannerul stă pe tenta de live — aceeași ca nodul LIVE din bracket. */
.live-status--live { background: var(--ui-live-tint); }
.live-status__txt { min-width: 0; }
/* „● Urmează" = ce vine, starea SELECTATĂ: violetul de identitate (cast-ui regula 2), ca eticheta URMEAZĂ din bracket. */
.live-status__next {
    font-family: var(--font-display); font-size: var(--font-xs); font-weight: 800;
    text-transform: var(--type-label-case, uppercase); letter-spacing: var(--type-label-tracking, .06em);
    color: var(--ui-accent);
}
/* Pe SALĂ: banda de JOS, la scara ecranului — `vw`, ca antetul de sală: banda stă în AFARA containerului
   `.bk-layout`, deci `cqi` n-ar avea pe ce se măsura. */
.live-status--venue {
    margin: clamp(.6rem, 1.2vw, 1.5rem) 0 0;
    font-size: clamp(var(--font-md), 1.6vw, var(--font-3xl));
}
.live-status--venue .live-status__next { font-size: .85em; }

/* MĂRIMEA numelui = cqi (lățimea containerului) × --nm-k (bucket-ul de LUNGIME al numelui, servit de
   presenter prin .sc-nm--m/--l): cqi nu știe cât de lung e textul — fără coeficient, numele scurte
   rămâneau mici degeaba, iar cele lungi se rupeau în cuvânt (break-word e plasa FINALĂ, nu regula).
   Pe proiector, zoom-ul din .live-projector amplifică totul încă o dată.
   ⚠️ Antetul „VS" propriu (`.sc__vs` / `.sc__side` / `.sc__score*`) a fost ȘTERS pe 2026-09-01:
   capul e acum ACELAȘI partial în ambele stări (`.sc-hd`), deci nu mai există două surse de nume
   care să arate diferit — și nimic nu mai sare la reveal. */
.sc-nm--m { --nm-k: .8; }
.sc-nm--l { --nm-k: .62; }
/* Nume lungi / 2v2 → maxim 3 rânduri apoi taie. `break-word`, NU `anywhere`: `anywhere` rupea ÎN
   INTERIORUL cuvântului chiar când nu era nevoie — „SATANEL" apărea ca „SATAN / EL". Cu `break-word`
   numele rămâne întreg cât timp încape (corpul literei scade fluid înainte) și se rupe doar dacă un
   singur cuvânt chiar nu are loc. */
.sc__nm {
    min-width: 0;
    display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical;
    overflow: hidden; overflow-wrap: break-word;
}
/* MĂRIMEA NUMELUI — recalibrată 2026-09-01. Trei lucruri, în ordinea importanței:

   1. PLAFONUL NU se mai înmulțește cu `--nm-k`. Înainte se înmulțea și mijlocul, și plafonul, deci
      punctul în care scara ÎNGHEȚA era acelasi (W=480px) indiferent de lungimea numelui — adică
      exact bugul: între 560px și 1400px lățime de ecran nu se mai schimba nimic. Acum numele lungi
      (k=.62) continuă să crească până la W≈815px, cele scurte până la W≈505px.
   2. Coeficientul urcă de la 7.5 la 6.5cqi *măsurat pe tot capul*, dar numele câștigă spațiu real:
      cifra a IEȘIT din jumătate în coloana din mijloc, deci celula nu mai împarte lățimea cu ea.
   3. `--nm-k` (bucketul de LUNGIME servit de presenter prin `.sc-nm--m/--l`) rămâne pe mijloc:
      `cqi` nu știe cât de lung e textul. Numele lung primește .62, cel scurt 1 → cutii de mărimi
      comparabile, nu litere de mărimi egale. */
.sc-hd__nm .sc__nm {
    font-size: clamp(var(--font-lg), calc(5.8cqi * var(--nm-k, 1)), calc(var(--font-9xl) * var(--scale-cap, 1)));
    /* RÂNDURILE STRÂNSE (2026-09-01, iter. 2). Numele n-avea `line-height` deloc, deci moștenea ~1.5
       din corp: un nume pe două rânduri lăsa între ele un gol cât o linie întreagă și umfla cutia cu
       ~18px. Proiectul folosește deja `line-height: 1` pe nume de afișaj (`.sc-totals__v`, bracket) — aici e strâns cu o treaptă sub, ca în macheta aprobată (.98).
       `letter-spacing` negativ: la weight 900 literele stau mai bine apropiate. */
    /* B159 L10 (F2): 1.15 + tracking 0. Valorile vechi (1.02, -.015em) erau pentru greutatea 900 si
       taiau diacriticele sub `overflow: hidden` + line-clamp. Coeficientul 6.5cqi -> 5.8cqi de mai sus
       are acelasi motiv: bucketul de marime numara lungimea TOTALA, iar „KILOMETRU / L ZERO" se rupea. */
    line-height: 1.15; letter-spacing: var(--type-name-tracking, 0);
}
.sc__tr { color: var(--ui-rank-gold-ink); flex-shrink: 0; font-size: clamp(var(--font-sm), 3.6cqi, calc(var(--font-3xl) * var(--scale-cap, 1))); }

/* Scor mare acumulat în antet = runde câștigate (2–0) */

/* ═══ RUNDA din detaliu (B135, 2026-09-02): bandă · rânduri de jurați · subsol ═══
   O rundă se citește ca un BON: capul spune ce rundă e și cine a luat-o (verdictul, centrat pe
   spinare); rândurile arată notele fiecărui jurat; subsolul adună neturile SUB coloana pe care o
   adună — privirea merge în jos spre total (foile de scor ISU/FIG pun suma la capătul coloanei).
   Istoric: capul ținea și punctele („trei scoruri ierarhizate", iter. 5) într-un rând flex cu
   `space-between` — eticheta „RUNDA 1" din stânga împingea totul, deci votul nu cădea pe mijloc și
   punctele nu stăteau sub concurenți. Acum bandă, rânduri și subsol stau pe ACEEAȘI grilă.
   ⛔ ȘTERSE 2026-09-01: culorile rotative `.sc-round--c0/c1/c2` (ciclau pe INDEXUL rundei, nu pe
   criteriu; fixate pe light; culoare fără sens pe un ecran unde culoarea = verdict). */
.sc-round {
    border-left: 4px solid var(--ui-edge);
    border-radius: var(--radius-sm); margin: 0 .45rem .4rem; overflow: hidden;
    /* CONTAINERUL DE MĂSURARE E RUNDA, nu `.sc-jt` (B135). Banda și subsolul sunt FRAȚII corpului, nu
       copiii lui: cu containerul pe `.sc-jt`, un `cqi` scris în bandă se rezolva pe următorul strămoș
       cu `container-type`, adică pe rândul de bracket (exact ce făcea, greșit, `.live-projector
       .sc--focus .sc-round__hd`). `.sc-jt` umple conținutul rundei, deci coeficienții vechi rămân.
       `.sc-round` nu e subgrid și nu găzduiește `position: fixed` — containment fără efecte secundare. */
    container-type: inline-size;
    /* SSOT DE COLOANE PE RUNDĂ: rândurile și subsolul consumă aceeași definiție, deci eticheta
       subsolului cade pe spinarea rândurilor PRIN CONSTRUCȚIE, nu din calibrare. (Banda are grila ei,
       tot simetrică — vezi acolo de ce.) `cqi` dintr-o proprietate custom se rezolvă pe elementul
       CONSUMATOR (un descendent), deci pe runda asta — nu pe cel care declară containerul. Mijlocul
       era `7.5rem` fix, cu două rescrieri care aproximau aceeași lățime (`.sc--focus` 10rem,
       `.bk-layout__current` 6.5rem); un clamp pe container le înlocuiește. Pe îngust caseta juratului
       cedează prima. */
    --sc-jt-cols: 1fr clamp(4.2rem, 16cqi, calc(7.5rem * var(--scale-cap, 1))) 1fr;
    /* ⛔ PISTE FIXE ÎN CELULĂ — NU (rev. 5, măsurat pe ecranul mare). În rev. 3-4 nume · valoare ·
       ajustare · net aveau piste fixe din container; pe `?proiector=1` (`--scale-cap: 2`) se dublau —
       137 + 83 + 128 + 109 = 457px + gap-uri într-o celulă de 412px — iar `overflow: hidden` TĂIA
       ultima pistă: nota finală dispărea pur și simplu de pe latura 1. Pragurile de stivuire sunt în
       `rem`, deci nu știu de `--scale-cap`. O pistă fixă e legitimă DOAR pentru ce nu scalează cu
       fontul. Singura rezervare care rămâne e lane-ul de ajustări (mai jos), și acela `minmax(rezervă,
       auto)`: crește dacă un chip e mai lat, nu taie. */
    --sc-jt-adj-w: 0px;
    /* GEOMETRIILE TREPTELOR, declarate O dată aici și doar ACTIVATE în cele două interogări de mai
       jos (altfel aceleași declarații ar sta de două ori). Trei trepte, cad UNA CÂTE UNA (rev. 6,
       owner: „penalizările să cadă primele sub criterii, abia apoi nota finală"):
         lat    — `sk | chip | arrow | net` pe un rând (fallback-ul din `.sc-jt__cell`);
         mediu  — chipul coboară SUB registru, în COLOANA registrului (aliniat cu valorile, nu la
                  spinare sub net — rev. 7, owner: „pică sub nota finală și criterii, la margine");
                  finalul rămâne la dreapta; fără chip rândul doi e gol (0 înălțime), deci rândurile
                  fără penalizare nu se schimbă;
         îngust — cade și finalul, pe rândul trei, la spinare („operație una sub alta"). */
    --sc-jt-mid-cols-1: minmax(0, 1fr) auto auto;
    --sc-jt-mid-cols-2: auto auto minmax(0, 1fr);
    --sc-jt-mid-areas-1: "sk arrow net" "chip . .";
    --sc-jt-mid-areas-2: "net arrow sk" ". . chip";
    --sc-jt-stack-cols-1: minmax(0, 1fr) auto auto;
    --sc-jt-stack-cols-2: auto auto minmax(0, 1fr);
    --sc-jt-stack-areas-1: "sk sk sk" "chip chip chip" ". arrow net";
    --sc-jt-stack-areas-2: "sk sk sk" "chip chip chip" "net arrow .";
}
/* LANE-UL DE AJUSTĂRI se rezervă la nivel de SCORECARD, nu de rundă (rev. 6). Cu rezerva per rundă,
   o rundă fără nicio penalizare avea pista 0 și registrul cu ~90px mai lat — valorile sub-notelor,
   aliniate spre mijloc, „stăteau mai la stânga sau mai la dreapta" decât în runda de deasupra
   (owner). Ochiul compară rânduri din același card, deci rezerva e aceeași pe toate rundele când
   battle-ul are orice ajustare (`.sc-detail--adj`, din Twig, pe listele `entryNAdjustments`).
   6rem > cel mai lat chip uzual („SCLIPIRE +2,5%" ≈ 91px): sub rezervă nu mai sare nici 1px; un chip
   mai lat lărgește pista (`minmax(rezervă, auto)`), nu se rupe. FĂRĂ `--scale-cap` — fontul chipului
   nu scalează pe proiector, deci nici pista lui. */
.sc-detail--adj .sc-round { --sc-jt-adj-w: 6rem; }
.sc-round:first-of-type { margin-top: .4rem; }
/* runda extra (golden) — scoasă în evidență cu auriu */
/* Runda extra: muchie + tenta `warning` din paleta, fara inelul de umbra (B159 L10, F2). */
.sc-round--golden { border: 2px solid var(--ui-warning); border-left-width: 5px; background: var(--ui-warning-soft); }
/* Capul rundei golden poartă PERECHEA lui (fundal + cerneală din același rol `warning`): banda obișnuită e pe
   `--surface-inverse` / `--text-on-inverse` (mai jos), iar cerneala ei pe fundalul de avertisment ar cădea sub prag.
   Copiii benzii moștenesc (`color: inherit`), deci sub golden urmează perechea fără reguli paralele. */
.sc-round--golden .sc-round__hd { background: var(--ui-warning-soft); color: var(--ui-on-warning-soft); }

/* ── BANDA rundei: eticheta la margine, VERDICTUL centrat pe spinare, pe UN SINGUR rând ──
   Aceeași suprafață ca toggle-ul deschis (și ca fosta bandă `.sc__bar`, urcată în linia de sus la B195 L2) (`--surface-inverse`): banda e capul
   grupului, pe muchia de sus (pattern `fieldset`/`legend`, UI_RULES „Gruparea vizuală"), și iese în
   evidență ca să se vadă de unde începe fiecare rundă (cerere owner 2026-09-02). Copiii moștenesc
   cerneala, ca sub golden să urmeze fundalul pinned fără reguli paralele.
   GRILA `1fr auto 1fr`, NU `--sc-jt-cols` (rev. 2, owner: „să nu mai pice runda pe două rânduri; văd
   că încape; maxim scurtăm runda 1 sau se taie din ea"): verdictul ia exact lățimea lui (`auto`),
   iar cele două `1fr` egale îl țin centrat pe spinare oricât ar crește; eticheta din col. 1 se
   STRÂNGE în loc să se suprapună și se taie cu „…". Cu mijlocul fix al rândurilor, verdictul depășea
   coloana și pe îngust intra peste etichetă — de aici venea căderea pe rândul doi, scoasă acum. */
.sc-round__hd {
    display: grid; grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr); align-items: center;
    column-gap: .5rem;
    padding: .25rem .6rem;
    background: var(--ui-quiet); color: var(--ui-ink);
    font-size: var(--font-xs); font-weight: 600; text-transform: none; letter-spacing: 0;
}
/* Eticheta rundei — display 900, o treaptă peste restul benzii (`em`, ca `.sc--focus` și proiectorul
   s-o crească odată cu banda, dintr-o singură regulă). `min-width: 0` + ellipsis: pe îngust cedează
   EA, nu verdictul („RUNDA EXTRA", nu „RUNDĂ DE DEPARTAJARE" — un nume scurt n-are ce tăia). */
.sc-round__no {
    grid-column: 1; justify-self: start; min-width: 0; max-width: 100%;
    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
    font-family: var(--font-display); font-weight: 700; font-size: 1.15em; color: inherit;
}
/* Verdictul stă în coloana `auto` din mijloc — centrul benzii = spinarea rândurilor (ambele simetrice). */
.sc-round__res { grid-column: 2; display: inline-flex; align-items: baseline; gap: .6rem; white-space: nowrap; }
/* „egal" nu poate ieși în evidență prin greutate — părintele `.sc-round__verdict` e deja 700.
   Se distinge prin SCRIERE, singurul canal liber în cutia aia. */
.sc-round__w--tie { text-transform: var(--type-status-case, uppercase); letter-spacing: var(--type-status-tracking, .06em); }
/* VOTUL JURAȚILOR și CUMULUL PE RUNDE — LA FEL DE MARI (owner, 2026-09-02 rev. 2; înainte cumulul era
   .85em estompat). Ambele sunt axe care DECID (votul ia runda, rundele iau battle-ul), iar etichetele
   „jurați" / „runde" le țin despărțite. Punctele — singura cifră care POATE contrazice verdictul
   (corolar 5b) — nu mai stau aici deloc: sunt în subsol, unde adună coloana neturilor. */
.sc-round__verdict, .sc-round__cum {
    display: inline-flex; align-items: baseline; gap: .25em;
    font-family: var(--font-mono); font-weight: 700; font-variant-numeric: tabular-nums;
    font-size: 1.2em; color: inherit;
}
/* Egalul primește ȘI fundalul, nu doar cerneala `on-`: o cerneală `on-X` folosită în afara lui X
   e interzisă de UI_RULES (corolar 6b). Perechea completă pe ACELAȘI selector — `contrast-audit.php`
   o prinde singur, pe orice bandă (inversă sau golden) ar sta. */
/* La egal, „egal" nu se estompeaza: e un verdict, nu o nota de subsol (B159 L10, F2). */
.sc-round__verdict.is-tie small { opacity: 1; }
.sc-round__verdict.is-tie {
    background: var(--ui-warning-soft); color: var(--ui-on-warning-soft);
    padding: 0 .3em; border-radius: var(--radius-sm);
}
/* Etichetele „jurați" / „runde" rămân MEREU vizibile: fără ele, „1–2" și „0–1" alături se citesc ca
   o singură cifră pe proiector. Nu se scot „ca să fie mai curat" — ele separă cele două axe. */
.sc-round__verdict small, .sc-round__cum small {
    font-size: .62em; font-weight: 400; letter-spacing: var(--type-label-tracking, .08em);
    text-transform: var(--type-label-case, uppercase); opacity: .7; margin-right: .15em;
}
.sc-round__tally { font-family: var(--font-mono); color: inherit; opacity: .8; flex-shrink: 0; }

/* ── SUBSOLUL rundei: suma punctelor NETE, sub coloana neturilor pe care o adună ──
   Aceeași grilă ca rândurile; valoarea laturii 1 se aliniază la DREAPTA în coloana 1, cu același
   padding interior ca celula (.6rem), deci muchia ei = muchia netului de deasupra; latura 2 în
   oglindă. Eticheta „puncte" stă pe mijloc, ca „total puncte" din `.sc-totals`. FĂRĂ sufixul „p" de
   pe vechile puncte din bandă: eticheta din mijloc îl spune, iar un „p" lipit ar decala zecimala față
   de neturile din coloană (mono, `tabular-nums`). Suprafață `--paper-2` + hairline sus — rețeta
   benzilor secundare (`.sc-totals`, `.sc-av`). */
.sc-round__ft {
    display: grid; grid-template-columns: var(--sc-jt-cols); align-items: baseline;
    padding: .18rem 0 .22rem; background: var(--ui-sunken); border-top: 1px solid var(--ui-hair);
}
.sc-round__pts {
    font-family: var(--font-mono); font-weight: 700; font-variant-numeric: tabular-nums;
    font-size: var(--font-md); color: var(--ui-ink); white-space: nowrap; line-height: 1;
}
.sc-round__ft .sc-round__pts:first-child { grid-column: 1; justify-self: end; padding-right: .6rem; }
.sc-round__ft .sc-round__pts:last-child  { grid-column: 3; justify-self: start; padding-left: .6rem; }
.sc-round__lbl {
    grid-column: 2; justify-self: center;
    font-size: var(--font-2xs); font-weight: var(--type-label-weight, 900); color: var(--ui-ink-muted);
    text-transform: var(--type-label-case, uppercase); letter-spacing: var(--type-label-tracking, .06em);
}

/* Tabel jurați — stânga = e1 | jurat | dreapta = e2. Fundal alb, neutru: din 2026-09-01 celula nu
   mai are umplere de proporție, deci nimic nu concurează cu cifrele. Containerul de măsurare e
   RUNDA (`.sc-round`, mai sus) — nu mai e aici, ca banda și subsolul să măsoare același lucru. */
.sc-jt { display: flex; flex-direction: column; background: var(--ui-flat); }
/* Coloanele vin din `--sc-jt-cols` (SSOT pe `.sc-round`): mijloc cu lățime EXPLICITĂ (nu `auto`) →
   celulele laterale e1/e2 rămân egale pe TOATE rândurile și rundele, indiferent de cât de lung e
   numele juratului/criteriului, iar cifrele nete cad pe aceeași coloană de la un jurat la altul.
   Numele/criteriile lungi se rup în mijlocul fix (overflow-wrap). */
.sc-jt__row {
    display: grid; grid-template-columns: var(--sc-jt-cols);
    align-items: stretch; border-top: 1px solid var(--ui-hair);
}
.sc-jt__row:first-child { border-top: none; }
/* `break-word`, nu `anywhere`: numele lungi se rup pe CUVINTE (cerut explicit) — `anywhere` le
   pulveriza literă cu literă. Podeaua lățimii o dă `clamp()`-ul din `--sc-jt-cols`, nu ruperea. */
.sc-jt__judge {
    display: flex; flex-direction: column; align-items: center; justify-content: center;
    padding: .12rem .4rem; text-align: center; line-height: 1.05;
    border-left: 1px solid var(--ui-hair); border-right: 1px solid var(--ui-hair);
    min-width: 0; overflow: hidden; overflow-wrap: break-word;
}
.sc-jt__jn { font-size: var(--font-xs); font-weight: 600; }
.sc-jt__jr { font-size: var(--font-2xs); color: var(--ui-ink-muted); text-transform: var(--type-label-case, uppercase); }
/* ── CELULA (B135 rev. 5-6, forma finală după șase runde de feedback) ──
              Fizic 7/10
           Artistic 6/10   SLIP −2,5%   → 16.2
      Interpretativ 8/10
   Patru piste, dintre care UNA SINGURĂ cedează: registrul (`minmax(0, 1fr)`) — și cedează prin
   RUPERE PE CUVINTE, niciodată prin tăiere (rev. 6, owner: „numele criteriilor trebuie citite mereu").
   Ajustarea (`minmax(rezervă, auto)`, pe un singur rând), săgeata (`auto`, cât glifa) și netul
   (`auto`, lipit de spinare) sunt cât conținutul lor, deci NU pot fi tăiate — cauza pentru care nota
   finală lipsea pe ecranul mare (piste fixe × `--scale-cap` > celulă) nu mai există.
   `align-items: center`: chip, săgeată și net stau pe mijlocul înălțimii registrului, iar celula NU
   crește. Săgeata are pista ei mică și cade lipită de net prin `gap`. Ordinea din DOM = ordinea
   asta; oglinda pe latura 2 vine tot din DOM, nu din `order` (WCAG 1.3.2 / 2.4.3, ADR 0041).
   Subtotalul „19/30" a fost SCOS în rev. 2 (repeta nota finală).
   ⛔ Caretul „favorizat" și muchia `inset 3px` au DISPĂRUT (rev. 3): marcajul e TENTA celulei.
   `position: relative; overflow: hidden` rămân ca plasă — cu piste `auto` nu mai au ce tăia. */
.sc-jt__cell {
    position: relative; overflow: hidden;
    display: grid;
    grid-template-columns: var(--sc-jt-cell-cols, minmax(0, 1fr) minmax(var(--sc-jt-adj-w), auto) auto auto);
    grid-template-areas: var(--sc-jt-cell-areas, "sk chip arrow net");
    align-items: center; justify-items: end;
    column-gap: .25rem; row-gap: .1rem;
    padding: .14rem .6rem; min-height: 1.55rem; min-width: 0;
}
/* Oglinda pentru latura din dreapta: „net ←" la spinare, ajustarea, apoi registrul cu valoarea
   ÎNAINTEA numelui (valorile spre mijloc, numele spre margine). */
.sc-jt__cell--entry2 {
    grid-template-columns: var(--sc-jt-cell-cols, auto auto minmax(var(--sc-jt-adj-w), auto) minmax(0, 1fr));
    grid-template-areas: var(--sc-jt-cell-areas, "net arrow chip sk");
    justify-items: start;
}
/* ── „FAVORIZAT" = TENTA celulei (rev. 3, owner: „scoatem săgeata de tot și dăm o ușoară tentă verde
   căsuței, toată") ──
   Familia WINNER (`--winner-edge`, nu `--success` — al patrulea vocabular de „câștigător" e exact ce
   semnalează B133), derivată LOCAL prin `color-mix`, fără token nou. 22 % peste card = ~1.37:1 pe
   light / ~1.67:1 pe dark — intensitatea suprafeței laturilor nedecise (`--c-kf-side`: 1.40 / 1.61),
   deci același registru de „tentă discretă" ca restul fișierului.
   ⚠️ SUB 3:1 (WCAG 1.4.11), ASUMAT de owner. E acceptabil fiindcă tenta e REDUNDANTĂ: la același
   maxim „favorizat" = netul mai mare, iar netul e scris în celulă; pastilele din grilă poartă și ele
   votul. `contrast-audit.php` NU vede `color-mix` — perechea e documentată acolo de mână.
   Egalul: aceeași rețetă în amber, și pe celulele laterale, și pe caseta juratului din mijloc (care
   stătea pe `--warning-soft`, 1.06:1 față de card pe light — adică invizibilă). */
.sc-jt__cell.is-fav { background: color-mix(in srgb, var(--ui-win) 22%, var(--ui-flat)); }
.sc-jt__cell.is-tie, .sc-jt__judge.is-tie { background: color-mix(in srgb, var(--ui-warning) 22%, var(--ui-flat)); }
/* NETUL — concluzia celulei, lipit de spinare (dreapta la e1, stânga la e2), `tabular-nums` ⇒
   zecimalele stau una sub alta de la un jurat la altul, iar suma din subsol cade fix sub el.
   `min-width: 4ch` (rev. 7, MĂSURAT): pista netului e `auto`, deci lată cât textul — „24.2" = 32px,
   „19" = 16px — și registrul de lângă ea se muta cu 16px de la un rând la altul („notele stau mai la
   dreapta sau mai la stânga", owner; dădeam vina pe chip, coincidea). `4ch` e lățimea celui mai lat
   net posibil (mono ⇒ 4 caractere = „28.5"), în CARACTERELE NETULUI, deci scalează cu fontul lui pe
   focus și pe proiector fără să poată tăia (pista rămâne `auto`, doar conținutul are podea).
   Textul aliniat spre spinare în cutia de 4ch ⇒ cifrele stau pe aceeași verticală. */
.sc-jt__net {
    grid-area: net; font-family: var(--font-mono); font-weight: 700; font-size: var(--font-md);
    font-variant-numeric: tabular-nums; color: var(--ui-ink); white-space: nowrap;
    min-width: 4ch; text-align: end;
}
.sc-jt__cell--entry2 .sc-jt__net { text-align: start; }
/* SĂGEATA spre net (B135): legenda promitea „→ 7" de luni de zile, iar celula n-o randa. E semnul
   NON-cromatic care spune care cifră iese din care — merge pe proiector și când celula se stivuiește
   pe îngust. Marcaj în DOM (`aria-hidden`), nu `content:` CSS, ca să fie testabil prin HTTP și să nu
   fie citit de cititorul de ecran. Mono, ca cifrele dintre care stă; `--fg3` = 6.04:1 pe card. Pista
   ei e `auto` = cât glifa; de net o desparte doar `column-gap`-ul celulei (rev. 5: „lane mai mic"). */
.sc-jt__arrow { grid-area: arrow; font-family: var(--font-mono); font-size: var(--font-md); color: var(--ui-ink-muted); line-height: 1; }
.sc-jt__eq { font-size: var(--font-2xs); font-weight: 700; text-transform: var(--type-status-case, uppercase); letter-spacing: var(--type-status-tracking, .03em); color: var(--ui-warning); }
/* REGISTRUL sub-notelor: o LINIE per sub-notă, numele și valoarea în ACELAȘI wrap („Fizic 7/10" —
   owner, rev. 5: „notele în același wrap cu numele criteriilor"). Liniile sunt aliniate spre
   MIJLOC (`flex-end` la e1, `flex-start` la e2), deci valorile stau pe muchia dinspre spinare, una
   sub alta, iar numele ies spre margine — oglinda exactă între laturi. Nume și valoare sunt lipite
   prin construcție (un spațiu). Linia cedează prima în celulă, dar NUMAI prin rupere pe cuvinte
   (`white-space: normal`): FĂRĂ ellipsis — numele criteriilor „trebuie citite mereu" (owner, rev. 6),
   iar treptele de mai jos sunt calibrate ca ruperea să nu fie necesară în practică. Valoarea nu se
   rupe niciodată de „/10" (`nowrap`). La o singură sub-notă numele lipsește: linia E nota („9/10"). */
.sc-jt__sk {
    grid-area: sk; justify-self: stretch; min-width: 0;
    display: flex; flex-direction: column; align-items: flex-end; row-gap: 1px;
}
.sc-jt__cell--entry2 .sc-jt__sk { align-items: flex-start; }
.sc-jt__skl { min-width: 0; max-width: 100%; white-space: normal; line-height: 1.25; text-align: end; }
.sc-jt__cell--entry2 .sc-jt__skl { text-align: start; }
/* Registrul e STINS la toate lățimile (rev. 10-11, owner: „se atrage atenția numai asupra notei
   finale, e o alegere bună"): sub-note, nume și „/max" pe 400 + `--fg3`, ca pozițiile de pe un bon;
   singurul lucru gras și pe cerneală plină din celulă e nota finală. ⚠️ `--fg2`, nu `--fg3`, n-ar
   stinge nimic: pe tema KF `--fg2: var(--kf-text)` = `--fg1`. `--fg3` = cerneala săgeții, 6:1 pe card. */
.sc-jt__skn { font-size: var(--font-xs); color: var(--ui-ink-muted); }
.sc-jt__skv { font-family: var(--font-mono); font-weight: 400; font-size: var(--font-sm); color: var(--ui-ink-muted); font-variant-numeric: tabular-nums; white-space: nowrap; }
.sc-jt__skv small { font-size: var(--font-2xs); color: var(--ui-ink-muted); font-weight: 400; }
/* Chip-ul de ajustare (`.adj-chip`) e definit ÎN tokens.css — singurul fișier încărcat și de
   scorecard, și de ecranul juratului, deci culoarea pe nivel e aceeași pe ambele (ADR 0021 am.3).
   PE UN SINGUR RÂND (rev. 5, owner: „Sclipire se rupe pe două rânduri și înalță divul"): pista lui e
   `minmax(rezervă, auto)`, deci un chip mai lat decât rezerva LĂRGEȘTE pista în loc să se rupă sau
   să intre peste sub-note; registrul (`1fr`) cedează. Centrat vertical de `align-items` pe celulă.
   Nu se micșorează la nevoie: e deja pe cel mai mic token de font (~10px), sub el nu se mai citește
   pe proiector — când nu încape, CADE sub registru (treapta medie), mecanismul care chiar câștigă
   lățime. */
.sc-jt .adj-chip { grid-area: chip; white-space: nowrap; }
/* TREAPTA MEDIE (sub ~42rem de CONTAINER = runda): chipul CADE sub registru, finalul rămâne la dreapta
   (owner, rev. 6: „penalizările să cadă primele, abia apoi nota finală"). Fără chip, rândul doi are
   0 înălțime, deci rândurile fără penalizare nu se mișcă. Pragul, din conținut: pe lat o latură cere
   registru (~110px, „Interpretativ 8/10") + rezerva de chip (96) + săgeată (11) + net (36) + gap-uri
   + padding ≈ 284px; două laturi + mijlocul ≈ 675px ⇒ 42rem. */
@container (max-width: 42rem) {
    .sc-jt__cell { --sc-jt-cell-cols: var(--sc-jt-mid-cols-1); --sc-jt-cell-areas: var(--sc-jt-mid-areas-1); }
    .sc-jt__cell--entry2 { --sc-jt-cell-cols: var(--sc-jt-mid-cols-2); --sc-jt-cell-areas: var(--sc-jt-mid-areas-2); }
}
/* TREAPTA ÎNGUSTĂ (sub ~29rem, telefon): cade și finalul, pe rândul trei, la spinare — „ca o operație
   matematică una sub alta". Pragul: registru (~110) + săgeată + net + gap-uri + padding ≈ 188px pe
   latură ⇒ 376 + mijlocul ≈ 468px ⇒ 29rem.
   „RESTUL MAI ÎN SPATE" = POZIȚIE, nu prominență (rev. 11; owner: „notele nu stau mai în urma notei
   finale, sunt tot aliniate"). Trei revizii au citit greșit cuvântul: mărime (rev. 6, 9 — finalul a
   ajuns mai mare decât suma rundei, inversare de ierarhie) și cerneală (rev. 10 — păstrată, dar
   mutată pe toate lățimile, la regula registrului). Măsurat: sub-note, chip și net aveau TOATE
   muchia la același pixel. Idiomul de registru contabil: detaliile într-o coloană interioară,
   totalul „trecut" spre exterior — aici sub-notele și chipul se retrag de la muchia spinării cu
   `--space-3`, iar nota finală rămâne SINGURA pe muchie. Un token, nu „coloana următoare" (netul
   întreg dincolo de operanzi ar lăsa coloana la ~84px și ar rupe „Interpretativ 7/10" și numele din
   Trivium pe telefon). Fără `--scale-cap`: treapta asta nu apare pe proiector. Selectoare (0,3,0),
   ca la vecini, ca să nu piardă la egalitate cu regulile de context. */
@container (max-width: 29rem) {
    .sc-jt__cell { --sc-jt-cell-cols: var(--sc-jt-stack-cols-1); --sc-jt-cell-areas: var(--sc-jt-stack-areas-1); }
    .sc-jt__cell--entry2 { --sc-jt-cell-cols: var(--sc-jt-stack-cols-2); --sc-jt-cell-areas: var(--sc-jt-stack-areas-2); }
    .sc .sc-jt__cell .sc-jt__sk { padding-inline-end: var(--space-3); }
    .sc .sc-jt__cell .adj-chip { margin-inline-end: var(--space-3); }
    .sc .sc-jt__cell--entry2 .sc-jt__sk { padding-inline-end: 0; padding-inline-start: var(--space-3); }
    .sc .sc-jt__cell--entry2 .adj-chip { margin-inline-end: 0; margin-inline-start: var(--space-3); }
}

/* Legendă reveal — explică notă / % / bară / crash pentru oameni obișnuiți */
.sc-legend {
    display: flex; flex-wrap: wrap; gap: .3rem 1.1rem;
    padding: .4rem .65rem; background: var(--ui-sunken); border-bottom: 1px solid var(--ui-hair);
    font-size: var(--font-2xs); color: var(--ui-ink-muted);
}
.sc-legend > span { display: inline-flex; align-items: center; gap: .35rem; }
.sc-legend__k {
    font-family: var(--font-mono); color: var(--ui-ink);
    background: var(--ui-flat); border: 1px solid var(--ui-hair); border-radius: var(--radius-sm); padding: 0 .3rem;
}

/* ȘTERS 2026-09-01 — TOT vocabularul `.sc-jc*` (tabelul de criterii: 3 coloane % | criteriu | %) și,
   la rescrierea capului din aceeași zi, ultimul supraviețuitor `.sc-jc__pens`. Rezumatul pe criterii
   folosește acum ACEEAȘI grilă de pastile ca cel pe runde (`.sc-jg`, mai jos): la panel juratul E
   criteriul, deci coloanele grilei sunt criteriile; cifrele exacte trăiesc în detaliul din toggle.
   Chip-urile de ajustări au trecut în `.sc-hd__adj` / `.sc-hd__adjg` — din B158, în cutia concurentului.
   `.sc-totals` / `.sc-av` nu depindeau de `.sc-jc`; din 2026-09-01 își iau coloanele din `--sc-cols`,
   partajat cu capul — vezi blocul de mai jos. */
/* ═══════════════════════════════════════════════════════════════════════════
   CAPUL BATTLE-ULUI (`.sc-hd`) — RESCRIS 2026-09-01, structură nouă.

   TREI COLOANE × PATRU RÂNDURI, celulele direct pe grila părintelui:

       col 1 (1fr)     col 2 (mijloc)   col 3 (1fr)
       __crew          __mid            __crew      rând 1  ┐
       __nm            (rândurile 1-2)  __nm        rând 2  │ umplute cu verdictul (cutia concurentului)
       __adj ─ două jumătăți flex care cresc spre centru ─  rând 3  ┘ cipurile LUI, SUB cifre (B158 → B219)
       __tiebreak ──── toată lățimea ───────────    rând 4

   DE CE s-a rescris (istoric — nu reintroduce forma veche):
   1. Cifra stătea ÎN jumătate, care era `subgrid` cu coloane proprii + reguli de oglindire pe
      `--entry2`. Fiecare proprietate se scria de două ori ⇒ două reguli (0,2,0) se băteau și
      chip-urile din dreapta se aliniau la stânga, deși comentariul promitea oglindire.
   2. Scara era MOARTĂ: cifra atingea plafonul de 48px la o lățime de container de 282px, numele la
      480px. Între 560px și 1400px lățime de ecran capul nu-și mai schimba nicio mărime, iar cifra
      era 3× numele pe telefon. Coeficienții de mai jos sunt recalibrați ca scara să rămână vie.
   3. Chip-urile de ajustări stăteau PESTE umplerea de verdict: 1.00–1.32:1 pe olive (light), adică
      invizibile ca formă. Au stat pe un canal pe fundalul cardului, pe toată lățimea, până la B158
      (2026-09-16), când ownerul le-a cerut înapoi ÎN cutia concurentului („să fie ale lor"): canalul se
      citea ca „o linie albă ruptă". Diferența față de forma veche: umplerea e lime / gri (nu olive), iar
      cipul are un inel de contur (skin) — forma rămâne vizibilă. NU reveni la canal fără ownerul.

   ⚠️ CONTAINERUL DE INTEROGARE STĂ PE `.sc-hd`, niciodată pe o celulă: `cqi` măsoară TOT capul, deci
   toți coeficienții de mai jos sunt calibrați pe lățimea întreagă. Mutat pe celulă, se dublează tăcut.
   ⚠️ Fără `subgrid`: celulele stau direct pe rândurile părintelui, deci cele două laturi se aliniază
   PRIN CONSTRUCȚIE (regula UI_RULES „ce trebuie aliniat între doi frați nu poate sta în interiorul
   lor"). Nu reintroduce jumătăți-wrapper — de acolo veneau coliziunile.
   ═══════════════════════════════════════════════════════════════════════════ */

/* SSOT DE COLOANE. Capul, rândul de vot, totalurile și votul publicului au ACELEAȘI trei coloane —
   înainte se aliniau doar din simetrie („spinarea"), adică din noroc. Acum din definiție. */
.sc {
    /* Rândurile cu ETICHETĂ pe mijloc („total puncte", „Vot public") — au nevoie de lățime. */
    --sc-cols: 1fr minmax(4.5rem, calc(8.5rem * var(--scale-cap, 1))) 1fr;
    /* Capul + rândul de vot — mijlocul ține doar „VS"/scorul, deci e o FRACȚIUNE, nu o lățime fixă:
       ~14% din propria lățime, cu o podea care acoperă cel mai lat scor. Procent, nu `cqi`: vezi nota
       de la `.sc-hd`. Aceeași valoare în ambele ⇒ canalul dintre jumătăți nu are treaptă. */
    --sc-mid: minmax(2.6rem, 14%);
}

.sc-hd {
    display: grid;
    /* MIJLOCUL are lățime PROPRIE (`--sc-mid`), nu `--sc-cols`.
       ⚠️ Cifra care conta nu era podeaua, ci PLAFONUL. Cu `minmax(4.5rem, 8.5rem)` și `min-width: 0`
       pe celulele laterale, baza celor două `fr` e 0 — deci §12.6 „Maximize Tracks" umflă mijlocul
       până la growth limit (8.5rem = 136px) ÎNAINTE ca §12.7 să împartă restul între `fr`-uri. Pe un
       card de 340px asta însemna 136px = 40% pentru o cutie care ține „VS". (Estimarea „72px = 21%"
       era greșită cu 2×: măsura podeaua, nu ce se întâmplă efectiv.)
       ⚠️ NU `auto`: ar fi content-driven, deci lățimea ar diferi între „VS" (2 caractere) și scor
       („10–8" e posibil la panel cu multe criterii) ⇒ coloanele de nume s-ar redimensiona la reveal
       și punctul de rupere al numelui s-ar muta. Track EXPLICIT = aceeași lățime în ambele stări.
       ⚠️ Nici `min-width` pe `.sc-hd__mid` nu ajută: pe ELEMENT nu poate îngusta un track, doar să-l
       apere. Valoarea trebuie să intre în definiția coloanei, adică aici.
       ⚠️ Și NU `cqi` aici: unitățile de container NU se rezolvă pe elementul care DECLARĂ containerul
       (`.sc-hd` are `container-type` mai jos), deci `11cqi` scris aici s-ar măsura pe `.bk-layout` —
       tot rândul de bracket. PROCENTUL, în schimb, se raportează la lățimea proprie a grilei, exact
       ce trebuie. `.sc__vote` folosește aceeași valoare și are aceeași lățime, deci canalul dintre
       jumătăți se continuă fără treaptă (numele + butoanele = un bloc, cerere 2026-08-15).
       Podeaua (2.6rem) acoperă cel mai lat conținut posibil la fontul minim al mijlocului
       („10–8" ≈ 2.4em la 13px ≈ 31px) și e ȘI separatorul care ține cele două umpleri de verdict să
       nu se atingă — singurul motiv real de lățime minimă la cap. */
    grid-template-columns: 1fr var(--sc-mid) 1fr;
    grid-template-rows: auto auto auto auto; gap: 0;
    background: var(--ui-flat); font-variant-numeric: tabular-nums;
    container-type: inline-size;
    /* Paddingul celulelor: FLUID, nu `rem` fix. Fixul era cauza pentru „divurile se înalță cât un
       sfert de ecran" pe telefon (13.6px sus+jos oricât de îngust era) și, invers, rămânea pe loc pe
       proiector în timp ce fonturile se dublau.
       Coborât încă o treaptă 2026-09-01 (a doua iterație): penalizările au ieșit în canalul lor, deci
       cutia nu mai are ce ține înăuntru — cerința e „mai lată decât înaltă, subtil vizibilă". */
    --sc-hd-py: clamp(.25rem, 1.2cqi, calc(.9rem * var(--scale-cap, 1)));
    --sc-hd-px: clamp(.4rem, 1.8cqi, calc(1rem * var(--scale-cap, 1)));
    /* BANDA DE CIPURI (rândul 3; B158 → B219) — mărimea și înălțimea ei, declarate O DATĂ: le citesc
       grupurile (`.sc-hd__adjg`, rezervarea `min-height`); mijlocul NU le mai citește de la B219 (ține doar
       rândurile 1-2). Custom property nerezolvată aici: `cqi` se rezolvă la consumator, deci măsoară tot `.sc-hd`.
       Podeaua `--font-3xs`: pe ecran mic cipurile SE MICȘOREAZĂ odată cu capul (cererea ownerului), nu
       stau blocate la 11px cât numele. */
    --sc-hd-adj-fs: clamp(var(--font-3xs), 2cqi, calc(var(--font-md) * var(--scale-cap, 1)));
    --sc-hd-adj-h: calc(var(--sc-hd-adj-fs) * 1.5 + var(--sc-hd-py) * .35 + max(4px, var(--sc-hd-py) * .8));
}

/* ---- CELULELE DE IDENTITATE (rândurile 1-2) ---- */
.sc-hd__sub, .sc-hd__nm {
    min-width: 0; padding-inline: var(--sc-hd-px);
    font-family: var(--font-display);
    background: var(--ui-quiet);
}
.sc-hd__sub { grid-row: 2; text-transform: var(--type-title-case, uppercase); }
/* B195 L2 (prototipul fluxului live): NUMELE e rândul 1, membrii / crew-ul (`.sc-hd__sub`) rândul 2 — până atunci
   invers (supratitlu). Spațiul vertical e același: aerul de SUS al cutiei (.6 din pas) stă acum pe nume, iar cel de
   JOS (.3), dintre identitate și canalul de ajustări, pe linia de sub nume. ⚠️ NU zero jos: între identitate și
   `.sc-hd__adj` nu există linie de separare (`gap: 0`), deci tot spațiul vine de aici plus din paddingul canalului —
   la zero s-ar lipi pe proiector, unde numele urcă la `--font-9xl`. */
.sc-hd__nm { grid-row: 1; padding-top: calc(var(--sc-hd-py) * .6); display: flex; align-items: center; gap: .4rem; font-weight: var(--type-name-weight, 900); text-transform: var(--type-name-case, uppercase); letter-spacing: .02em; }

/* Plasarea pe coloană + oglindirea, O SINGURĂ DATĂ fiecare. Latura 2 e împinsă spre marginea
   EXTERIOARĂ; nu se folosește `order`/`row-reverse` nicăieri (WCAG 1.3.2/2.4.3, ADR 0041) — ordinea
   din DOM e deja ordinea de citire. */
.sc-hd__c--1 { grid-column: 1; text-align: start; border-inline-start: 6px solid var(--ui-ink); }
.sc-hd__c--2 { grid-column: 3; text-align: end; border-inline-end: 6px solid var(--ui-ink-muted); }
.sc-hd__c--2.sc-hd__nm { justify-content: flex-end; }
/* Barele de identitate de 6px de pe marginile capului se opreau brusc sus si jos („pare ca se taie").
   Latimea lor e structura (ramane), culoarea urmeaza umplerea cutiei — deci nu se mai vad ca linie
   separata, iar coltul rotunjit al cardului ramane curat. Cutia = crew + nume + CIPURILE.
   ⚠️ Regula sta DUPA `.sc-hd__c--1/2` inadins: aceeasi specificitate (0,1,0), deci ordinea decide.
   Coborata din `@layer skin` la B159 L10 (F2), unde castiga prin layer. */
.sc-hd__sub,
.sc-hd__nm,
.sc-hd__adjg { border-inline-color: var(--ui-quiet); }

/* Verdictul umple AMBELE celule ale laturii. Contigue pe verticală (`gap: 0`), deci se citesc ca un
   bloc, nu ca două dungi. Mijlocul rămâne pe card ⇒ cele două culori nu se ating. */
.sc-hd__sub.is-win, .sc-hd__nm.is-win, .sc-hd__adjg.is-win { background: var(--ui-win); color: var(--ui-on-win); border-inline-color: var(--ui-win); }
.sc-hd__sub.is-out, .sc-hd__nm.is-out, .sc-hd__adjg.is-out { background: var(--ui-lose); color: var(--ui-ink-muted); border-inline-color: var(--ui-lose); }
/* INVINSUL are aceeasi greutate ca invingatorul, cu o treapta imperceptibil mai jos, si e ESTOMPAT prin
   CULOARE: o greutate mult mai mica „se vedea oribil" langa castigator. B159 L10 (F2). */
.sc-hd__nm.is-out { font-weight: 750; }
/* Cupa moștenește cerneala laturii: aurul pe umplerea de accent e ilizibil. */
.sc-hd__nm.is-win .sc__tr { color: inherit; }

/* IDENTITATEA SECUNDARĂ — linia de SUB nume (supratitlu până la B195 L2), lipită de el: la echipe COMPONENȚII, la solo CREW-ul
   (`BattleScorecardPresenter::subLine()`). Un rând, tăiat cu „…".
   ⚠️ `min-height` E OBLIGATORIU, dar exact CÂT UN RÂND (2026-09-01, iter. 4). Rândul se rezervă
   MEREU, chiar gol: fără el capul își schimba înălțimea de la un battle la altul, după cum avea sau
   nu ce scrie acolo. NU se întoarce la `1.35em` — aia lăsa spațiu mort deasupra și făcea linia să
   citească drept o bandă separată, nu un supratitlu. `1.1em` = fix `line-height`-ul de mai jos.
   Perechea lui e `padding-top` la 60% din pasul comun: destul aer cât să nu se lipească de muchie,
   nu atât cât să pară un rând de sine stătător.
   B158 (2026-09-16, ownerul: „se văd foarte, foarte subtil și font foarte mic"): o treaptă mai mare
   (podea `--font-xs`, plafon `--font-md`), greutate 600, FĂRĂ opacitate — opacitatea făcea pe umplerea
   de verdict o bandă de altă nuanță deasupra numelui. */
.sc-hd__sub {
    min-height: 1.1em; padding-bottom: calc(var(--sc-hd-py) * .3);
    /* Linia de crew / componenti se vedea „foarte, foarte subtil" -> cerneala tare pe latura nedecisa
       (cea a verdictului vine din regula de umplere de mai sus). B159 L10 (F2). */
    font-weight: 600; letter-spacing: .02em; line-height: 1.1;
    font-family: var(--font-mono);
    font-size: clamp(var(--font-xs), 2.2cqi, calc(var(--font-md) * var(--scale-cap, 1)));
    color: var(--ui-ink);
    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
}
/* ⚠️ Pe umplerea de verdict cerneala vine din regula de umplere, NU din `inherit`.
   `color: inherit` aici ar fi (0,2,0) ca ea și, venind mai jos, ar câștiga — crew-ul ar moșteni
   cerneala CORPULUI peste umplere. Fără wrapper de latură nu mai există de la cine să moștenești. */

/* ---- MIJLOCUL (rândurile 1-2, coloana 2; B219 — rândul 3 e al cipurilor) — „VS" înainte, cifrele după ---- */
/* Un singur element care își schimbă TEXTUL. De aici vine „la reveal nu se mișcă nimic": nodul e
   același, deci morph-ul nu inserează și nu șterge nimic. */
.sc-hd__mid {
    /* 1 / 3 (B219): rândul 3 = cipurile de ajustare, un rând flex pe TOATĂ lățimea (`.sc-hd__adj`), în care cele două
       umpleri de verdict se întâlnesc la mijloc, sub cifre. Până la B219 mijlocul cobora până în rândul 3 (`1 / 4`) ca
       despicătura de culoare să fie continuă — acum o continuă chiar jumătățile de cipuri. */
    grid-column: 2; grid-row: 1 / 3;
    /* ⚠️ `stretch`, NU `center` (schimbat 2026-09-01, iter. 4): mijlocul trebuie să UMPLE celula lui
       de grilă, altfel fundalul de mai jos ar picta doar cutia conținutului și ar rămâne card în jur.
       Conținutul se centrează din interior. `align-items: center`, nu `baseline`: cele două cifre au
       același corp de literă, deci rezultatul e identic, dar merge și când cutia e mai înaltă. */
    display: flex; align-items: center; justify-content: center; gap: .25em;
    /* CULORILE CONCURENȚILOR TREC PESTE MIJLOC, fix jumătate-jumătate (cerere owner 2026-09-01).
       E o întoarcere la intenția din B115/B116 — „culorile concurenților se întâlnesc la mijloc" —
       pe care am rupt-o când am scos cifra din jumătăți în coloana asta.
       Despicătura cade exact pe SPINARE fără niciun calcul: coloanele laterale sunt `1fr` egale și
       barele de accent sunt simetrice (6px de fiecare parte), deci 50% din mijloc E centrul capului.
       Oprire DURĂ (`0 50%` / `50% 100%`), nu `50%, 50%` — fără interpolare, muchie curată. Idiomul
       există deja în fișier: barele de scor din `judge.css` / `.smoke-*`. */
    background: var(--ui-quiet);
    /* B158 (cererea ownerului): cifrele stăteau centrate pe TOATĂ înălțimea (nume + cipuri) într-o coloană
       îngustă, deci ieșeau mici și cădeau sub nume. Mijlocul ține acum DOAR rândurile numelor (B219), deci
       cifrele se centrează pe ele fără rezervare jos (`padding-bottom: var(--sc-hd-adj-h)` a plecat odată cu
       `grid-row: 1 / 4`); cifrele POT depăși coloana spre interiorul cutiilor (numele stau spre marginile
       exterioare) — `z-index` ca latura 2, pictată după, să nu le acopere. */
    position: relative; z-index: 1;
    font-family: var(--font-display); font-weight: var(--type-number-weight, 900); line-height: .9;
    /* SCORUL FINAL E CE CONTEAZĂ — umple coloana, nu stă timid în ea (2026-09-01, iter. 3).
       Coeficientul vechi (3.4cqi) folosea ~50% din lățimea disponibilă: coloana nu era constrângerea,
       calibrarea era. Cu liniuța scoasă, conținutul cere 1.49em în loc de 1.86em (-20%), iar restul
       câștigului vine din coeficient. Rezultat: ~2x mai mare la ORICE lățime, fără să lățesc coloana.
       ⚠️ 7cqi, nu 7.5: la 300px lățime 7.5 umple coloana EXACT, iar .62em (lățimea cifrei în Archivo
       900) e o estimare, nu o măsurătoare din font. Marja acoperă abaterea. */
    font-size: clamp(var(--font-2xl), 9cqi, calc(var(--font-9xl) * 1.5 * var(--scale-cap, 1)));
}
/* Doar DOUA stari colorate. „Terminat fara castigator" e IMPOSIBIL: `winnerEntry = null` apare doar
   in constructorul lui Battle (status PENDING), iar toate caile spre COMPLETED seteaza un castigator.
   O a treia regula ar fi cod mort. */
.sc-hd__mid--w1 { background: linear-gradient(90deg, var(--ui-win) 0 50%, var(--ui-lose) 50% 100%); }
.sc-hd__mid--w2 { background: linear-gradient(90deg, var(--ui-lose) 0 50%, var(--ui-win) 50% 100%); }
/* Mărimea VS-ului față de cifrele de scor. Efectul (tăiat + rotit, B196) și culoarea stau într-o singură regulă, comună cu ringul Smoke:
   components.css, după `.smoke-vs__x`. */
.sc-hd__vs { font-size: .55em; }
/* Fiecare cifra sta pe JUMATATEA ei, deci isi ia cerneala de pe umplerea de sub ea — nu `--winner-ink`,
   care e cerneala de pe SUPRAFATA si ar fi gresita peste olive. Aceleasi clase ca celulele (`_s1`/`_s2`),
   nu un vocabular paralel: inainte cifra invinsului nu primea nicio clasa. */
.sc-hd__n { color: var(--ui-ink-muted); }
.sc-hd__n.is-win { color: var(--ui-on-win); }
.sc-hd__n.is-out { color: var(--ui-ink-muted); font-weight: 750; }

/* ---- AJUSTĂRILE (rândul 3) — ÎN CUTIA CONCURENTULUI (B158, 2026-09-16, cererea ownerului) ----
   Cipurile unui concurent sunt ALE LUI: stau sub numele lui, pe umplerea laturii lui (verdict / învins /
   latură nedecisă), cu bara de identitate continuă. Până acum stăteau pe un canal separat, pe fundalul
   cardului, între cutii și banda juraților — ownerul îl vedea ca „o linie albă ruptă". Motivul vechi
   (cipurile dispăreau ca FORMĂ peste olive, 1.00–1.32:1) a fost tratat cu un inel fin pe cip până la B219.
   B219 (decizia ownerului, 2026-10-05): `.sc-hd__adj` e UN RÂND FLEX pe toată lățimea (rândul 3), cu cele două
   grupuri ca jumătăți egale care cresc SPRE centru — cipurile stau SUB cifrele de scor, nu sub nume / crew
   (convenția sportivă: deducțiile lângă scorul pe care îl modifică; ownerul: „plasate sub scor au sens că au
   avut impact asupra lui"). Umplerile de verdict se întâlnesc la mijloc în rândul lor. Fără inel: pe light toate
   umplerile trec pragul grafic, pe dark pică pe latura învinsului (2.08 … 1.33) — acceptat de owner, „altă
   soluție" = B220 (umpleri mai deschise pe dark). Se randează MEREU, goale — rezervarea ține capul la aceeași
   înălțime înainte și după reveal. */
.sc-hd__adj {
    display: flex; grid-column: 1 / -1; grid-row: 3;
    /* Padding vertical PROPORȚIONAL, nu `.15rem` fix: fixul nu creștea cu fontul, deci pe proiector
       chip-urile ajungeau lipite de numele mare. Perechea lui `padding-bottom` de pe `.sc-hd__nm`.
       ⚠️ REZERVAREA SCALEAZĂ CU CONȚINUTUL (2026-09-01, iter. 5). `min-height: 1.25em` se măsura pe
       fontul CORPULUI (16px ⇒ 20px constant), în timp ce chipul crește cu `cqi` și `--scale-cap`.
       Peste ~537px lățime de cap rezervarea nu mai acoperea chipul, deci capul creștea la reveal
       (+4.7…+27px; pe proiector ~+25px). Sub 537px diferența era exact 0 — de asta părea „mică".
       Fixul: rândul poartă ACELAȘI font-size ca chipurile, iar `1.5em` = înălțimea lor reală
       (`line-height: 1.3` + `padding: .1em` × 2). Chipurile îl moștenesc, deci nu pot diverge. */
    /* `font-size` pe rând, moștenit de grupuri și de cipuri. O treaptă mai mare (cererea ownerului: „să mărim partea aia"). */
    font-size: var(--sc-hd-adj-fs);
}
/* Rezervarea = înălțimea unui cip (1.5em) + paddingul vertical, în border-box → cutia goală și cea cu
   un rând de cipuri au aceeași înălțime. */
.sc-hd__adjg {
    /* Jumătate egală a rândului (B219): cusătura cade la 50%, fix pe spinarea cifrelor. */
    flex: 1 1 0; min-width: 0;
    display: flex; flex-wrap: wrap; align-content: flex-start; gap: 2px;
    /* Podea de 6px jos: pe ecran îngust `--sc-hd-py` scade și cipurile ajungeau lipite de muchia cutiei.
       ⚠️ Cipurile POT trece pe al doilea rând când sunt multe (cutia are acum jumătate de lățime):
       rezervarea acoperă UN rând, deci la reveal cu 2+ rânduri capul crește o dată. Asumat — alternativa
       (fără wrap) ar ascunde penalizări, iar rezervarea de două rânduri ar lăsa goluri în fiecare cutie. */
    min-height: var(--sc-hd-adj-h);
    padding: calc(var(--sc-hd-py) * .35) var(--sc-hd-px) max(4px, calc(var(--sc-hd-py) * .8));
    background: var(--ui-quiet);
}
/* Cipurile cresc SPRE centru (B219): stânga le lipește de cusătură, dreapta la fel — citite ca ale scorului de deasupra. */
.sc-hd__adjg.sc-hd__c--1 { justify-content: flex-end; }
.sc-hd__adjg--r { justify-content: flex-start; }
/* `font-size: inherit` — scara vine de pe rând (vezi acolo), ca rezervarea și conținutul să nu
   poată diverge. Două declarații ale aceleiași scări = exact felul în care revine driftul.
   Fără inel (B219, ownerul: „fără border, direct numai culoare") — forma o dă umplerea; perechile umplere / latură
   sunt în contrast-audit.php, cele care pică pe dark în baseline cu motiv. */
.sc-hd__adj .adj-chip { font-size: inherit; padding: .1em .35em; line-height: 1.3; white-space: nowrap; }
/* Numarul (x2) si procentul FARA opacitate: pe umplerea de verdict cadeau sub pragul de text.
   ⚠️ `.adj-chip` e definit in tokens.css, pe care il incarca SI juratul — regula lui ramane acolo
   neatinsa, iar aceasta sta in scoreboard.css, foaie de site. Asa opacitatea urca doar pe site.
   Coborata din `@layer skin` la B159 L10 (F2). */
.adj-chip__count,
.adj-chip__pct { opacity: 1; }

/* ---- BANDA DE DEPARTAJARE (rândul 4) — o propoziție despre PERECHE, nu despre o latură ---- */
.sc-hd__tiebreak {
    grid-column: 1 / -1; grid-row: 4; padding: .2rem .6rem; text-align: center;
    background: var(--ui-warning-soft); color: var(--ui-on-warning-soft);
    border-bottom: 1px solid var(--ui-hair);
    font-family: var(--font-sans); font-weight: 600; text-transform: var(--type-status-case, uppercase);
    font-size: clamp(var(--font-3xs), 1.4cqi, calc(var(--font-2xs) * var(--scale-cap, 1)));
    letter-spacing: var(--type-status-tracking, .03em); line-height: 1.3;
}
.sc-hd__tiebreak b { font-family: var(--font-mono); }

/* Cupa dispare pe container îngust — înghesuia numele, care e informația. Prag și idiom deja folosite
   în fișier (`.live-sign__st`, `.sc-jt__cell`). Container, nu `@media`: capul își știe lățimea reală,
   ecranul nu. */
@container (max-width: 26rem) {
    .sc-hd__nm .sc__tr { display: none; }
}

/* Toggle „Detaliu pe jurați" — lipit sub rezumat, deschide tabelele pe runde (Bootstrap collapse).
   Capul de tabel NU se redublează: numele sunt deja în rezumatul de deasupra. */
/* rând-footer al aceleiași rame (nu cutie separată): full-width, doar hairline sus */
.sc-detail-toggle {
    display: flex; align-items: center; justify-content: space-between; gap: .5rem;
    width: 100%; margin: 0; padding: .3rem .6rem;
    background: transparent; border: 0; border-top: 1px solid var(--ui-hair); border-radius: 0;
    font-family: var(--font-display); font-size: var(--font-2xs); font-weight: 600;
    text-transform: var(--type-control-case, uppercase); letter-spacing: var(--type-control-tracking, .06em); color: var(--ui-ink-muted); cursor: pointer;
    transition: background .12s, color .12s, border-color .12s;
}
/* Hoverul trece pe tenta de cerneala — gramatica de hover a skinului (B159 L10, F2). */
.sc-detail-toggle:hover { background: color-mix(in srgb, var(--ui-ink) 8%, transparent); color: var(--ui-ink); }
.sc-detail-toggle[aria-expanded="true"] { background: var(--ui-quiet); color: var(--ui-ink); border-color: var(--ui-line); }
.sc-detail-toggle__chev { flex-shrink: 0; font-size: var(--font-sm); transition: transform .15s; }
.sc-detail-toggle[aria-expanded="true"] .sc-detail-toggle__chev { transform: rotate(180deg); }
/* FĂRĂ `border-top` aici: butonul de deasupra are deja unul, iar deschis se vedeau DOUĂ linii
   lipite (2026-09-01). Separarea o face butonul, care e mereu prezent deasupra detaliului. */
.sc-detail { border-top: 0; }
.sc--focus .sc-detail-toggle { font-size: var(--font-xs); padding: .4rem .75rem; }

/* Totaluri (baza tie-break) — 3 coloane simetrice, aceeași rețetă ca `.sc-av`. Capul (`.sc-hd`) are
   2 jumătăți, tot simetrice, deci SPINAREA lui cade pe centrul coloanei din mijloc de aici: fiecare
   total rămâne sub numele lui, eticheta pe mijloc. Era `flex
   space-between` (cifrele la margini, „mai centrat pe coloana numelui" — userul, 2026-08-27).
   `padding-inline: 0` — altfel centrul coloanelor s-ar decala față de nume cu jumătate din padding. */
.sc-totals {
    display: grid; grid-template-columns: var(--sc-cols);
    align-items: center; text-align: center;
    padding: .35rem 0; background: var(--ui-sunken); border-top: 1px solid var(--ui-hair);
}
/* TOTAL PUNCTE = info importantă (tie-break la egal) → cifre MARI, vizibile */
.sc-totals__v { padding: 0 .5rem; font-weight: var(--type-number-weight, 900); font-size: var(--font-3xl); color: var(--ui-ink-muted); line-height: 1; }
/* Totalul care conduce ia cerneala de accent (B159 L10, F2). */
.sc-totals__v--hi { color: var(--ui-win-ink); }
.sc--focus .sc-totals__v { font-size: var(--font-5xl); }
/* maxul teoretic (constant) = SCALA cifrei („18.6 / 30") — vizibil, nu estompat (cerere 2026-08-27) */
.sc-totals__max { font-size: var(--font-sm); color: var(--ui-ink-muted); font-weight: 400; margin-left: 3px; }
.sc--focus .sc-totals__max { font-size: var(--font-md); }
.sc-totals__lbl { font-size: var(--font-sm); font-weight: var(--type-label-weight, 900); color: var(--ui-ink-muted); text-transform: var(--type-label-case, uppercase); letter-spacing: var(--type-label-tracking, .06em); }

/* ═══ Grila JURAT × RUNDĂ (B115, 2026-08-27) — corpul AMBELOR rezumate din 2026-09-01 ═══
   La panel juratul E criteriul, deci aceleași coloane se citesc ca CRITERII — un singur corp, două
   moduri. Pastilele numără VOTURI DE JURAT și NU se adună în antet (UI_RULES „Cifrele de lângă un
   verdict", pct. 5); legenda în unitatea antetului stă pe axa care decide: numărul rundei
   (`.sc-jg__no`) la runde, capul de coloană (`.sc-jg__judge.is-*`) la criterii.
   Două grile suprapuse, nu una: capul `.sc-hd` are 2 jumătăți, corpul are N coloane egale
   (N = jurați, `--sc-jn` din template).
   Toate scările = `clamp(<token>, N cqi, calc(<token> * var(--scale-cap, 1)))` (ADR 0040 / 0041 am.1)
   → pe sală cresc singure, fără reguli `.live-projector` aici. Aceleași clase înainte ȘI după reveal
   (pastila cu fața în jos = `is-down` [+ `is-on` = a votat]); animația pornește când pastila primește
   clasa de stare — prin morph pe același nod sau prin inserare (frații lui `.sc` diferă între stări).
   Pattern-ul = `.jgrid` (components.css): grid pe container, rândurile `display: contents`. */
.sc-jg { background: var(--ui-flat); font-variant-numeric: tabular-nums; }
/* Antetul rezumatului e acum banda proprie `.sc-hd` (două jumătăți care se ating la mijloc) — vezi
   blocul ei mai sus. Regulile `.sc-jg__hd .*` de aici au fost ȘTERSE odată cu grila de 3 coloane
   din cap: scorul pe mijloc, liniuța dintre cifre, celula-coloană cu chip-uri, `.sc-jg__id`.
   Corpul: containerul de măsurare e WRAPPER-ul (bloc în flux, lățimea vine de la părinte — testul din
   ADR 0040) și tot el trage lateral când N coloane × podea nu mai încap („se strânge întâi, se trage
   lateral după"). `.sc { overflow: hidden }` e în AFARA lui, deci nu înghite nimic. */
/* Aer ÎNTRE capul cu numele și grila juraților (cerut 2026-08-27: „să fie aerisit de nume, mai
   distanțat, să se vadă că acolo apar scorurile"). Spațiul e pe RAIL, nu pe corp: corpul e containerul
   de scroll și gazda de `cqi`, iar un padding-top acolo ar intra sub masca `.rail-fade` și ar derula
   odată cu conținutul. Pe rail rămâne fix, deci despărțitura se vede și când grila e trasă lateral.
   Distanța e mai mare decât hairline-ul de sub cap tocmai ca să citească drept ZONĂ NOUĂ, nu ca rând
   următor al aceluiași tabel.
   ⚠️ Spațiul e în `rem × --scale-cap`, NU în `cqi`: pe lanțul `.sc → .sc-jg → .sc-jg__rail` nu există
   niciun element cu `container-type` (`.sc-hd` e FRATE, nu strămoș), deci `cqi` ar cădea tăcut pe
   viewport — capcana prinsă azi la cronometru. `--scale-cap` îl dublează pe proiector, unde trebuie. */
/* JURAȚII SUNT O BANDĂ PROPRIE, nu o continuare a căsuțelor concurenților (cerut 2026-08-28:
   „vreau să desprindem jurații din scoreboard, să nu mai fie legați de concurenți").
   Rețeta e cea deja folosită de `.sc-totals` și `.sc-av`: suprafață `--paper-2` + hairline sus.
   Așa scorecardul se citește ca un TEANC de benzi — verdict · jurați · puncte · public — fiecare cu
   propria suprafață, în loc de un bloc unic în care jurații par lipiți de numele de deasupra. */
/* Distanța dintre capul cu numele concurenților (`.sc-hd`) și zona de runde/criterii. Urcată
   2026-09-01 (.6→1rem, focus .9→1.4rem) la cererea ownerului: capul de coloană are acum două etaje
   (jurat + criteriu), deci blocul de dedesubt începe „mai sus" și cele două zone se citeau lipite.
   Se aplică în AMBELE moduri și pre-reveal — toate trei trec prin `.sc-jg`. */
.sc-jg__rail {
    /* Banda sta pe s1, nu pe suprafata cutiilor: pe s2 era identica cu cutiile nedecise, iar inainte
       de verdict capul si banda se vedeau ca „un bloc gri". B159 L10 (F2). */
    /* B195 L2: fără hairline sus — treapta tonală dintre cutiile concurenților (s2) și bandă (s1) face separarea
       (prototipul fluxului live; ADR 0057 §4). */
    background: var(--ui-flat);
    padding-top: calc(1rem * var(--scale-cap, 1));
}
.sc--focus .sc-jg__rail { padding-top: calc(1.4rem * var(--scale-cap, 1)); }
.sc-jg__body { container-type: inline-size; overflow-x: auto; padding: .35rem .5rem .45rem; }
.sc-jg__grid {
    /* `gap` urcat 3px→6px (cerut 2026-08-27: „nu așa lipite, mai aerisite"). E un singur `gap`, deci
       aerisește pe AMBELE axe: și între jurați, și între runde — exact ce trebuie când sunt multe
       runde una sub alta. Coloanele rămân `1fr` egale, deci simetria (și mijlocul) se păstrează. */
    display: grid; gap: 6px; align-items: stretch;
    /* Prima coloană = legenda de rând (R1, R2…), `auto` deci ia exact cât cere numărul. Restul rămân
       coloanele de jurați, egale. Urma coloanei de jurat stă ÎNTR-UN loc (`--sc-jg-col`) — o citește și varianta fără
       legendă de mai jos; `cqi` se rezolvă tot pe grila asta (proprietatea e declarată și consumată pe același element). */
    --sc-jg-col: minmax(clamp(2.6rem, 8cqi, calc(4rem * var(--scale-cap, 1))), 1fr);
    grid-template-columns: auto repeat(var(--sc-jn, 1), var(--sc-jg-col));
}
/* Fără legendă de rând (banda de sub ringul Smoke, `rowLegend: false`): fără prima coloană, doar jurații. */
.sc-jg__grid--bare { grid-template-columns: repeat(var(--sc-jn, 1), var(--sc-jg-col)); }
.sc-jg__row { display: contents; }
/* LEGENDA DE RÂND (R1, R2…; „#1" până la B195 L2) — contra-măsura pentru paradoxul de numărare, repusă 2026-08-28 la
   cererea userului: pastilele sunt VOTURI, antetul numără RUNDE, iar numărul ăsta ia culoarea
   câștigătorului RUNDEI. Așa se pot număra rundele în aceeași unitate ca antetul, fără să pară că
   „a câștigat cel cu mai puține pastile". Același vocabular de culoare ca pastilele (`is-winner` /
   `is-loser` / `is-tie`), ca să se citească drept aceeași informație, la altă scară.
   Mai mic decât o pastilă și fără ramă: e o ETICHETĂ de rând, nu un al (N+1)-lea vot. Neutru
   pre-reveal, când `pick` e null. */
.sc-jg__no {
    display: flex; align-items: center; justify-content: center;
    padding: 0 .4em; border-radius: var(--radius-sm);
    font-family: var(--font-mono); font-weight: 700; line-height: 1;
    font-size: clamp(var(--font-xs), 2.4cqi, calc(var(--font-base) * var(--scale-cap, 1)));
    color: var(--ui-ink-muted); font-variant-numeric: tabular-nums;
}
/* Votul pentru INVINS se topea in card: cifre cu cerneala tare + un inel `box-shadow` care ii da
   forma, fara geometrie noua. B159 L10 (F2). */
.sc-jg__no.is-winner { background: var(--ui-win); color: var(--ui-on-win); }
.sc-jg__no.is-loser  { background: var(--ui-lose); color: var(--ui-ink); box-shadow: inset 0 0 0 1px var(--ui-line); }
.sc-jg__no.is-tie    { background: var(--ui-warning-soft); color: var(--ui-on-warning-soft); }
/* RUNDA ÎN CURS (B195 L2): inelul de IDENTITATE pe eticheta ei + cifra violet (starea activă din bugetul violetului,
   cast-ui regula 2). Inel = `box-shadow` inset, deci nu mută nimic. Inelul (tonul de umplere) iese 2.8:1 pe banda
   dark — redundant cu cifra violet (7.23), deci WCAG 1.4.11 nu-l cere; tonul de umplere e decizia ownerului pentru
   liniile violet (G1b). Cât rulează battle-ul eticheta n-are verdict, deci nu se bate cu `is-winner/loser`. */
.sc-jg__row.is-current .sc-jg__no { box-shadow: inset 0 0 0 2px var(--ui-accent-fill); color: var(--ui-accent); }
/* Căsuțele care încă AȘTEAPTĂ pe rândurile ne-curente se retrag: ochiul rămâne pe runda care se votează. */
.sc-jg__row:not(.is-current) .sc-jg__pill.is-down:not(.is-on) { opacity: .45; }

/* Rândul juraților: coloane egale; celula e container, numele se măsoară în COLOANA LUI → cu 3
   jurați iese mare, cu 7 mic, fără nicio clasă de N. `anywhere` + podeaua coloanei merg împreună.

   NUMELE JURATULUI E ETICHETĂ, NU TITLU (corecție user 2026-08-27: „numele juraților sunt cam la fel
   de mari ca numele concurenților, e ciudat să vezi 5 nume scrise la fel"). Măsurat înainte: la ≥537px
   cu ≤5 jurați numele juratului ajungea la 20,8px iar al concurentului (2v2, bucket `l`, `--nm-k: .62`)
   la 19,84px — juratul era MAI MARE, la același font, aceeași greutate 900, același uppercase și
   ACEEAȘI culoare `--fg1`. Nu exista niciun canal de diferențiere.
   Coborârea refolosește vocabularul de text SECUNDAR din fișier: `--fg3` + greutate mai mică +
   treaptă mai jos. Nu inventăm un al doilea vocabular pentru același rol. Al treilea canal (mono)
   vine din lista de mono a vocabularului de scoreboard (`components.css`), lângă pastile — coloana
   juratului devine mono, numele concurenților rămân Archivo 900.
   La PANEL capul ăsta e și LEGENDA în unitatea antetului: primește `is-winner/is-loser/is-tie` din
   `judges[].pick` (presenter) și se numără ca să dea cifra din cap. Fundalul stă pe SPAN, nu pe
   celulă — celula e container de interogare (`container-type`) și gazdă de grilă, iar spanul are
   deja reguli proprii (`.sc-jg__judge > span`, mai jos); o declarație pe span bate moștenirea
   indiferent de layer (lecția B116/B105). */
/* Capul are DOUĂ RÂNDURI DE GRILĂ la panel (criterii, apoi nume), nu două etaje într-o celulă: rândul
   comun e ce ține toate criteriile la același nivel și toate numele la altul, oricâte linii ia fiecare.
   `justify-content: center` (axa rând) ține eticheta pe lățimea TEXTULUI — cu `stretch` s-ar întinde
   cât coloana și, fiind colorată, s-ar citi ca încă un dreptunghi de vot.
   Criteriile se aliniază la BAZĂ (ultima linie pe aceeași cotă), numele la VÂRF — așa granița dintre
   cele două rânduri e o linie dreaptă pe toată banda. */
.sc-jg__judge { container-type: inline-size; min-width: 0; display: flex; justify-content: center; text-align: center; letter-spacing: .04em; }
.sc-jg__judge--crit { align-items: flex-end; padding-bottom: 2px; }
.sc-jg__judge--jn { align-items: flex-start; }
.sc-jg__judge > span {
    /* B159 L10 (F2): scara urcata o treapta, cu ACEEASI forma (podea · cqi · plafon × --scale-cap),
       deci proiectorul ramane proportional. In panoul ingust `8cqi` cadea pe podeaua de 8.8px si se
       vedea ca atare. Numele juratilor = cerneala tare, nu gri: sunt informatie, nu decor. */
    font-weight: 700; line-height: 1.1; color: var(--ui-ink); overflow-wrap: anywhere;
    letter-spacing: .04em;
    font-size: clamp(var(--font-xs), 10cqi, calc(var(--font-base) * var(--scale-cap, 1)));
    max-width: 100%;
}
/* Numele juratului (DOAR la panel) — etajul de DEDESUBT, NEUTRU: verdictul e al criteriului, nu al
   persoanei; colorat, s-ar citi „a câștigat juratul". Ordinea criteriu-sus / jurat-jos e cerută
   explicit (2026-09-01): criteriul e informația, persoana e atribuirea.

   ⚠️⚠️ ȚINTA E `.sc-jg__judge--jn > span` (0,2,1), NU `.sc-jg__jn` (0,1,0). Regula de deasupra,
   `.sc-jg__judge > span`, are (0,1,1) și o bate — deci mărimea ȘI greutatea scrise pe clasa simplă
   NU s-au aplicat niciodată, iar numele s-a randat identic cu criteriul. Diagnosticat greșit de două
   ori („600 se rotunjește la 700 în Space Mono") înainte de a citi specificitatea: fontul chiar are
   400 și 700, dar declarația nu ajungea la el. Dacă adaugi aici o proprietate nouă, verifică întâi
   cine câștigă — regula-frate de deasupra pune și `font-family`, și `color`, și `line-height`.

   Singurul canal de diferențiere rămas e GREUTATEA (400 vs 700 — real în Space Mono: măsurat pe
   canvas, 700 are 1.53x cerneala lui 400). Celelalte două au fost încercate și scoase de owner pe
   2026-09-01, în ordinea asta:
     · MĂRIMEA — numele micșorat „se citește greu"; a revenit pe scara criteriului (13px/13px);
     · SCRIEREA — `text-transform: none` scos la cerere („revin la litere uppercase și la nume, că se
       vede mai bine"), deci numele ia din nou uppercase-ul kf de pe CELULĂ, prin moștenire.
   Contra-argumentul rămâne la vedere: majusculele pe nume de oameni costă 10-20% viteză de citire
   (`docs/FEEDBACK-2026-08-18`) — owner-ul a ales lizibilitatea la distanță, cu risc asumat și declarat
   temporar („o mai lăsăm așa o perioadă"). Dacă se revine la scriere normală, `text-transform` se
   anulează AICI, pe span: uppercase-ul stă pe CELULĂ (`.sc-jg__judge`, în `components.css`), iar o
   declarație proprie bate moștenirea indiferent de layer (același mecanism ca `font-family`). */
.sc-jg__judge--jn > span { font-weight: 500; color: var(--ui-ink-muted); }
/* AVATARUL din capul grilei (B195 L5, prototipul): DEASUPRA numelui juratului — în coloană, ca să nu ia din lățimea
   unei coloane înguste. Rândul de sus (runde) se aliniază JOS, spre căsuțe; rândul numelor (panel) SUS, sub criteriu.
   Stă DUPĂ `--crit` / `--jn` fiindcă le suprascrie `align-items` la aceeași specificitate.
   Mărimea din lățimea CELULEI (`.sc-jg__judge` e container → `cqi` în copil); pe sală crește cu `--scale-cap`.
   ⚠️ `.sc-jg__judge > .avatar` (0,2,0), NU `.avatar`: regula-frate `.sc-jg__judge > span` (0,1,1) — și lista de
   mono din components.css — i-ar fi dat fontul, mărimea și cerneala numelui. */
.sc-jg__judge--av { flex-direction: column; align-items: center; justify-content: flex-end; gap: .25rem; }
.sc-jg__judge--av.sc-jg__judge--jn { justify-content: flex-start; }
.sc-jg__judge > .avatar {
    --av-size: clamp(1.35rem, 28cqi, calc(2.1rem * var(--scale-cap, 1)));
    font-family: var(--font-display); font-weight: 800; line-height: 1; letter-spacing: .02em;
    font-size: calc(var(--av-size) * .38); color: var(--ui-on-color, #fff); max-width: none;
}
/* Criteriul (panel) — eticheta care poartă verdictul coloanei. Îmbracă TEXTUL, nu lățimea coloanei, și
   NU se lipește de primul dreptunghi: ambele au fost încercate pe 2026-09-01 și respinse de owner —
   „nu merge să fie lipit (…) și nici lat cât dreptunghiul, ca să nu se înțeleagă greșit că e un
   dreptunghi". Rămâne o etichetă, cu greutatea (700) ca al doilea canal față de numele juratului. */
.sc-jg__lbl--crit { padding: .28rem .55rem; border-radius: var(--radius-sm); font-weight: 700; }
/* Legenda pe COLOANĂ — ACEIAȘI tokeni ca legenda pe rând (`.sc-jg__no`) și ca pastilele, ca să nu
   apară un al treilea verde. */
.sc-jg__lbl.is-winner { background: var(--ui-win); color: var(--ui-on-win); }
.sc-jg__lbl.is-loser  { background: var(--ui-lose); color: var(--ui-ink); box-shadow: inset 0 0 0 1px var(--ui-line); }
.sc-jg__lbl.is-tie    { background: var(--ui-warning-soft); color: var(--ui-on-warning-soft); }
/* Pastila = blocul care umple celula. Ramă de 2px în TOATE stările (nimic nu se mișcă la întoarcere).
   Colțuri drepte (`--radius-sm`), ca restul scoreboard-ului — „pastilă" e doar numele din discuție.
   Fontul („egal") vine din lista de mono a vocabularului de scoreboard (`components.css`) — cât timp
   regula lui stătea în `@layer components`, una de font aici ar fi fost moartă (UI_RULES „livrare inertă"). */
.sc-jg__pill {
    /* Conținutul rămâne CENTRAT pe ambele axe („păstrează mijlocul") — se schimbă doar cât de înaltă
       e cutia. Coborâtă 2026-08-27 („chenarele mai mici, să le scadă importanța"): pastilele sunt
       DETALIUL care susține verdictul din cap, nu verdictul. `stretch` pe grilă rămâne, ca rândul cu
       „egal" (singurul cu text) să nu iasă din rând cu vecinii lui. */
    display: flex; align-items: center; justify-content: center; min-width: 0;
    min-height: clamp(.8rem, 2.8cqi, calc(1.25rem * var(--scale-cap, 1)));
    border: 2px solid var(--ui-hair); border-radius: var(--radius-sm); background: transparent;
    /* B159 L10 (F2): scara urcata o treapta, cu ACEEASI forma (podea · cqi · plafon × --scale-cap) —
       pastilele ajunsesera „extrem de marunte" in panoul ingust. */
    font-weight: 700; text-transform: var(--type-status-case, uppercase); letter-spacing: var(--type-status-tracking, .03em);
    font-size: clamp(var(--font-xs), 2.8cqi, calc(var(--font-base) * var(--scale-cap, 1)));
}
/* Cu fața în jos, votat = CERNEALĂ, nu culoarea verdictului (verdele înseamnă „cu câștigătorul"), cu `✓` în culoarea
   benzii (B195 L2) — perechea text-hi / s1, inversată. */
.sc-jg__pill.is-down.is-on { background: var(--ui-ink); border-color: var(--ui-ink); color: var(--ui-flat); }
/* …iar juratul care INCA n-a votat = contur vizibil (era `--border-hair`, 1.34:1 — randul „disparea") + `·`.
   B195 L2 (prototipul): contur PLIN, nu punctat — punctul din mijloc spune „așteaptă", iar învinsul e UMPLUT, deci
   nu se confundă. */
.sc-jg__pill.is-down:not(.is-on) { border-color: var(--ui-line); color: var(--ui-ink-muted); }
/* ── DUBLU CANAL: câștigătorul UMPLUT, învinsul CONTUR GOL (decizia userului, 2026-08-27) ──
   Raportul: „la tema light se observă destul de greu diferențele de culoare de la alb la verdele
   câștigător sau griul pierzător; încep să văd de ce aleg ăștia roșu și albastru".
   Măsurat, cauza e mai rea decât suna — era INVERS: umplerea de câștigător (`--winner-bg` `#eef7c6`)
   dădea 1,02:1 față de `--card`, iar cea de învins (`--fg4`) 4,06:1. **Pastila de învins era de 4×
   mai vizibilă decât cea de câștigător.** Ce se vedea la câștigător era rama, nu umplerea.
   Reparația nu adaugă un efect, inversează greșeala, și pe DOUĂ canale — culoare ȘI greutate
   vizuală (bloc plin vs. contur gol), ca să se citească și când proiectorul strică hue-ul
   (WCAG 1.4.1; UI_RULES § contrast pct. 8 „accentul e UMPLERE, nu linie").
   Perechea de tokene e semantică, nu aleasă pe ochi: `--winner-edge` E `--primary` sub kf, deci
   cerneala lui e `--on-primary` — se inversează singură pe temă (6,5:1 light / 11:1 dark), iar
   umplerea dă 5,86:1 light / 9,59:1 dark față de card. Cifrele intră în `scripts/contrast-audit.php`
   (§ PAIRS), altfel regresia se repetă tăcut — perechea „fundal câștigător ↔ fundal card" lipsea. */
.sc-jg__pill.is-winner { background: var(--ui-win); border-color: var(--ui-win-mark); color: var(--ui-on-win); }
/* Învins = UMPLUT cu `--loser-fill`, exact ca jumătatea lui din cap (userul, 2026-08-27: „înțeleg
   că e empty, dar ar fi trebuit să aibă aceeași culoare și pastilele juriului").
   Varianta de dinainte (contur gol) despărțea mai tare câștigătorul de învins, dar rupea legătura
   dintre pastilă și concurentul ei — iar aia e informația: pastila spune CU CINE a votat juratul.
   Un semnal consecvent bate un contrast local. Al doilea canal rămâne: câștigătorul e accent, nu gri.
   Pastila FĂRĂ vot a unui battle finalizat rămâne transparentă cu `--border-hair` (1,43:1) — o cutie
   goală lângă una umplută, deci tot nu se confundă cu învinsul. */
.sc-jg__pill.is-loser { background: var(--ui-lose); border-color: var(--ui-line); color: var(--ui-ink); }
.sc-jg__pill.is-tie { background: var(--ui-warning-soft); border-color: var(--ui-on-warning-soft); color: var(--ui-on-warning-soft); }
.sc-jg__empty { padding: .55rem .65rem; font-size: var(--font-sm); color: var(--ui-ink-muted); }
/* ⛔ ȘTERSĂ la B159 L10 (F2): întoarcerea pastilei la reveal (`@keyframes sc-jg-flip`, cadență în
   TREPTE, 2026-08-27). Pastilele se re-randează la FIECARE poll, iar o animație care se reia e
   zgomot — skinul o oprise cu `animation: none`, iar la coborârea lui a căzut declarația însăși.
   Odată cu ea au căzut și keyframe-urile (nimeni nu le mai numește) și garda `prefers-reduced-motion`
   care o oprea: o gardă fără subiect nu mai e gardă. */
/* Panoul mare (battle-ul curent / sala) */
.sc--focus .sc-jg__body { padding: .5rem .75rem .6rem; }
.sc--focus .sc-jg__grid { gap: 8px; }
/* ⛔ ȘTEARSĂ la B159 L10 (F2): `.sc--focus .sc-jg__judge > span { font-size: 9cqi }`. De când
   skinul a urcat scara generică la 10cqi, regula asta pierdea (layerul bate specificitatea), deci
   panoul mare se randa DEJA la 10cqi. Coborârea skinului îi lua prefixul `body.skin-modern`, iar
   `.sc--focus …` (0,2,1) ar fi CÂȘTIGAT înapoi la specificitate — adică o schimbare de geometrie
   cu toate gate-urile verzi. Ștearsă ca să rămână ce se vede azi. */
/* Numele juratului NU are mărime proprie, nici aici, nici la mărimea de bază: rămâne pe scara lui
   `.sc-jg__judge > span`, aceeași cu a criteriului. Micșorat, devine greu de citit (raportat
   2026-09-01: „marimea e prea mica, se citeste greu"). Diferențierea față de criteriu se face pe
   GREUTATE (400 vs 700) și SCRIERE (normală vs majuscule) — nu pe mărime. */
/* Pe panoul mare culoarea trebuie să se vadă din sală, deci eticheta primește mai mult aer. */
.sc--focus .sc-jg__lbl--crit { padding: .38rem .75rem; }
.sc--focus .sc-jg__pill { min-height: clamp(1rem, 3.4cqi, calc(1.55rem * var(--scale-cap, 1))); }

/* ═══ Scara de SALĂ (B114, ADR 0041 am.1) — pe perete tavanul dispare ═══
   Raportul userului după B112: „bracketul Top 8 rămâne la o mărime intermediară", „div-urile cresc,
   fonturile nu", „A+ ajută puțin". Cauza, una: toate scările din container au tavan fix în rem/px
   (regula 2o „maximele = valorile de dinainte"), iar `zoom` e INVARIANT pe `cqi` (micșorează și
   containerul). Aici stă UN SINGUR loc de remap, în două părți:
     1. `--scale-cap` — tavanul fiecărui clamp() din fișier e `calc(<azi> * var(--scale-cap, 1))`;
        pe sală = 100 ⇒ practic fără tavan, podelele neatinse. Pe public/organizator rămâne 1.
     2. mărimile care NU erau în cqi (scorul mare, „VS", totalurile, bara):
        `max(<azi>, N cqi)` DOAR aici — podeaua e valoarea de azi, creșterea o dă containerul.
        `cqi` se rezolvă pe cel mai apropiat container: `.sc-hd` (capul de
        rezumat), `.sc-jg__body` (grila de pastile), `.sc-round` (o rundă din detaliu — bandă,
        rânduri ȘI subsol, din B135; înainte era `.sc-jt`, deci banda de rundă măsura `.bk-layout`),
        altfel `.bk-layout` (rândul). Coeficienții se CALIBREAZĂ vizual cu userul.
   Specificitate: `.live-projector .sc--focus .x` (0,3,0) bate `.bk-layout__current .sc--focus .x`
   de mai sus la egalitate, fiindcă vine după. */
/* ⚠️ Prima livrare (100 = „fără tavan", iar mărimile de mai jos cu `max()` = fără NICIUN plafon) a
   fost „dezastruoasă" pe ecran (userul, 2026-08-26): pe un panou de 1900px numele ieșeau la 160px,
   scorul la 190px — nimic nu mai încăpea pe ÎNĂLȚIME. Lățimea nu e constrângerea unui ecran 16:9,
   înălțimea e. Soluția „între": UN SINGUR buton, `--scale-cap` = 2 (tavanul = dublul valorii de
   azi), iar mărimile de mai jos au și ele tavanul `azi × --scale-cap`, prin `clamp()`. Reglajul
   global = cifra de pe linia următoare; reglajul unui element = coeficientul lui `cqi`. */
.live-projector { --scale-cap: 2; }
.live-projector .sc--focus .sc__meta { font-size: clamp(var(--font-sm), 1.4cqi, calc(var(--font-sm) * var(--scale-cap, 1))); }
.live-projector .sc--focus .sc-jt__skv { font-size: clamp(var(--font-md), 1.7cqi, calc(var(--font-md) * var(--scale-cap, 1))); }
.live-projector .sc--focus .sc-jt__arrow,
.live-projector .sc--focus .sc-jt__net,
.live-projector .sc--focus .sc-round__pts { font-size: clamp(var(--font-lg), 2cqi, calc(var(--font-lg) * var(--scale-cap, 1))); }
.live-projector .sc--focus .sc-round__hd { font-size: clamp(var(--font-sm), 1.8cqi, calc(var(--font-sm) * var(--scale-cap, 1))); }
.live-projector .sc--focus .sc-totals__v { font-size: clamp(var(--font-5xl), 5cqi, calc(var(--font-5xl) * var(--scale-cap, 1))); }
.live-projector .sc--focus .sc-totals__max { font-size: clamp(var(--font-md), 1.8cqi, calc(var(--font-md) * var(--scale-cap, 1))); }
.live-projector .sc--focus .sc-totals__lbl { font-size: clamp(var(--font-sm), 1.6cqi, calc(var(--font-sm) * var(--scale-cap, 1))); }

/* Progresul de dinainte de reveal (fostul `.sc-prog`, căsuțe pe rundă) trăiește acum în grila
   jurat × rundă (`.sc-jg`, pastile `is-down`) — vezi secțiunea B115 de mai sus. */

/* Carduri battle terminate = expandabile + acordeon scorecards */
.bk-battle--expandable { cursor: pointer; }
/* ── „La ce battle mă uit în scoreboard?" (iter. 2o, cererea userului) ──
   Marcajul NU are nevoie nici de JS, nici de o clasă nouă din server: cardul din bracket ESTE
   declanșatorul de collapse al panoului, deci `aria-expanded="true"` e prin construcție exact
   battle-ul afișat — și la randarea de server (`curId` din `currentScorecard`), și după ce omul
   deschide alt scorecard (Bootstrap comută atributul), și după morph (scorecard-slot.js îl
   resincronizează). Un flag paralel s-ar fi putut desincroniza; ăsta nu poate.
   CONTUR, nu umplere: `.bk-battle--active` (IN_PROGRESS) folosește deja umplerea volt, iar cele
   două stări se suprapun de obicei — UN NIVEL = UN MECANISM (UI_RULES).
   ⚠️ `z-index` nu e cosmetic: `outline` pictează ÎN AFARA cutiei, iar cardurile următoare din DOM
   (z-index: 2) l-ar tăia — capcana de ordine de pictare deja plătită pe scara juratului. */
.bk-battle--expandable[aria-expanded="true"] {
    outline: 2px solid var(--ui-ink);
    outline-offset: 2px;
    z-index: 3;
}
/* ⛔ ȘTERS la B195: chevronul „apasă pt scorecard" (`.bk-battle__more`), din colțul de sus-interior. Acolo stă
   acum căsuța de scor, iar prototipul fluxului live (confirmat de owner) nu-l are: nodul terminat își arată
   rezultatul prin căsuțe, cursorul și ridicarea la hover spun că se deschide, iar conturul de mai sus arată
   care scorecard e deschis. */

/* Slot principal scorecard (în panoul din dreapta): un singur scorecard vizibil odată — battle-ul
   curent implicit, sau cel pe care s-a dat click în bracket. Restul rămân collapse (ascunse). */
.bk-sc-slot { display: flex; flex-direction: column; }
.bk-sc-slot__item .sc { margin-bottom: 0; }

/* Finala = accent (centrul convergenței) */
/* ⛔ ȘTEARSĂ la B159 L10 (F2): `.bk-col--final .bk-battle { box-shadow: var(--shadow-hard-sm) }`.
   Era (0,2,0) și bătea `.bk-battle`, dar skinul o acoperea prin LAYER, deci cardul finalei avea de
   mult umbra de card ca toate celelalte. La coborârea skinului s-ar fi trezit — și `--shadow-hard-sm`
   nici nu mai există în paleta de azi, deci ar fi ieșit `none`. Prinsă de sondă pe proiector. */
/* ⚠️ `:not(--active)` NU e cosmetic — fără el eticheta finalei devenea ILIZIBILĂ pe dark (raportat
   2026-08-21, în timpul unei finale reale). Mecanica: selectorul ăsta are specificitate (0,2,0) și
   bate `.bk-col-label--active` (0,1,0), dar suprascrie DOAR `color` — fundalul plin `--volt` rămâne
   de la starea activă. Rezultă o pereche pe care n-a proiectat-o nimeni: text `--primary-strong` pe
   fundal `--volt`. În light+kf e olive #506600 pe lime #ccff00 (~5.9:1, se citește); în dark+kf
   `--kf-primary-solid` urcă la lime-dim #abd600 → LIME PE LIME, ~1.3:1, invizibil.
   Regula generală de reținut: o decorație de COMPONENTĂ nu are voie să bată o STARE care aduce
   fundal propriu — starea vine cu perechea ei fundal+text, decorația rupe doar jumătate din ea.
   Accentul finalei rămâne exact cum era pe coloana inactivă și pe cea terminată. */
.bk-col--final .bk-col-label:not(.bk-col-label--active) { color: var(--ui-ink); border-bottom-color: var(--ui-ink); }



/* === 10c. CATEGORY SHOW ==================================== */

.cat-panel-hdr {
    display: flex; align-items: center; justify-content: space-between;
    padding: .32rem .65rem;
    background: var(--ui-subtle);
    border-top: 2px solid var(--ui-line);
    border-bottom: 1px solid var(--ui-hair);
    font-family: var(--font-display);
    font-size: var(--font-xs); font-weight: var(--type-label-weight, 900); text-transform: var(--type-label-case, uppercase);
    color: var(--ui-ink); margin-bottom: .35rem;
}
/* `.cat-panel-hdr--active/--done/--info` ȘTERSE la B194: `components.css` le anula (aceeași specificitate,
   încărcat după) — pe ecran n-au existat niciodată de la G1, iar `--info` nu mai avea niciun template. */

.config-pill {
    display: inline-flex; align-items: center; gap: 4px;
    background: var(--ui-flat); border: 1px solid var(--ui-hair); border-radius: var(--radius-sm);
    padding: .15rem .5rem; font-size: var(--font-xs); color: var(--ui-ink-muted);
}
.config-pill__val { font-family: var(--font-mono); font-weight: 700; color: var(--ui-ink); }

/* Tabs categorie (Calificare | Bracket/Smoke). Familia/mărimea/tracking-ul vin din rolul de
   ETICHETĂ (components.css § 18b); aici rămân doar spațierea și culoarea.
   `background` + `border-color` pe `.active` au fost șterse: skinul kf le rescrie oricum (tab plat cu
   underline), deci erau declarații moarte care doar făceau diagnosticul mai greu. */
/* B218 (ADR 0059): comutatorul de VEDERE = DOUĂ JUMĂTĂȚI pe toată lățimea, direct sub pastilele de categorii
   (prototipul v3 aprobat; ADR 0054 §5: „categoria = umplere, vederea = subliniere"). `flex: 1 1 0` pe item, nu pe
   link: Bootstrap face `.nav` flex, dar item-urile stau la lățimea conținutului. `nowrap`: două jumătăți care s-ar
   înfășura n-ar mai fi un comutator. ⚠️ ȚINTĂ DE TAP: 44px explicit — tabul avea 33px (auditul B218). */
.cat-tabs { flex-wrap: nowrap; }
.cat-tabs .nav-item { flex: 1 1 0; min-width: 0; }
.cat-tabs .nav-link {
    display: inline-flex; width: 100%; min-height: var(--tap-min);
    align-items: center; justify-content: center;
    padding: .3rem .75rem; color: var(--ui-ink-muted);
}
/* Sublinierea = semn GRAFIC de stare activă → tonul de UMPLERE, ca șina și tabul de categorie activ (tonul de
   TEXT e mai deschis pe dark și se vedea ca altă nuanță — raport owner, G1b). 5.46 light / 3.10 dark pe pagină. */
.cat-tabs .nav-link.active { color: var(--ui-ink); border-bottom-color: var(--ui-accent-fill); }

/* Linia taburilor = taburi + acțiunile de categorie (iter. 2k): taburile la stânga, butoanele la
   dreapta, pică pe rând nou PROGRESIV (flex-wrap + gap fluid — regula aranjamentului fluid). */
.cat-tabs-row { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: .35rem clamp(.5rem, 2vw, 1rem); margin-block: 0 .6rem; }
/* `flex: 1 1 0` + o lățime minimă de citire, NU `width: 100%`: cu 100% baza de flex umple rândul și acțiunile ownerului
   ar cădea sub taburi la ORICE lățime (B4 din stres-testul planului B218). Așa, pe lat taburile iau restul rândului și
   acțiunile stau la dreapta; pe îngust (sub 16rem disponibili) acțiunile cad singure sub ele. */
.cat-tabs-row .cat-tabs { flex: 1 1 0; min-width: min(100%, 16rem); }
/* Gap MARE între grupuri (iter. 2n): `flex-wrap` umple lacom și rupe unde apucă, deci wrapul trebuie
   să cadă ÎNTRE grupuri, nu prin mijlocul unuia (UI_RULES „Wrapul se face între grupuri"). */
.tab-actions { display: flex; flex-wrap: wrap; align-items: center; gap: .3rem clamp(.5rem, 2.5vw, 1rem); }
/* …și gap MIC în grup: butoanele care se folosesc împreună stau lipite și se citesc ca un cluster.
   `wrap`, nu `nowrap`: asimetria de gap e destulă ca ruptura să cadă între grupuri la orice lățime
   realistă, iar la 320px cu o etichetă lungă de fază preferăm o rupere în grup decât o pagină care
   se trage lateral (containerele n-au voie să înghită depășirea). */
.tab-actions__grp { display: flex; flex-wrap: wrap; align-items: center; gap: .2rem; }
/* Butoanele de pe linie stau O TREAPTĂ sub btn-xs (cererea userului: pe mobil ocupau prea mult
   când picau pe rânduri) — doar aici, restul btn-xs din produs rămâne cum e. */
.tab-actions .btn-xs { font-size: var(--font-2xs); padding: .12rem .38rem; }
/* Subiectul grupului ACUM: pe CE battle apasă butoanele. Doar faza — starea (LIVE/urmează) stă pe
   banda scorecardului, unde e adevărată. Accentul e UMPLERE, nu linie (memoria accent-token-fill). */
.tab-now {
    display: inline-flex; align-items: center; gap: .25rem;
    padding: .1rem .4rem; border-radius: var(--radius-sm);
    background: var(--ui-quiet);
    font-weight: 900;
    font-size: var(--font-2xs); text-transform: uppercase; letter-spacing: .06em;
    white-space: nowrap;
}


/* ── Tabul Calificare: containerul de măsurare (iter. 2o, ADR 0040) ──
   TOT ce e pe tab se dimensionează din LĂȚIMEA TABULUI, nu din ecran. Regulile de aici au fost
   scrise cândva pentru un `@media`, dar secțiunea trăia într-un `.col-md-6`: de la 768px în sus
   înghesuia 4 carduri în JUMĂTATE de ecran, adică exact anti-pattern-ul de care `.qual-2col`
   fusese deja scăpat (vezi comentariul ei mai jos). */
.qual-tab { container-type: inline-size; }
.qual-groups { min-width: 0; }

/* Grid de grupe calificare — se RĂREȘTE CÂTE UNA pe măsură ce se îngustează (cerința userului),
   până la 2 pe rând, fără niciun prag: `auto-fit` + `minmax` fac exact asta, singure.
   --bgc-min = podeaua unui card; la 360px lățime utilă intră FIX două, iar de acolo în sus grila
   adaugă câte o coloană când chiar încape încă una. `min(100%, …)` ține grila validă și când
   containerul e mai îngust decât podeaua (o singură coloană, nu overflow). */
.bouts-groups-grid {
    /* Podeaua CREȘTE cu tabul: pe un proiector lat cardurile trebuie să fie MARI (se citesc din
       fundul sălii), nu multe și mici. Cu o podea fixă, 16 grupe ar fi umplut 1500px cu 9 coloane
       de 160px. Așa, de pe la ~700px în sus grila se așază pe 4 coloane care cresc cu ecranul, iar
       în jos cade 4 → 3 → 2, câte una. */
    --bgc-min: clamp(9.5rem, 22cqi, 22rem);
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(min(100%, var(--bgc-min)), 1fr));
    /* Rândurile au AER deasupra (row-gap + padding-top): acolo stă eticheta LIVE / URMEAZĂ, călare pe muchia
       de sus a cardului (`.state-tag`), ca la nodul din bracket. */
    gap: 1.15rem clamp(3px, .5cqi, 7px);
    margin-top: .35rem; padding-top: .55rem;
}

/* Card grupă (B192 G2, prototipul v5 aprobat de owner 2026-09-30) — limbajul nodului de bracket: SUPRAFAȚĂ +
   UMBRĂ, fără ramă și fără banda colorată în cap (ADR 0057 §4). Starea: LIVE = tenta live + muchia roșie sus +
   eticheta + progresul ca bară de 3px JOS (`--fill`, voturi date / necesare, din builder — B163); URMEAZĂ =
   muchia violet; departajarea = muchia chihlimbarie (în curs: + tenta și eticheta de live, EXACT ca nodul
   `.bk-battle--golden` — decizia ownerului). ⚠️ FĂRĂ `overflow: hidden`: eticheta iese peste muchie.
   CARDUL e containerul de măsurare pentru tot ce scrie în el (iter. 2o): tipografia lui nu are
   voie să depindă de ecran, fiindcă același card are 152px pe telefon și ~370px pe proiector.
   ⚠️ `cqi` NU se rezolvă pe elementul care DECLARĂ containerul — de aceea mărimile fluide stau pe
   COPII (.bgc__hdr / .bgc__row), nu aici. `font-size` de mai jos rămâne baza moștenită. */
.bgc {
    position: relative;
    container-type: inline-size;
    border-radius: var(--radius-card, 0);
    /* B234 (Arena): grupa = card plat cu inelul fin al skinului, cu aer înăuntru. */
    background: var(--ui-flat);
    box-shadow: var(--ui-shadow-raised);
    padding: .75rem .85rem;
    font-size: var(--font-base);
    /* Mărimea ETICHETELOR cardului (antetul + `.state-tag`): urmează lățimea cardului ca numele (`cqi`, rezolvat
       în COPII — pe elementul-container `cqi` nu se rezolvă), cu plafonul de sală (`--scale-cap`: 1 pe pagină,
       2 pe proiector). Treapta rămâne sub nume (4.5cqi față de 7.5cqi). v4 al prototipului o fixase la
       `--font-2xs` — pe telefon identic, pe proiector ~2.5× mai mică decât înainte (ownerul: „pe telefon se vede,
       dar când e mare, nu știu"). Rolul de etichetă îl poartă familia, majusculele, rărirea și griul, nu micimea. */
    --bgc-label-fs: clamp(var(--font-2xs), 4.5cqi, calc(var(--font-xs) * var(--scale-cap, 1)));
    --state-tag-fs: var(--bgc-label-fs);
}
.bgc--active {
    background-color: var(--ui-live-tint);
    background-image: linear-gradient(var(--ui-live-mark), var(--ui-live-mark));
    background-repeat: no-repeat; background-position: left bottom; background-size: var(--fill, 0%) 3px;
    box-shadow: inset 0 3px 0 var(--ui-live-mark);
}
.bgc--next { box-shadow: inset 0 3px 0 var(--ui-accent-fill), var(--ui-shadow-raised); }
/* Departajarea (B24) — DUPĂ `--active`: pe grupa ⚖ în curs muchia e chihlimbarie, iar tenta, bara și eticheta
   rămân de live — exact ca nodul `.bk-battle--golden`. Pe cea încheiată rămâne doar muchia. */
.bgc--golden { box-shadow: inset 0 3px 0 var(--ui-warning), var(--ui-shadow-raised); }

/* Antetul grupei = ETICHETĂ (Material „overline"), nu titlu: mono (din `components.css`), majuscule rărite, gri —
   ca să nu se confunde cu numele concurenților (ownerul: „headerele, neavând background, nu se pot confunda cu
   numele?"). Fără bandă și fără fir. */
.bgc__hdr {
    display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 4px;
    font-size: var(--bgc-label-fs); font-weight: 800;
    text-transform: var(--type-label-case, uppercase); letter-spacing: .09em;
    padding: .6rem clamp(.15rem, 1.6cqi, .5rem) .3rem;
    color: var(--ui-ink);
}
/* B234 (Arena): „GRUPA 1" = titlu condensat; starea = verdictul, pe cerneala de câștig, pe un rând. */
.bgc__ord { white-space: nowrap; font-weight: 900; font-stretch: var(--ar-wdth); text-transform: uppercase; font-size: var(--font-xl); }
.bgc__state { display: inline-flex; align-items: center; gap: 3px; font-weight: 700; color: var(--ui-win-ink); white-space: nowrap; }
/* Punctele de RUNDĂ din antetul grupei (B163) — atâtea câte runde are boutul, pline cât s-au încheiat.
   Apar DOAR la mai multe runde (Twig decide); la o rundă n-ar spune nimic. Sunt decor: starea în cuvinte
   stă în `title`-ul cardului, de aceea markupul e `aria-hidden`. Mărimea urmează containerul (`cqi`), ca
   restul antetului, deci nu adaugă un rând nou nici pe proiector. ⚠️ „Rundă" aici = rundă PLANIFICATĂ a
   boutului (`roundsPlanned`), NU runda de departajare (`.bgc--golden`, tie-break). */
.bgc__rounds { display: inline-flex; align-items: center; gap: clamp(2px, .8cqi, 4px); flex: 0 0 auto; }
.bgc__rd {
    width: clamp(5px, 1.8cqi, 9px); aspect-ratio: 1; border-radius: 50%;
    border: 1px solid var(--ui-line); opacity: .55;
color: var(--ui-ink-muted); }
.bgc__rd--done { background: currentColor; opacity: 1; color: var(--ui-ink); }

.bgc__live-dot {
    width: clamp(5px, 2cqi, 10px); height: clamp(5px, 2cqi, 10px); border-radius: 50%;
    /* Culoarea punctului LIVE (`--sm-live-mark`) a coborât în regula asta la B159 L10: umplerea e
       scrisă mai jos, în aceeași regulă, nu moștenită de undeva. */
    display: inline-block;
    border: 1px solid var(--ui-live-mark);
    animation: bgc-pulse 1.2s ease-in-out 3;
background: var(--ui-live-mark); }
@keyframes bgc-pulse { 0%,100% { opacity: 1; transform: scale(1); } 50% { opacity: .35; transform: scale(.7); } }

/* Numele concurenților = ce se citește de la distanță, deci ele iau treapta cea mai mare din card.
   Padding-ul scade odată cu fontul: pe telefon aerul costă rânduri, pe proiector nu deranjează.
   Între rânduri: o linie de 1px în culoarea PAGINII (despărțire prin fundal, nu fir de contur — ADR 0057 §4). */
.bgc__row {
    display: flex; align-items: center; gap: clamp(3px, 1cqi, 7px);
    font-size: clamp(var(--font-2xs), 7.5cqi, var(--font-2xl));
    padding: .3rem clamp(.15rem, 1.6cqi, .5rem);
    min-width: 0;
    /* B234 (Arena): firul fin între concurenți, și sub antet. */
    border-top: 1px solid var(--ui-hair);
}

.bgc__dot {
    width: clamp(5px, 2cqi, 10px); height: clamp(5px, 2cqi, 10px); border-radius: 50%;
    flex-shrink: 0;
    background: var(--ui-hair);
}
.bgc__dot--done   { background: var(--ui-win-mark); }
/* Celelalte doua puncte de stare, coborate din `@layer skin` la B159 L10 (F2). */
.bgc__dot--pending { background: var(--ui-line); }
.bgc__dot--active  { background: var(--ui-live-mark); }

.bgc__name {
    flex: 1; min-width: 0;
    overflow: hidden; white-space: nowrap; text-overflow: ellipsis;
    color: var(--ui-ink); font-weight: 600;
    line-height: 1.3;
}
.bgc__crew { color: var(--ui-ink-muted); font-weight: 400; }

/* Listă calificați — 2 coloane jumate/jumate (stivuite pe mobil) + iconiță metodă */
/* Despicarea în două coloane e dictată de CONTAINER, nu de ecran. Avea `@media (min-width: 768px)`,
   dar panoul stă într-un `.col-md-6`, deci exact de la 768px în sus are jumătate din lățimea pe care
   o măsura media query-ul: două tabele de 4 coloane într-o jumătate de ecran → rândurile ieșeau
   afară (raportat: „pe ecran mic se adaptează, pe intermediare iese"). `auto-fit` + `minmax` rupe
   coloana a doua abia când chiar încape, progresiv, fără prag.
   `min(100%, …)` în minmax = supapa obligatorie: fără ea, sub 20rem pista rămâne mai lată decât
   containerul și overflow-ul revine, doar mai jos.
   `min-width: 0` pe copii fiindcă itemii de grid au implicit `min-width: auto` — adică nu pot coborî
   sub min-content-ul tabelului, deci pistele `1fr` nu se strâng deloc. */
/* Accentul cerut (2026-08-21): lista calificaților e ce așteaptă sala, deci BLOCUL se vede ca unitate.
   ⚠️ Accentul e pe TOȚI calificații deopotrivă — locurile 1/2/3 NU se medaliază aici (decizia
   userului): calificarea nu e podium, iar locul 1 e adesea doar invitatul cu seed direct. */
/* Din iter. 2o rezultatul stă DEASUPRA grupelor, în DOUĂ BLOCURI SUPRAPUSE, fiecare pe toată
   lățimea: calificații întâi, necalificații pe rândul următor. Fiecare listă e despicată în două
   coloane (`.qual-2col`) ca să nu se întindă ca un rând lung și subțire pe un ecran lat.
   Simetria e intenționată — același antet, aceleași patru coloane — fiindcă asta se compară: cine a
   trecut linia și cine nu. Ce le DEOSEBEȘTE e o singură lucru, tenta (vezi `--in` mai jos). */
.qual-block + .qual-block { margin-top: .6rem; }
.qual-2col {
    display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 20rem), 1fr)); gap: .5rem;
    padding: .4rem; background: var(--ui-raised); border: 1px solid var(--ui-frame);
border-radius: var(--sm-r-row); }
/* TENTA VERDE e a calificaților și NUMAI a lor (cerința userului, iter. 2o). Nu e decor: pe fundal
   verde, rândurile impare opace (`.kf-catrow--odd`) produc zebra verde/deschis care se citește din
   sală ca „ăștia au trecut"; necalificații stau pe `--card`, deci aceeași zebră iese neutră.
   Tenta stă pe CONTAINER, nu pe rânduri — altfel ar ieși dungată peste `.kf-catrow--odd`. */
.qual-2col--in { background: var(--ui-flat); border-bottom-left-radius: 0; border-top-left-radius: 0; box-shadow: inset 4px 0 0 var(--ui-win-mark); }
/* B234 (Arena): tenta calificaților pe TOATE rândurile (nu doar pe fundalul de sub zebră) — blocul se citește verde din sală. */
.qual-2col--in .kf-catrow td { background: var(--ui-qualified-tint); }

/* ---- RANDUL DE CATEGORIE din tabelul de calificare (mutat din kf-skin.css, B159 L10) ----
   Clasa e scrisa in template (`_qualification_section.html.twig`), iar regulile ei existau DOAR in
   kf — stergerea fisierului le-ar fi luat cu totul. Tokenii kf sunt inlocuiti de echivalentii globali
   (tabel de echivalente extras din blocul de remap: `--kf-surface-bright` == `--card`,
   `--kf-surface-2` == `--surface-2`, `--kf-text` == `--text`, `--kf-marker` == `--accent`).
   Dunga de la hover citeste rolul `hover-strip`, cu valoarea de azi ca fallback. */
.kf-catrow td { transition: background .1s; }
.kf-catrow--odd td { background: var(--ui-zebra); }
.kf-catrow:hover td { background: var(--ui-subtle); color: var(--ui-ink); }
.kf-catrow:hover td:first-child { box-shadow: var(--shadow-hover-strip, inset 4px 0 0 var(--ui-ink)); }
.qual-2col > * { min-width: 0; }
/* COLOANA e containerul de măsurare: numele se citesc de la distanță, deci mărimea lor trebuie să
   urmeze lățimea coloanei (~20rem pe telefon, ~45rem pe proiector), nu lățimea ecranului.
   ⚠️ ca la `.bgc`: `cqi` se rezolvă pe COPII, nu pe elementul care declară containerul. */
/* B234 (Arena): fiecare coloană = card plat cu inelul fin al skinului; capul de tabel pe banda liniștită, etichetă rărită. */
.qual-col { container-type: inline-size; min-width: 0; background: var(--ui-flat); border-radius: var(--radius-card, 0); box-shadow: var(--ui-shadow-raised); }
.qual-col .pub-cat-table { font-size: clamp(var(--font-sm), 3.6cqi, var(--font-3xl)); }
.qual-col .tbl-th        { font-size: clamp(var(--font-3xs), 2.2cqi, var(--font-md)); padding: clamp(.1rem, .8cqi, .3rem) clamp(.2rem, 1.4cqi, .6rem); background: var(--ui-subtle); color: var(--ui-ink-muted); font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }
/* Scorul = cifra de citit, pe cerneală, în ambele blocuri (B234: nu mai e lime pe calificați — tenta rândului spune deja asta). */
.qual-col .stat-value    { font-size: clamp(var(--font-2xs), 3cqi, var(--font-2xl)); font-weight: 800; color: var(--ui-ink); font-variant-numeric: tabular-nums; }
/* Locul: cifra apăsată. Pe calificați = cerneala de câștig (pereche cu tenta); pe necalificați = cerneala; un retras calificat se
   stinge (pierderea locului e istorie, nu verdict). Clasă proprie, nu `.text-muted`: utilitarul Bootstrap e `!important` în
   `@layer vendor` și ar bate orice culoare de aici. */
.qual-rank { font-weight: 800; color: var(--ui-ink); }
.qual-2col--in .qual-rank { color: var(--ui-win-ink); }
.qual-2col--in .kf-catrow:has(.e-chip--out) .qual-rank { color: var(--ui-ink-muted); font-weight: 600; }
/* Podelele stau pe COLOANĂ, nu pe tabel (UI_RULES „Tabel dens"): cele trei coloane înguste își țin
   lățimea de citire, iar coloana de nume ia tot restul și e singura care se rupe. Fluide, ca să
   crească odată cu litera — o coloană de rang de 2rem sub o cifră de 24px ar tăia cifra. */
.qual-2col .col-rank-narrow { width: clamp(1.8rem, 7cqi, 4rem); }
.qual-2col .qual-name-cell { min-width: clamp(4rem, 26cqi, 12rem); }
.qual-method { font-size: clamp(var(--font-3xs), 2.6cqi, var(--font-lg)); margin-left: .3rem; vertical-align: middle; }
/* Celula nume RĂMÂNE celulă de tabel (B234, fix): era `display: flex` pe `<td>`, care scoate celula din algoritmul tabelului —
   browserul o înfășoară într-o celulă anonimă și rândurile se taie. Acum: numele curge în celulă, crew-ul pe rândul de sub el,
   marcajul (⚖ ★ ⇧) lipit în dreapta, poziționat absolut pe mijlocul rândului, cu locul lui rezervat în padding. */
.qual-name-cell { position: relative; min-width: 0; line-height: 1.3; }
/* Locul marcajului, rezervat în dreapta. (0,3,0): paddingul celulelor de calificare (`.qual-col .pub-cat-table td`, (0,2,1), în
   components.css) l-ar suprascrie altfel. */
.qual-col .pub-cat-table .qual-name-cell { padding-inline-end: 1.6rem; }
/* Numele lung se RUPE, nu se taie: `text-overflow: ellipsis` ascundea tăcut coada numelui, iar la
   calificați numele E informația. Rupere pe cuvinte întâi (`break-word`; `white-space: normal` desface `nowrap`-ul cipului —
   fără el ruperea nu se întâmpla niciodată); `anywhere` ar cobora min-content-ul până la o literă. */
.qual-name-cell .e-chip { display: inline; min-width: 0; white-space: normal; overflow-wrap: break-word; background: transparent; }
/* Crew-ul / componenții pe rândul de sub nume, puțin mai mici (B234 r2). Componenții unei echipe: UN rând, cât încap, cu „…" —
   `inline-size: 0; min-inline-size: 100%` ține rândul nedespărțit în afara min-content-ului celulei, deci nu lățește tabelul. */
.qual-name-cell .bgc__crew { display: block; font-size: .72em; line-height: 1.2; }
.qual-name-cell .bgc__crew--members { inline-size: 0; min-inline-size: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
/* Retrasul care și-a pierdut locul: crew-ul / componenții tăiați, ca numele. */
.qual-name-cell:has(.e-chip--out) .bgc__crew { text-decoration: line-through; }
/* Butonul de corecții (doar organizatorul): în dreapta, pe mijlocul rândului — nu pe rândul de sub crew; marcajul stă lângă el, iar
   rezerva din dreapta crește doar când butonul există. */
.qual-name-cell .cm-trigger { position: absolute; inset-inline-end: .2rem; inset-block-start: 50%; translate: 0 -50%; }
.qual-name-cell:has(.cm-trigger) .qual-method { inset-inline-end: 1.6rem; }
.qual-col .pub-cat-table .qual-name-cell:has(.cm-trigger) { padding-inline-end: 3rem; }
.qual-name-cell .qual-method { position: absolute; inset-inline-end: .4rem; inset-block-start: 50%; translate: 0 -50%; margin: 0; }
.qual-method--tie_break { color: var(--ui-inverse); }
/* Invitat = calificat direct (fără scor/voturi) — marcaj ★ pe rândul din tabelul de calificați, pe violetul de identitate (B234). */
.qual-method--invited { color: var(--ui-accent); }
/* Rezervă intrată pe locul unui retras (ADR 0042) — marcaj ⇧. Ton NEUTRU, nu accent: a intrat
   pentru că s-a eliberat un loc, nu pentru o performanță în plus. Aceeași logică ca badge-ul de
   retras, care e tot neutru („retragerea e informație, nu accent"). */
.qual-method--reserve { color: var(--ui-ink-muted); }
/* Perechea de înlocuire („înlocuit de X" pe retras, „în locul lui X" pe înlocuitor). Micro-etichetă,
   în ton cu `.e-chip__out`: e adnotare de istorie, nu verdict. `nowrap` fiindcă eticheta și numele
   sunt o singură unitate de citire — rupte pe două rânduri n-ar mai însemna nimic.
   Până pe 2026-08-30 era o săgeată goală („→ X"), scoasă la raportul ownerului: nu spunea ce s-a
   întâmplat și cele două direcții se confundau între ele. Textul poartă acum înțelesul, deci NU mai
   are nevoie de tooltip sau legendă — regula „denumiri care se citesc singure".
   ⚠️ DOAR în listele de calificare. În bracket a fost scoasă (cerința userului, 2026-08-28): acolo
   cardul se dimensionează din container (ADR 0040), iar un nume de lungime arbitrară îi mănâncă
   bugetul de lățime — cel care ține un Top-32 pe telefon. `--font-xs` (11px), nu 9.6px: se citește (B158.b). */
.qual-swap {
    font-size: var(--font-xs); font-weight: 600; color: var(--ui-ink-muted);
    white-space: nowrap; letter-spacing: .02em; font-style: italic;
}
/* Cel care a PIERDUT locul se stinge mai tare decât cel care l-a primit: rândul lui e istorie, nu
   competiție. Aceeași ierarhie ca între `.e-chip__out` și un rând activ. */
.qual-swap--out { opacity: 1; font-weight: 400; color: var(--ui-ink-muted); }
/* Voturile juriului (decidentul PRIMAR) — coloană proeminentă X/Y; plin (toți jurații) = verde */
.qual-votes {
    display: inline-block; min-width: clamp(2rem, 9cqi, 4.5rem); text-align: center;
    font-family: var(--font-mono); font-size: clamp(var(--font-3xs), 2.6cqi, var(--font-lg)); font-weight: 700;
    color: var(--ui-ink-muted); background: transparent;
    border: 1px solid var(--ui-edge); border-radius: var(--sm-r-pill); padding: 0 .3rem;
}
/* B234 (Arena): votul PLIN (toți jurații) = umplerea de câștig, colț de control — se vede din sală. */
.qual-votes--full { color: var(--ui-on-win-fill); border-color: var(--ui-win-mark); background: var(--ui-win-fill); border-radius: var(--radius-control, 0); }
/* Legenda = o notă pe banda liniștită, pe toată lățimea (B234 r2, ownerul: „înghesuită"). */
.qual-legend { font-size: var(--font-base); color: var(--ui-ink-muted); background: var(--ui-subtle); margin: 1rem 0 0; padding: .8rem 1rem; border-radius: var(--radius-card, 0); line-height: 1.55; }
.qual-legend strong { color: var(--ui-ink); }
/* `.qual-cutline` (linia punctată „Necalificați", divider între calificați și eliminați) a fost
   ȘTEARSĂ în iter. 2o: necalificații nu mai vin ca a treia listă dedesubt, ci ca A DOUA COLOANĂ, cu
   antetul ei `.cat-panel-hdr` — același vocabular ca restul tabului. Un divider n-are ce despărți
   între două coloane alăturate, iar o regulă rămasă fără consumatori e junk care minte. */
/* `opacity: .72` pe tot tabelul a fost SCOASĂ în iter. 2o: cât timp necalificații erau o anexă sub
   linia punctată, estomparea îi ținea secundari — dar acum sunt un bloc propriu, cu antet și cu
   aceeași zebră ca restul, iar opacitatea spăla exact zebra pe care userul a cerut-o „normală"
   (și, pe deasupra, contrazicea cererea de text mare, citibil din sală).
   Semnalul „ăștia n-au trecut" rămâne, dar unde trebuie: pe TEXT (culoare estompată), nu pe toată
   suprafața — plus absența tentei verzi, care e adevăratul purtător al distincției. */
.qual-row--out td { color: var(--ui-ink-muted); }


/* ── VOTUL PUBLICULUI (ADR 0030 am.2) — CTA-ul stă LÂNGĂ numele concurentului, în capul „VS" al
   panoului curent, nu într-o cutie separată care repetă numele. Counts NU apar aici
   (anti-bandwagon) — cifrele trăiesc pe scorecard la reveal (.sc-av mai jos). ── */
/* RÂNDUL de vot: aceleași 3 coloane ca „VS" de deasupra, deci fiecare buton stă sub numele lui.
   Sub nume, NU în celula numelui (încercat, raportat 2026-08-15): acolo fura din lățimea numelui pe
   ecran mic, iar cele două laturi își distribuiau liniile independent → butoanele ieșeau decalate
   pe verticală. Într-un rând propriu sunt pe aceeași linie prin construcție. */
.sc__vote {
    /* `padding: 0` (B158, cererea ownerului: „prea departe de toate, recuperăm spațiu"). */
    display: grid; grid-template-columns: 1fr var(--sc-mid) 1fr; align-items: center;
    padding: 0; border-bottom: 1px solid var(--ui-hair);
    /* Continuă suprafața capului, ca numele și butoanele să rămână UN bloc (cerere 2026-08-15). */
    background: var(--ui-quiet);
}
/* Coloanele 1 și 3 (a 2-a rămâne goală), fiecare buton CENTRAT pe coloana lui. NOTĂ 2026-09-01:
   numele de deasupra NU mai e centrat (stă spre marginea exterioară, `.sc-hd__c--1/2`), deci butonul
   nu mai cade sub centrul lui — cade sub centrul COLOANEI. Coloanele sunt însă aceleași ca ale
   capului (`--sc-mid`), deci canalul dintre jumătăți se continuă drept. Textul de mai jos —
   adică exact sub numele de deasupra, care e și el centrat. Containerul se randează și gol după
   vot: rezervă spațiul, nimic nu sare. */
.avc { display: flex; align-items: center; justify-content: center; min-height: 44px; }
/* B158: butonul e VIZUAL mai mic (36px, cererea ownerului), dar ținta de tap rămâne 44px — `::after`
   întinde zona apăsabilă 4px sus și jos (UI_RULES „Ținte touch": acțiunea principală = 44px). Rândul
   păstrează 44px ca rezervare, deci nimic nu sare după vot. */
.avc:first-child { grid-column: 1; }
.avc:last-child { grid-column: 3; }
.avc__btn {
    /* Corp de literă PROPRIU: numele de lângă poate urca până la treptele mari ale scării pe panoul mare, iar
       moștenirea ar face din buton un panou. */
    display: inline-flex; align-items: center; gap: .35rem;
    position: relative;
    min-height: 36px; padding: .3rem .7rem;       /* ținta de tap: vezi `::after` */
    font-family: var(--font-display); font-weight: var(--type-control-weight, 900); text-transform: var(--type-control-case, uppercase);
    font-size: var(--font-sm); letter-spacing: var(--type-control-tracking, .04em); line-height: 1; white-space: nowrap;
    /* CTA NEUTRU: lime-ul e al rezultatului, nu al invitatiei de a vota. B159 L10 (F2). */
    border: 2px solid transparent; border-radius: var(--sm-r-pill);
    background: var(--ui-ink); color: var(--ui-page); cursor: pointer;
    box-shadow: var(--shadow-hard-sm);
}
/* `inset` se măsoară de la PADDING box: butonul de 36px are border 2px, deci -4px dădea 40px (măsurat).
   -6px sus/jos = 44px; -2px lateral acoperă borderul. Rămâne în interiorul `.avc` (44px), fără suprapuneri. */
.avc__btn--vote::after { content: ""; position: absolute; inset: -6px -2px; }
.avc__btn--vote:hover { background: var(--ui-ink-muted); color: var(--ui-page); }
/* După vot: confirmarea rămâne pe latura ALEASĂ. PĂSTREAZĂ umplerea lime — varianta „plată"
   (transparent + --volt-ink) punea cerneală ÎNCHISĂ pe suprafața închisă a panoului și dispărea
   (feedback 2026-08-15). `--volt-ink` are contrast garantat DOAR pe `--volt`, perechea lui.
   Se schimbă doar afordanța: fără cursor de apăsat, fără umbră, fără hover. */
/* „Ai votat" = doar bifa + textul, fara cutie (cererea ownerului). Pe suprafata laturii, cerneala
   tare tine 15:1 in ambele teme. B159 L10 (F2). */
.avc__btn--voted { cursor: default; box-shadow: none;
    background: transparent; border-color: transparent; color: var(--ui-ink);
    padding-inline: 0; font-weight: 600; }

/* ── Rezultatul votului pe scorecard — RÂND PROPRIU, DEASUPRA rezumatului, pe ACELEAȘI 3 coloane ca
   `.sc-totals` → cifra fiecărei laturi cade exact peste numele ei din capul `.sc-hd` (simetric, deci
   spinarea lui cade pe centrul coloanei din mijloc). Tavanul coloanei din mijloc = `--scale-cap`
   (era 8.5rem fix → pe sală se decala față de restul; B115).
   Suprafață NEUTRĂ + o muchie de accent (nu bandă lime plină, feedback 2026-08-15: striga mai tare
   decât verdictul juriului). Identitatea vine din muchie + etichetă, nu din fundal. */
.sc-av {
    display: grid; grid-template-columns: var(--sc-cols); align-items: center;
    background: var(--ui-flat); color: var(--ui-ink);
    border-top: 1px solid var(--ui-hair);
    box-shadow: inset 0 3px 0 0 var(--ui-line);
}
.sc-av__v { padding: .4rem .5rem .3rem; text-align: center; font-family: var(--font-display); font-weight: var(--type-number-weight, 900); line-height: 1; }
/* Cifra e MARE — se citește din sală, de la aceeași distanță ca scorul juriului de sub ea. */
/* Latura care a pierdut votul e ESTOMPATA, nu taiata (B159 L10, F2). */
.sc-av__v:not(.is-win) { color: var(--ui-ink-muted); font-weight: 500; }
.sc-av__v b { font-size: var(--font-4xl); }
.sc-av__v.is-win b { text-decoration: underline; text-underline-offset: .18em; text-decoration-thickness: .09em; }
.sc-av__mid {
    display: flex; align-items: center; justify-content: center; gap: .3rem; padding: .3rem .4rem;
    font-family: var(--font-display); font-weight: 600; text-transform: var(--type-status-case, uppercase);
    letter-spacing: var(--type-status-tracking, .06em); font-size: var(--font-xs); text-align: center; color: var(--ui-ink-muted);
}
.sc--focus .sc-av__v b { font-size: var(--font-6xl); }
.sc--focus .sc-av__mid { font-size: var(--font-sm); }


  /* ---- Garda de MISCARE: punctele care pulseaza se opresc. Coborata din `@layer skin` la B159 L10
     (F2). Garda se imparte dupa unde traieste regula de baza a fiecarui punct: cele doua de aici (`.sc__dot` a
     plecat la B195 L3),
     `.page-state__dot` in base-layout.css. ---- */
  @media (prefers-reduced-motion: reduce) {
    .bgc__live-dot, .now-tag__dot { animation: none; }
  }

  /* ---- FORCED COLORS (High Contrast pe Windows). Toate marcajele de stare ale skinului sunt
     fundaluri / umbre / gradienturi, pe care modul le STERGE: castigatorul, verdictul, live-ul,
     rigla calificatilor ar fi disparut. Fallback verificat in emularea Chromium, ambele teme:
      · starile pe elemente CU TEXT = contur (Chromium picteaza un backplate Canvas sub text, deci o
        umplere Highlight ascunde textul);
      · `border-color: transparent` NU se pastreaza (devine CanvasText) -> `Canvas`;
      · culorile de sistem se pastreaza fara `forced-color-adjust: none`.
     Coborata din `@layer skin` la B159 L10 (F2). ---- */
  @media (forced-colors: active) {
    .bk-entry--winner,
    .sc-jg__no.is-winner,
    .sc-jg__lbl.is-winner { outline: 3px solid Highlight; outline-offset: -3px; }
    :is(.sc-hd__nm, .sc-hd__sub, .sc-hd__adjg).is-win { border-inline-color: Highlight; }
    .sc-hd__n.is-win { text-decoration: underline; text-decoration-thickness: .08em; text-underline-offset: .12em; }
    .sc-jg__pill.is-winner { background: Highlight; border-color: Highlight; }
    .sc-jg__pill.is-down.is-on { background: CanvasText; border-color: CanvasText; color: Canvas; }
    .sc-jg__row.is-current .sc-jg__no { outline: 2px solid Highlight; outline-offset: -2px; }
    .bk-battle--active,
    .bk-battle--golden { outline: 3px double CanvasText; outline-offset: 2px; }
    .bk-battle--next { outline: 2px dashed CanvasText; outline-offset: 2px; }
    .bgc--active { outline: 3px double CanvasText; outline-offset: 1px; }
    .qual-2col--in { border-inline-start: 4px solid Highlight; }
    .bgc__dot--done { background: CanvasText; }
    .bgc__dot--active { background: Highlight; }
    .bgc__dot--pending { background: Canvas; outline: 1px solid CanvasText; outline-offset: -1px; }
    .cat-strip__item--on { outline: 3px solid Highlight; outline-offset: -3px; }
  }

  /* ---- Ultimele reguli coborate din `@layer skin` la B159 L10 (F2) ----
     Scopul pe proiector RAMANE (are un inteles: acolo geometria e alta); scopul pe skin dispare —
     foaia asta e incarcata doar de site. */
  /* (Șina de 3px a rândului de taburi — capătul „L"-ului verde — a fost ȘTEARSĂ la B218: „L"-ul a plecat
     odată cu pastilele, vezi `.cat-block`.) */
  /* Pe PROIECTOR bracketul isi ia latimea din continut: numele in scriere normala l-au ingustat de la
     1313px la 994px (masurat). Pe sala raman in majuscule, ca geometria sa nu se miste. */
  body.live-projector .bk-entry__name { text-transform: uppercase; letter-spacing: .02em; }
} /* END @layer app */