<!-- ═══ ServidorChatK10 V9 — Auditoria Completa V25 (19/abr/2026) ═══
     Correções aplicadas:
     S-1  peerId stale no closure → peerIdRef.current
     S-2  distributeMessage: guard conn.open antes de send
     S-3  stopYoutubeChat: broadcast youtube-chat-stop adicionado
     S-4  broadcastYoutubeChat: msgId adicionado ao seenMessages
     S-5  broadcastYoutubeChat: guard conn.open
     S-6  pureServerModeRef: inicializado com valor real do localStorage (IIFE)
     S-7  youtube-chat-stop de cliente agora é relay para todos os peers ← NOVO V19
     S-8  setupConnection: cada send em try-catch individual
     S-9  startKeepalive: linha p.socket._socket removida (API privada inexistente PeerJS 1.5+) ← NOVO V19
     S-10 Sistema K10 ID: prefixo K10(3) + GID(4) + sufixo(2) = 9 chars ← NOVO V23
          - GID dinâmico: cresce de 1→2→3→4 chars conforme a rede (cap 4)
          - PEX comprimido: transmite {gid, users:[sufixo2chars]} — K10 implícito
          - generateGid: 62 chars case-sensitive (A-Z a-z 0-9)
          - assignUserSuffix: auto-busca sufixo livre na lista do grupo
          - peer-list envia {gid, users} ao invés de peers com IDs completos
     S-11 K10 V24: GID Hierárquico + Lista Delta + Dominância Dinâmica ← NOVO V24
          - generateChildGid: novo grupo deriva GID do pai (prefixo 3 chars herdado)
          - findGroupFamily: localiza todos os GIDs irmãos (mesmo prefixo)
          - buildFamilyPex: comprime listas de grupos irmãos em pex-family com base+deltas
          - checkAndPromote: troca GIDs quando filho supera pai em >20% de usuários
          - Relay de gid-promote e pex-family adicionados ao handleIncomingData
     S-13 K10 V26: Protocolo Binário — pex-update, position-update, gid-promote ← NOVO V26
          - K10BinaryProtocol: instância global k10bin (registry GID↔idx, encode/decode)
          - registerGid: chamado ao criar grupo → atribui índice uint16 sequencial
          - peer-list JSON: campo gidIdx adicionado → cliente aprende o índice do GID
          - pex-update: enviado como Uint8Array(7) via binary protocol (−89% vs JSON)
          - position-update: enviado como Uint8Array(7) via binary protocol (−86%)
          - gid-promote: enviado como Uint8Array(7) via binary protocol (−91%)
          - Relay binário: reencodeWithDecrementedTtl() → sem JSON.stringify/parse
          - Fallback: se conn não suportar binário → JSON V25 mantido como fallback
     S-12 K10 V25: Lista de Posições Fixa + Swap-on-Leave + pex-update ← NOVO V25
          - K10_MAX_GROUP: limite de 1800 usuários por grupo
          - K10_POSITION_LIST: lista fixa de 1800 sufixos (AA..dB) — idêntica em todos os nós
          - positions[]: array contíguo por grupo; positions[i] = peerId na posição i+1
          - peerPositionMapRef: mapeia peerId → {gid, posIdx}
          - Entrada: peer recebe {gid, user, count} — conecta às posições 0..count-1
          - Saída: peer sai → último ocupa buraco → broadcast {type:'pex-update',gid,user}
          - pex-update relay: servidor repassa para toda a rede com TTL decrementado
          - GC atualizado: limpa peerPositionMapRef + reconstrói positions[] correto
     S-13 K10 V25 — FIXES DE BANCADA (19/abr/2026) ← NOVO
          - FIX V25-BUG1: position-update enviado ao peer movido após swap-on-leave
            Sem isso, o peer movido ficava com sufixo errado e mensagens diretas falhavam
            Aplicado em conn.on('close') E no GhostGC
          - FIX V25-BANDA: removido users:[] do peer-list
            Reduz peer-list de ~565 bytes para ~65 bytes (−88%) para grupo de 100 peers
     S-15 AUDITORIA BANCADA V25-FINAL (20/abr/2026) — 8 fixes adicionais ← NOVO
          - FIX-AUDIT-SRV-TITLE: título corrigido V23→V25
          - FIX-AUDIT-SRV-HYDRA 🔴: cap de conexões aplicado também no modo Hydra
            Sem este guard, Hydra aceitava conexões ilimitadas → DoS por RAM
            MAX_HYDRA_CONNECTIONS=500 (fecha em 2s, suporta mais tráfego)
          - FIX-AUDIT-SRV-LOG 🟠: console.log removidos de distributeMessage,
            setupConnection, handleIncomingData, setupPeer, monitoramento
            Previne exposição de IDs de peers, política de bloqueio e metadados
          - FIX-AUDIT-SRV-HYDRA2 🟠: console.log de ativação do modo Hydra
            substituído por addAudit (visível apenas no painel de auditoria)
          - FIX-AUDIT-SRV-AUDIO: descarte silencioso de áudio longo e ficheiros
          - FIX-AUDIT-SRV-CONN-ERR: conn.on error agora registra no audit log
          - FIX-AUDIT-SRV1 🔴: TTL clampado [0..15] em distributeMessage
            Previne relay amplificado por peer malicioso injetando TTL=999999
          - FIX-AUDIT-SRV2 🔴: console.log(data) removido (linha 1455)
            Dados de chat não mais expostos no DevTools do servidor
          - FIX-AUDIT-SRV3 🔴: positions:[] adicionado em directory-announce, group-split, group-merge
            GC periódico não mais falha silenciosamente com peerPositionMap inconsistente
          - FIX-AUDIT-SRV4 🔴: GC periódico agora faz broadcast pex-update quando remove fantasmas
            Clientes corrigem groupSize imediatamente, não esperando 30s
          - FIX-AUDIT-SRV5a 🟠: senderName limitado a 60 chars (previne OOM)
          - FIX-AUDIT-SRV5b 🟠: youtubeId validado com regex [a-zA-Z0-9_-]{6,50}
            Previne injeção de string maliciosa no broadcast de YouTube Chat
═══ -->
<!DOCTYPE html>
<html lang="pt-br">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <!-- HYDRA V7 server --><title>Servidor K10 - V25</title>
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
  <style>
    body {
      font-family: Arial, sans-serif;
      padding: 20px;
      background-color: #f5f5f5;
    }
    #root {
      max-width: 800px;
      margin: 0 auto;
      background: white;
      padding: 20px;
      border-radius: 8px;
      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    .peer-id-container {
      display: flex;
      align-items: center;
      margin-bottom: 10px;
      padding: 10px;
      background: #f8f9fa;
      border-radius: 5px;
    }
    .message {
      margin-bottom: 10px;
      padding: 10px;
      border-radius: 5px;
    }
    .message.you {
      background-color: #e3f2fd;
      margin-left: 20%;
    }
    .message.other {
      background-color: #f1f1f1;
      margin-right: 20%;
    }
    .file-link {
      color: #1976d2;
      text-decoration: none;
      font-weight: bold;
    }
    .progress-container {
      margin-top: 5px;
    }
    .progress-bar {
      height: 5px;
      background: #ddd;
      border-radius: 3px;
      overflow: hidden;
    }
    .progress {
      height: 100%;
      background: #4CAF50;
      width: 0%;
      transition: width 0.3s ease;
    }
    .connected-peers {
      margin-top: 10px;
      padding: 10px;
      background: #f9f9f9;
      border-radius: 4px;
    }
    .peer-item {
      margin: 5px 0;
      padding: 5px;
      background: #e3f2fd;
      border-radius: 3px;
      cursor: pointer;
      display: flex;
      align-items: center;
    }
    button {
      background: #4CAF50;
      color: white;
      border: none;
      padding: 8px 15px;
      border-radius: 4px;
      cursor: pointer;
      margin-left: 10px;
    }
    button:disabled {
      background: #cccccc;
      cursor: not-allowed;
    }
    .file-input-container {
      display: flex;
      gap: 10px;
      margin-top: 10px;
    }
    .audio-player {
      margin-top: 5px;
      width: 100%;
    }
    .contact-form {
      display: flex;
      flex-direction: column;
      gap: 10px;
      margin-bottom: 20px;
    }
    .contact-form-row {
      display: flex;
      flex-direction: column;
      gap: 10px;
    }
    .contact-form input {
      padding: 8px;
      border: 1px solid #ddd;
      border-radius: 4px;
    }
    .contacts-list {
      max-height: 300px;
      overflow-y: auto;
      border-right: 4px solid #4CAF50;
      padding-right: 10px;
    }
    .id-backup-container {
      margin: 10px 0;
      padding: 10px;
      background-color: #fff3cd;
      border-radius: 4px;
      border: 1px solid #ffeeba;
      display: flex;
      align-items: center;
      flex-wrap: wrap;
      gap: 10px;
    }
    .id-input {
      padding: 8px;
      border: 1px solid #ddd;
      border-radius: 4px;
      width: 100px;
      margin-right: 10px;
    }
    .copy-button {
      background: #007bff;
    }
    .status-indicator {
      display: inline-block;
      width: 10px;
      height: 10px;
      border-radius: 50%;
      margin-right: 5px;
    }
    .status-online {
      background-color: #4CAF50;
    }
    .status-offline {
      background-color: #ff0000;
    }
    .status-connecting {
      background-color: #FFC107;
    }
    .distribution-stats {
      margin-top: 15px;
      padding: 10px;
      background-color: #e3f2fd;
      border-radius: 5px;
    }
    .message-source {
      font-size: 0.8em;
      color: #666;
      margin-top: 3px;
    }
    .debug-container {
      margin-top: 15px;
      padding: 10px;
      background-color: #e8f5e9;
      border-radius: 5px;
      border: 1px solid #c8e6c9;
    }
    .server-mode-container {
      margin-top: 15px;
      padding: 10px;
      background-color: #e8f5e9;
      border-radius: 5px;
      display: flex;
      align-items: center;
      gap: 10px;
    }

    /* ── DARK MODE ── */
    body.dark-mode { background-color: #0f172a; color: #e2e8f0; }
    body.dark-mode #root { background: #1e293b; box-shadow: 0 2px 4px rgba(0,0,0,0.4); }
    body.dark-mode .peer-id-container { background: #0f172a; }
    body.dark-mode .id-backup-container { background-color: #1a2332; border-color: #334155; }
    body.dark-mode .id-input { background: #0f172a; color: #e2e8f0; border-color: #334155; }
    body.dark-mode .message.other { background-color: #1e293b; color: #e2e8f0; }
    body.dark-mode .message.you { background-color: #1e3a5f; color: #e2e8f0; }
    body.dark-mode .connected-peers { background: #0f172a; }
    body.dark-mode .peer-item { background: #1e3a5f; color: #e2e8f0; }
    body.dark-mode .distribution-stats { background-color: #1e3a5f; }
    body.dark-mode .distribution-stats > div > div { background: #0f172a !important; border-color: #334155 !important; }
    body.dark-mode .debug-container { background-color: #0a2a1a; border-color: #166534; }
    body.dark-mode .server-mode-container { background-color: #0a2a1a; }
    body.dark-mode input[type="text"] { background: #0f172a; color: #e2e8f0; border-color: #334155; }
    body.dark-mode input[type="checkbox"] { accent-color: #4CAF50; }
    body.dark-mode h1,body.dark-mode h3 { color: #e2e8f0; }
    body.dark-mode p,body.dark-mode small { color: #94a3b8; }
    body.dark-mode .message-source { color: #64748b; }

    /* ── AUDIT LOG PANEL ── */
    .audit-log { margin-top: 15px; padding: 10px; background: #f0f9ff; border: 1px solid #bae6fd; border-radius: 5px; max-height: 180px; overflow-y: auto; font-family: monospace; font-size: 11px; }
    body.dark-mode .audit-log { background: #0a1a33; border-color: #1e4d8c; color: #93c5fd; }
    .audit-entry { padding: 2px 0; border-bottom: 1px solid rgba(0,0,0,0.05); display: flex; gap: 8px; }
    .audit-ts { color: #64748b; white-space: nowrap; }
    .audit-msg.ok { color: #10b981; }
    .audit-msg.warn { color: #f59e0b; }
    .audit-msg.err { color: #ef4444; }
    .audit-msg.info { color: #3b82f6; }
    body.dark-mode .audit-entry { border-bottom-color: rgba(255,255,255,0.05); }

    /* ── STATUS BADGE ── */
    .connection-badge { display: inline-flex; align-items: center; gap: 6px; padding: 4px 12px; border-radius: 20px; font-size: 12px; font-weight: 700; }
    .connection-badge.connected { background: #d1fae5; color: #065f46; }
    .connection-badge.disconnected { background: #fee2e2; color: #991b1b; }
    .connection-badge.connecting,.connection-badge.reconnecting { background: #fef3c7; color: #92400e; }
    body.dark-mode .connection-badge.connected { background: #052e16; color: #34d399; }
    body.dark-mode .connection-badge.disconnected { background: #2a0a0a; color: #f87171; }
    body.dark-mode .connection-badge.connecting,.dark-mode .connection-badge.reconnecting { background: #1c1200; color: #fcd34d; }

  </style>
</head>
<body>
  <div id="root"></div>

  <!-- FIX BUG-5: Spinner cobre tela branca enquanto Babel compila o JSX -->
  <div id="k10-loading" style="position:fixed;inset:0;z-index:99999;background:#f5f5f5;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:16px">
    <div style="width:48px;height:48px;border:4px solid #c8e6c9;border-top-color:#4CAF50;border-radius:50%;animation:k10spin 0.75s linear infinite"></div>
    <p style="color:#388e3c;font-weight:700;margin:0">K10 Servidor — Inicializando…</p>
    <style>@keyframes k10spin{to{transform:rotate(360deg)}}</style>
  </div>
  <script>
    (function(){


      function hideLoader(){ var el=document.getElementById('k10-loading'); if(el){el.style.opacity='0';el.style.transition='opacity 0.3s';setTimeout(function(){if(el.parentNode)el.parentNode.removeChild(el);},320);} }
      setTimeout(hideLoader,12000);
      var obs=new MutationObserver(function(){ var r=document.getElementById('root'); if(r&&r.children.length>0){obs.disconnect();hideLoader();} });
      document.addEventListener('DOMContentLoaded',function(){ var r=document.getElementById('root'); if(r)obs.observe(r,{childList:true}); });
    })();
  </script>

  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.2.0/umd/react.production.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.2.0/umd/react-dom.production.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/esbuild-wasm@0.20.1/lib/browser.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/peerjs/1.5.1/peerjs.min.js"></script>

  <script type="text/tsx" id="esbuild-main">
    const { useState, useEffect, useRef } = React;

      // ════════════════════════════════════════════════════════════════════
      // QUIZ MODULE — portado do Chat_Desktop pra o Servidor assumir após
      // o handoff. SEGUE EXATAMENTE o mesmo wire-format do cliente:
      //   • type:'message' + text:'__QUIZ__'        + quizPayload
      //   • type:'message' + text:'__QUIZ_REVEAL__' + quizRevealPayload
      // Isso garante que clientes existentes recebem do servidor sem nenhuma
      // mudança no Chat_Desktop.
      // ════════════════════════════════════════════════════════════════════
      const QUIZ_SUBJECTS = [
        { id:'mat', name:'Matemática', emoji:'📐', url:'https://andradepsa.github.io/MATEMATICO10/chat/QuizBot/matematica.json' },
        { id:'fis', name:'Física',     emoji:'⚡', url:'https://andradepsa.github.io/MATEMATICO10/chat/QuizBot/fisica.json'     },
        { id:'bio', name:'Biologia',   emoji:'🧬', url:'https://andradepsa.github.io/MATEMATICO10/chat/QuizBot/biologia.json'   },
        { id:'his', name:'História',   emoji:'📜', url:'https://andradepsa.github.io/MATEMATICO10/chat/QuizBot/historia.json'   },
        { id:'geo', name:'Geografia',  emoji:'🌍', url:'https://andradepsa.github.io/MATEMATICO10/chat/QuizBot/geografia.json'  },
        { id:'ger', name:'Conhecimentos Gerais', emoji:'🧠', url:'https://andradepsa.github.io/MATEMATICO10/chat/QuizBot/gerais.json' },
        { id:'world', name:'Lugares do Mundo 🌍', emoji:'📸', url: null }
      ];
      const PIXABAY_KEYS = [
        '55432112-4ff85572d2ddb1603d2c7c5c4','55432140-1856231bf5468f5af7b691a86','55432148-234a48c7b984585064aade170',
        '55432161-ff1841689e09db89ef2fd6d7f','55432169-b8c497c53f9188c1fa4bd0a4c','55432176-243ee3339ef5979afa573d77c',
        '55432183-ff41b44ad26dd56e5a0a10120','55434585-1f45fab6e0f62be2d54cb12bd','55434613-3c2e2bd501e5f1a5f204ceece',
        '55434627-5996e4b3c4a08ba9ed91a5646','55434641-65e1978df07d3aa5c5be3d2f0','55434655-89ae41b0976a93b5bc5c6036d',
        '55434671-f6cddfcc74591c01d66a7ff18','55434681-4437946d973be5211da5447ee','55434697-5842274a69a83edbae6ec914d',
        '55434738-c5fef1c5c12906b9243fe306b','55434756-6131f2df55c3e8d28ec5b5fd1','55434766-66ba5ff749cea752a19570bbd',
        '55434774-343de34f6280ce716fe14916e','55439581-9ac1845d80166675ec0f778f5','55439590-4ba8a21a31cda8d1b04ae4194',
        '55439601-44ebb3b0f6ae06e58574e7e7e','55439616-f9e3ad2818bbce71ae54f1570','55439631-9325f3c2712ae70b75688aa0d',
        '55439656-3b3b5752f73c7cfa9c18476bc','55439666-8e465d451f5e63c73dc72f49d','55439678-d64fcd0f01e1279e4354e65be',
        '55439693-eb6838ccbeea2190f00a83f06','55439706-411b795d17e1fa63ef3536f3e','55439710-3752e92aba25b01235646c2e4',
        '55439724-0fad1a2d813853ca5b2c91ce3'
      ];
      let _srvPixIdx = 0;
      const _srvPixKey = () => { const k = PIXABAY_KEYS[_srvPixIdx % PIXABAY_KEYS.length]; _srvPixIdx++; return k; };
      const _srvImgCache = {};
      const _srvImgLocks = {};

      async function srvFetchWorldImage(query, usedImagesSet) {
        if (!Array.isArray(_srvImgCache[query])) _srvImgCache[query] = [];
        if (_srvImgCache[query].length === 0) {
          if (!_srvImgLocks[query]) {
            _srvImgLocks[query] = (async () => {
              try {
                const url = `https://pixabay.com/api/?key=${_srvPixKey()}&q=${encodeURIComponent(query)}&image_type=photo&safesearch=true&per_page=200&orientation=horizontal`;
                const res = await fetch(url);
                const data = await res.json();
                if (data.hits && data.hits.length > 0) {
                  const arr = [...data.hits];
                  for (let i = arr.length - 1; i > 0; i--) {
                    const j = Math.floor(Math.random() * (i + 1));
                    [arr[i], arr[j]] = [arr[j], arr[i]];
                  }
                  _srvImgCache[query] = arr;
                  const keys = Object.keys(_srvImgCache);
                  if (keys.length > 20) { const k = keys.find(k => k !== query); if (k) delete _srvImgCache[k]; }
                }
              } catch(e) { console.warn('Server Pixabay fetch error', e); }
              finally { _srvImgLocks[query] = null; }
            })();
          }
          await _srvImgLocks[query];
        }
        while (_srvImgCache[query].length > 0) {
          const pick = _srvImgCache[query].shift();
          if (usedImagesSet && !usedImagesSet.has(pick.id)) { usedImagesSet.add(pick.id); return pick; }
        }
        return null;
      }

      // Lista resumida de WORLD_PLACES (mesma usada no cliente). Para reduzir
      // peso, copiamos apenas as queries; o servidor só precisa transmitir
      // (não monta UI nova).
      const WORLD_PLACES = [
        { query:'Cristo Redentor Rio de Janeiro Brazil', country:'Brasil', state:'Rio de Janeiro', place:'Cristo Redentor', statePool:['São Paulo','Minas Gerais','Bahia','Paraná','Rio Grande do Sul','Pernambuco','Ceará','Goiás','Santa Catarina','Espírito Santo'] },
        { query:'Cataratas Iguazu Brazil Parana', country:'Brasil', state:'Paraná', place:'Cataratas do Iguaçu', statePool:['São Paulo','Rio de Janeiro','Minas Gerais','Bahia','Santa Catarina','Mato Grosso','Goiás','Pernambuco','Ceará','Amazonas'] },
        { query:'Machu Picchu Peru mountains', country:'Peru', state:'Cusco', place:'Machu Picchu', statePool:['Lima','Arequipa','Puno','Junín','Ayacucho','Cajamarca','Trujillo','Ica','Piura','Loreto'] },
        { query:'Eiffel Tower Paris France', country:'França', state:'Paris', place:'Torre Eiffel', statePool:['Lyon','Marseille','Nice','Toulouse','Bordeaux','Nantes','Strasbourg','Lille','Rennes','Montpellier'] },
        { query:'Colosseum Rome Italy ancient', country:'Itália', state:'Roma', place:'Coliseu', statePool:['Milão','Veneza','Florença','Nápoles','Turim','Bolonha','Palermo','Gênova','Verona','Pisa'] },
        { query:'Taj Mahal Agra India', country:'Índia', state:'Uttar Pradesh', place:'Taj Mahal', statePool:['Maharashtra','Karnataka','Tamil Nadu','Rajastão','Kerala','Bengala Ocidental','Gujarat','Punjab','Haryana','Goa'] },
        { query:'Great Wall China mountains', country:'China', state:'Pequim', place:'Grande Muralha', statePool:['Xangai','Cantão','Sichuan','Hubei','Yunnan','Henan','Hunan','Anhui','Fujian','Jiangsu'] },
        { query:'Pyramids Giza Egypt desert', country:'Egito', state:'Giza', place:'Pirâmides', statePool:['Cairo','Alexandria','Luxor','Aswan','Hurghada','Sharm el-Sheikh','Suez','Port Said','Faiyum','Mansoura'] }
      ];
      const ALL_COUNTRIES = ['Brasil','França','Itália','Índia','China','Peru','Egito','Grécia','Camboja','Reino Unido','Espanha','Estados Unidos','Austrália','Japão','Emirados Árabes','Canadá','Turquia','México','Jordânia','Indonésia','Alemanha','Portugal','Argentina','Chile','Colômbia','Venezuela','Bolívia','Equador','Paraguai','Uruguai','Cuba','Costa Rica','Panamá','Guatemala','Rússia','Polônia','Hungria','Áustria','Suíça','Holanda','Bélgica','Suécia','Noruega','Finlândia','Dinamarca','Irlanda','Israel','Líbano','Tailândia','Vietnã','Coreia do Sul','Filipinas','Malásia','Singapura','África do Sul','Quênia','Marrocos','Nigéria','Nova Zelândia','Croácia','Malta'];
      function srvBuildAlternatives(pool, correct) {
        const filtered = pool.filter(v => v.toLowerCase() !== correct.toLowerCase());
        const fakes = filtered.sort(() => Math.random() - 0.5).slice(0, 3);
        const all = [...fakes, correct].sort(() => Math.random() - 0.5);
        const idx = all.findIndex(v => v.toLowerCase() === correct.toLowerCase());
        return [all, idx];
      }

      // FIX BUG-1: Alinhado com MIN_QUIZ_INTERVAL do Chat_Desktop (120s).
      // Com 60s o servidor despachava perguntas antes do cooldown do cliente
      // expirar → filtro de vigilância rejeitava como SPAM.
      const SRV_MIN_QUIZ_INTERVAL = 120;


    const TRANSLATIONS = {
      en: {
        serverTitle: "K10 Server",
        distributorId: "Distributor ID:",
        save: "Save",
        cancel: "Cancel",
        copy: "Copy",
        edit: "Edit",
        logoutToEdit: "Log out to edit ID",
        status: "Status:",
        disconnect: "Disconnect",
        connect: "Connect",
        forceReconnect: "Force Reconnect",
        pureServerMode: "Pure Server Mode:",
        activatePureServer: "Activate pure server mode",
        startYoutubeChat: "Start YT Chat",
        stopYoutubeChat: "Stop YT Chat",
        stopQuiz: "Stop Quiz",
        quizActiveOnServer: "Server is broadcasting Quiz",
        connectToOtherServer: "Connect to another Server:",
        serverIdPlaceholder: "Server ID",
        knownServers: "Known Servers:",
        distributionStats: "Distribution Statistics",
        messagesReceived: "Messages Received",
        messagesDistributed: "Messages Distributed",
        activeConnections: "Active Connections",
        hydraWebSize: "Hydra Web Size",
        estimatedP2PNodes: "Estimated P2P Nodes",
        noActiveConnections: "No active connections",
        messages: "Messages",
        noMessagesReceived: "No messages received",
        origin: "Origin:",
        idCopied: "ID copied to clipboard!",
        idEmpty: "ID cannot be empty!",
        serverSelfAdd: "Server cannot add itself!",
        invalidYoutubeUrl: "Invalid YouTube URL",
        enterYoutubeUrl: "Enter YouTube Live URL for Chat:",
        connected: "connected",
        disconnected: "disconnected",
        connecting: "connecting",
        error: "error",
        errorIdUnavailable: "error-id-unavailable",
        errorFatal: "error-fatal",
        reconnecting: "reconnecting",
        darkMode: "Dark Mode",
        tutorial: "Tutorial",
        language: "PT",
        serverFullMigration: "Server full! Migrating you to the decentralized network.",
        pureServerModeConnected: "Connected to K10 server in pure server mode",
        globalRadio: "Global Radio",
        k10Server: "K10 Server",
        serverName: "SERVER",
        chatAlreadyActive: "A chat is already active. Stop it first.",
        hydraModeMessage: "Server in Hydra mode. Connect to the global network.",
        idDescription1: "The ID consists of 6 alphanumeric characters.",
        idDescription2: "More specifically:",
        idDescription3: "Letters: A to Z (uppercase only)",
        idDescription4: "Numbers: 2 to 9",
        ytChatExplanation: "You can start a chat on a YouTube Live and broadcast the YouTube chat from the server. Use the 'Start YT Chat' button. This information is available in both Media and Server menus.",
        clearAuditLog: "Clear",
        noAuditEvents: "No events recorded."
      },
      pt: {
        serverTitle: "Servidor K10",
        distributorId: "ID do Distribuidor:",
        save: "Salvar",
        cancel: "Cancelar",
        copy: "Copiar",
        edit: "Editar",
        logoutToEdit: "Desconecte para editar o ID",
        status: "Status:",
        disconnect: "Desconectar",
        connect: "Conectar",
        forceReconnect: "Forçar Reconexão",
        pureServerMode: "Modo Servidor Puro:",
        activatePureServer: "Ativar modo servidor puro",
        startYoutubeChat: "Iniciar Chat YT",
        stopYoutubeChat: "Parar Chat YT",
        stopQuiz: "Parar Quiz",
        quizActiveOnServer: "Servidor transmitindo Quiz",
        connectToOtherServer: "Conectar a outro Servidor:",
        serverIdPlaceholder: "ID do Servidor",
        knownServers: "Servidores Conhecidos:",
        distributionStats: "Estatísticas de Distribuição",
        messagesReceived: "Mensagens Recebidas",
        messagesDistributed: "Mensagens Distribuídas",
        activeConnections: "Conexões Ativas",
        hydraWebSize: "Tamanho da Teia Hydra",
        estimatedP2PNodes: "Nós P2P Estimados",
        noActiveConnections: "Nenhuma conexão ativa",
        messages: "Mensagens",
        noMessagesReceived: "Nenhuma mensagem recebida",
        origin: "Origem:",
        idCopied: "ID copiado para a área de transferência!",
        idEmpty: "O ID não pode estar vazio!",
        serverSelfAdd: "O servidor não pode adicionar ele mesmo!",
        invalidYoutubeUrl: "URL do YouTube inválida",
        enterYoutubeUrl: "Digite a URL do YouTube Live para o Chat:",
        connected: "conectado",
        disconnected: "desconectado",
        connecting: "conectando",
        error: "erro",
        errorIdUnavailable: "erro-id-indisponível",
        errorFatal: "erro-fatal",
        reconnecting: "reconectando",
        darkMode: "Modo Noturno",
        tutorial: "Tutorial",
        language: "EN",
        serverFullMigration: "Servidor cheio! Migrando você para a rede descentralizada.",
        pureServerModeConnected: "Conectado ao servidor K10 em modo servidor puro",
        globalRadio: "Rádio Global",
        k10Server: "Servidor K10",
        serverName: "SERVIDOR",
        chatAlreadyActive: "Um chat já está ativo. Pare-o primeiro.",
        hydraModeMessage: "Servidor em modo Hydra. Conecte-se à rede global.",
        idDescription1: "O ID consiste em 6 caracteres alfanuméricos.",
        idDescription2: "Mais especificamente:",
        idDescription3: "Letras: A a Z (apenas maiúsculas)",
        idDescription4: "Números: 2 a 9",
        ytChatExplanation: "Você pode iniciar um chat em uma live do YouTube e transmitir o chat do YouTube a partir do servidor. Use o botão 'Iniciar Chat YT'. Esta informação está disponível nos menus Mídias e Servidor.",
        clearAuditLog: "Limpar",
        noAuditEvents: "Nenhum evento registrado."
      }
    };

    const t = (lang, key, vars = {}) => {
      let str = TRANSLATIONS[lang][key] || TRANSLATIONS['en'][key] || key;
      Object.entries(vars).forEach(([k, v]) => { str = str.replace(`{${k}}`, v); });
      return str;
    };

    const PEER_ID_STORAGE_KEY = 'p2pChatDistributorId';
    const DEFAULT_ID = 'AAAAAA';

    const usePersistentId = () => {
      const [peerId, setPeerId] = useState(() => {
        try {
          const saved = localStorage.getItem(PEER_ID_STORAGE_KEY) || DEFAULT_ID;
          return saved.endsWith('-CENTRAL') ? saved : saved + '-CENTRAL';
        } catch (e) {
          return DEFAULT_ID + '-CENTRAL';
        }
      });

      useEffect(() => {
        try {
          const formattedId = peerId.endsWith('-CENTRAL') ? peerId : peerId + '-CENTRAL';
          if (formattedId !== peerId) {
            setPeerId(formattedId);
            return;
          }
          localStorage.setItem(PEER_ID_STORAGE_KEY, formattedId);
          sessionStorage.setItem(PEER_ID_STORAGE_KEY, formattedId);
          document.cookie = `${PEER_ID_STORAGE_KEY}=${formattedId}; max-age=31536000; path=/`;
        } catch (e) {
          console.error("Erro ao persistir ID:", e);
        }
      }, [peerId]);

      return [peerId, setPeerId];
    };

    const IdBackupTools = ({ peerId, setPeerId, onSaveId, isConnected, lang }) => {
      const [editableId, setEditableId] = useState(peerId);
      const [isEditing, setIsEditing] = useState(false);

      const copyToClipboard = () => {
        navigator.clipboard.writeText(peerId).then(() => {
          alert(t(lang, 'idCopied'));
        });
      };

      const startEditing = () => {
        setEditableId(peerId);
        setIsEditing(true);
      };

      const saveId = () => {
        if (editableId.trim() === '') {
          alert(t(lang, 'idEmpty'));
          return;
        }
        
        if (editableId !== peerId) {
          setPeerId(editableId);
          if (onSaveId) onSaveId(editableId);
        }
        
        setIsEditing(false);
      };

      return (
        <div className="id-backup-container">
          <div>
            <strong>{t(lang, 'distributorId')}</strong> 
            {isEditing ? (
              <>
                <input 
                  type="text" 
                  className="id-input"
                  value={editableId}
                  onChange={(e) => setEditableId(e.target.value)}
                  placeholder={t(lang, 'distributorId')}
                />
                <button onClick={saveId}>{t(lang, 'save')}</button>
                <button onClick={() => setIsEditing(false)}>{t(lang, 'cancel')}</button>
              </>
            ) : (
              <>
                {peerId}
                <button onClick={copyToClipboard} className="copy-button">
                  {t(lang, 'copy')}
                </button>
                <button 
                  onClick={startEditing}
                  disabled={isConnected}
                >
                  {t(lang, 'edit')}
                </button>
              </>
            )}
          </div>
          {isConnected && !isEditing && (
            <p><small>{t(lang, 'logoutToEdit')}</small></p>
          )}
        </div>
      );
    };

    const DistributorApp = () => {
      const [lang, setLang] = useState(() => localStorage.getItem('serverLang') || 'en');
      const langRef = useRef(localStorage.getItem('serverLang') || 'en'); // FIX S1: evita stale closure em setupConnection/conn.on
      useEffect(() => { langRef.current = lang; }, [lang]);
      const [peerId, setPeerId] = usePersistentId();
      const [connections, setConnections] = useState([]);
      const [messages, setMessages] = useState([]);
      const [connectionStatus, setConnectionStatus] = useState('disconnected');
      const [stats, setStats] = useState({
        messagesReceived: 0,
        messagesDistributed: 0,
        activeConnections: 0,
        hydraNodes: 0
      });

      useEffect(() => {
        localStorage.setItem('serverLang', lang);
      }, [lang]);
      // New state to control the mode — persisted in localStorage
      const [pureServerMode, setPureServerMode] = useState(() => {
        const saved = localStorage.getItem('pureServerMode');
        return saved === null ? true : saved === 'true';
      });
      // BUG S-6 FIX: inicializa pureServerModeRef com o valor real salvo,
      // evitando janela de dessincronização entre estado e ref antes do primeiro useEffect.
      const _pureServerModeInitial = (() => {
        const saved = localStorage.getItem('pureServerMode');
        return saved === null ? true : saved === 'true';
      })();
      const pureServerModeRef = useRef(_pureServerModeInitial);
      useEffect(() => { pureServerModeRef.current = pureServerMode; localStorage.setItem('pureServerMode', pureServerMode); }, [pureServerMode]);
      const [knownServers, setKnownServers] = useState(() => {
        try { return JSON.parse(localStorage.getItem('knownServers') || '[]'); } catch { return []; }
      });
      // FIX: ref mirrors knownServers so peer.on('open') never reads stale closure
      const knownServersRef = useRef([]);
      useEffect(() => { knownServersRef.current = knownServers; }, [knownServers]);
      const [darkMode, setDarkMode] = useState(() => localStorage.getItem('serverDarkMode') === 'true');
      const [auditLog, setAuditLog] = useState([]);
      const auditLogRef = useRef([]);
      const addAudit = (msg, type = 'info') => {
        const entry = { ts: new Date().toLocaleTimeString(), msg, type };
        auditLogRef.current = [entry, ...auditLogRef.current].slice(0, 60);
        setAuditLog([...auditLogRef.current]);
      };
      useEffect(() => {
        if (darkMode) { document.body.classList.add('dark-mode'); }
        else { document.body.classList.remove('dark-mode'); }
        localStorage.setItem('serverDarkMode', darkMode);
      }, [darkMode]);
      const [newServerId, setNewServerId] = useState('');
      const [youtubeChatId, setYoutubeChatId] = useState(null);
      const [youtubeBroadcasts, setYoutubeBroadcasts] = useState({});
      const youtubeChatIdRef = useRef(null);
      useEffect(() => { youtubeChatIdRef.current = youtubeChatId; }, [youtubeChatId]);
      const radioStateRef = useRef({ status: 'idle', startTime: 0, duration: 0 });
      
      const peerInstance = useRef(null);
      const pendingFiles = useRef({});
      const messagesEndRef = useRef(null);
      const activeConnectionsRef = useRef(new Map());
      const seenMessagesRef = useRef(new Set());
      const isHydraModeRef = useRef(false);
      const recentPeersRef = useRef([]);
      const heartbeatsRef = useRef(new Map());
      const worldQuizNodesRef = useRef(new Set());
      const quizBotPeerRef = useRef(null);

      // ═══════════════════════════════════════════════════════════════
      // S-10 V23: Sistema K10 ID
      // Estrutura: K10(3) + GID(4) + sufixo(2) = 9 chars total
      // K10 = prefixo implícito — NUNCA transmitido na rede
      // GID = identificador do grupo — 4 chars, transmitido 1× por lista
      // sufixo = identificador do usuário no grupo — 2 chars
      // Charset: 62 chars case-sensitive (A-Z a-z 0-9)
      // ═══════════════════════════════════════════════════════════════
      const K10_PREFIX = 'K10';
      const K10_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
      const K10_GID_LEN = 4;
      const K10_SUFFIX_LEN = 2;

      // ── V25: Lista de 1800 posições fixas — idêntica em TODOS os nós ──────
      // Posição 1→'AA', Posição 2→'AB', ..., Posição 1800→'dB'
      // Gravada no código: ninguém precisa transmitir a lista, só o índice/sufixo
      const K10_MAX_GROUP = 1800;
      const K10_POSITION_LIST = (() => {
        const list = [];
        for (let i = 0; i < K10_CHARS.length; i++) {
          for (let j = 0; j < K10_CHARS.length; j++) {
            if (list.length >= K10_MAX_GROUP) break;
            list.push(K10_CHARS[i] + K10_CHARS[j]);
          }
          if (list.length >= K10_MAX_GROUP) break;
        }
        return list; // ['AA','AB','AC',...,'dB'] — exatamente 1800 entradas
      })();

      // ── V26: Protocolo Binário K10 ─────────────────────────────────────────
      // K10BinaryProtocol: registry GID↔idx + encode/decode de 7 bytes
      // MAGIC=0xB1 | TYPE(1B) | PARAM_A uint16LE | PARAM_B uint16LE | AUX(TTL+SEQ)
      const K10B_MAGIC   = 0xB1;
      const K10B_SIZE    = 7;
      const K10B_TYPE    = { PEX_UPDATE:0x01, POSITION_UPDATE:0x02, GID_PROMOTE:0x03, JOIN_UPDATE:0x04 };
      const K10B_SEQ_MASK  = 0x1F;
      const K10B_TTL_SHIFT = 5;
      const K10B_TTL_MAX   = 6;

      class K10BinaryProtocol {
        constructor() {
          this._gidToIdx = new Map();
          this._idxToGid = new Map();
          this._nextIdx  = 0;
          this._seqCounters = new Map();
          this._dedupCache  = new Set();
          this._dedupOrder  = [];
        }
        registerGid(gid) {
          if (this._gidToIdx.has(gid)) return this._gidToIdx.get(gid);
          const idx = this._nextIdx++;
          this._gidToIdx.set(gid, idx);
          this._idxToGid.set(idx, gid);
          return idx;
        }
        getIdx(gid)  { return this._gidToIdx.has(gid) ? this._gidToIdx.get(gid) : -1; }
        getGid(idx)  { return this._idxToGid.get(idx) || null; }
        learnGid(gid, idx) {
          if (typeof idx !== 'number' || idx < 0) return;
          this._gidToIdx.set(gid, idx); this._idxToGid.set(idx, gid);
          if (idx >= this._nextIdx) this._nextIdx = idx + 1;
        }
        nextSeq(gidIdx) {
          const next = ((this._seqCounters.get(gidIdx) || 0) + 1) & K10B_SEQ_MASK;
          this._seqCounters.set(gidIdx, next); return next;
        }
        isDuplicate(gidIdx, type, seq) {
          const key = `${gidIdx}:${type}:${seq}`;
          if (this._dedupCache.has(key)) return true;
          this._dedupCache.add(key); this._dedupOrder.push(key);
          if (this._dedupOrder.length > 128) this._dedupCache.delete(this._dedupOrder.shift());
          return false;
        }
        encode(type, gidIdxA, paramB, ttl = K10B_TTL_MAX, seq = -1) {
          if (gidIdxA < 0) return null;
          const safeGidA  = gidIdxA & 0xFFFF;
          const safeParamB = paramB   & 0xFFFF;
          const safeTtl   = Math.min(Math.max(0, ttl), K10B_TTL_MAX) & 0x07;
          const safeSeq   = seq < 0 ? this.nextSeq(safeGidA) : (seq & K10B_SEQ_MASK);
          const buf = new Uint8Array(K10B_SIZE);
          const view = new DataView(buf.buffer);
          buf[0] = K10B_MAGIC; buf[1] = type;
          view.setUint16(2, safeGidA, true);
          view.setUint16(4, safeParamB, true);
          buf[6] = (safeTtl << K10B_TTL_SHIFT) | safeSeq;
          return buf;
        }
        decode(buffer) {
          const buf = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
          if (buf.length < K10B_SIZE || buf[0] !== K10B_MAGIC) return null;
          const view = new DataView(buf.buffer, buf.byteOffset);
          const type   = buf[1];
          const paramA = view.getUint16(2, true);
          const paramB = view.getUint16(4, true);
          const aux    = buf[6];
          return { type, paramA, paramB, ttl:(aux >> K10B_TTL_SHIFT) & 0x07, seq:aux & K10B_SEQ_MASK };
        }
        static isBinaryPacket(data) {
          if (data instanceof ArrayBuffer) return data.byteLength >= K10B_SIZE && new Uint8Array(data)[0] === K10B_MAGIC;
          if (data instanceof Uint8Array)  return data.length   >= K10B_SIZE && data[0]                  === K10B_MAGIC;
          return false;
        }
        // Alto nível — servidor
        encodePexUpdate(gid, newCount, ttl = K10B_TTL_MAX) {
          return this.encode(K10B_TYPE.PEX_UPDATE, this.getIdx(gid), newCount, ttl);
        }
        encodePositionUpdate(gid, newPosIdx) {
          return this.encode(K10B_TYPE.POSITION_UPDATE, this.getIdx(gid), newPosIdx, 0);
        }
        encodeGidPromote(gidA, gidB, ttl = K10B_TTL_MAX) {
          const ia = this.getIdx(gidA), ib = this.getIdx(gidB);
          if (ia < 0 || ib < 0) return null;
          return this.encode(K10B_TYPE.GID_PROMOTE, ia, ib, ttl);
        }
        // Alto nível — relay
        reencodeWithDecrementedTtl(buffer) {
          const pkt = this.decode(buffer);
          if (!pkt || pkt.ttl === 0) return null;
          return this.encode(pkt.type, pkt.paramA, pkt.paramB, pkt.ttl - 1, pkt.seq);
        }
      }

      // Instância global do protocolo binário (compartilhada por todas as funções do servidor)
      const k10bin = new K10BinaryProtocol();

      // Wrapper de envio: tenta binário primeiro, cai em JSON se necessário
      const k10Send = (conn, binaryBuf, jsonFallback) => {
        if (!conn || !conn.open) return;
        try {
          if (binaryBuf) {
            conn.send(binaryBuf.buffer); // PeerJS suporta ArrayBuffer
            return;
          }
        } catch(e) { /* fallthrough para JSON */ }
        try { conn.send(jsonFallback); } catch(e2) {}
      };

      // Wrapper de broadcast binário para todos os peers conectados
      const k10BroadcastBinary = (binaryBuf, jsonFallback, excludePeer = null) => {
        if (!binaryBuf && !jsonFallback) return;
        activeConnectionsRef.current.forEach((c, pid) => {
          if (pid === excludePeer || !c.open) return;
          k10Send(c, binaryBuf, jsonFallback);
        });
      };
      // ── Fim V26 Protocolo Binário ──────────────────────────────────────────

      // Gera um GID aleatório de 4 chars
      const generateGid = () => {
        const buf = new Uint8Array(K10_GID_LEN);
        crypto.getRandomValues(buf);
        return Array.from(buf).map(b => K10_CHARS[b % K10_CHARS.length]).join('');
      };

      // Contador global de GIDs gerados — usado para GID sequencial quando necessário
      const gidCounterRef = useRef(0);

      // Gera próximo GID sequencial (para grupos novos criados pelo servidor)
      const nextSequentialGid = () => {
        let n = gidCounterRef.current++;
        let gid = '';
        for (let i = 0; i < K10_GID_LEN; i++) {
          gid = K10_CHARS[n % K10_CHARS.length] + gid;
          n = Math.floor(n / K10_CHARS.length);
        }
        return gid;
      };

      // Extrai sufixo (2 chars) de um peerId completo K10GGGGXX
      const extractSuffix = (peerId) => {
        if (!peerId || peerId.length < K10_PREFIX.length + K10_GID_LEN + K10_SUFFIX_LEN) return null;
        return peerId.slice(K10_PREFIX.length + K10_GID_LEN);
      };

      // Extrai GID (4 chars) de um peerId completo K10GGGGXX
      const extractGid = (peerId) => {
        if (!peerId || peerId.length < K10_PREFIX.length + K10_GID_LEN) return null;
        return peerId.slice(K10_PREFIX.length, K10_PREFIX.length + K10_GID_LEN);
      };

      // Reconstrói peerId completo a partir de GID + sufixo
      const buildPeerId = (gid, suffix) => K10_PREFIX + gid + suffix;

      // Encontra o próximo sufixo livre para um grupo (varredura sequencial)
      const findFreeSuffix = (gid) => {
        const group = activeGroupsRef.current[gid];
        const usedSuffixes = new Set();
        if (group && group.members) {
          group.members.forEach(pid => {
            const s = extractSuffix(pid);
            if (s) usedSuffixes.add(s);
          });
        }
        // Varredura sequencial: AA, AB, AC ... zz
        for (let i = 0; i < K10_CHARS.length; i++) {
          for (let j = 0; j < K10_CHARS.length; j++) {
            const candidate = K10_CHARS[i] + K10_CHARS[j];
            if (!usedSuffixes.has(candidate)) return candidate;
          }
        }
        return null; // grupo cheio (3844 usuários)
      };

      // ═══════════════════════════════════════════════════════════════
      // K10 V24: GID Hierárquico + Lista Delta + Dominância Dinâmica
      // ═══════════════════════════════════════════════════════════════

      // Gera GID filho derivado do pai (herança do prefixo de 3 chars)
      // Pai "AbCd" → filho "AbCe", "AbCf" ... até esgotar → fallback sequencial
      const generateChildGid = (parentGid) => {
        if (!parentGid || parentGid.length < K10_GID_LEN) return nextSequentialGid();
        const prefix = parentGid.slice(0, K10_GID_LEN - 1);
        const siblings = new Set(
          Object.keys(activeGroupsRef.current)
            .filter(g => g.startsWith(prefix) && g.length === K10_GID_LEN)
            .map(g => g[K10_GID_LEN - 1])
        );
        for (const c of K10_CHARS) {
          if (!siblings.has(c)) return prefix + c;
        }
        return nextSequentialGid(); // todos 62 slots do prefixo ocupados
      };

      // Retorna todos os GIDs da mesma família (prefixo dos 3 primeiros chars)
      const findGroupFamily = (gid) => {
        const prefix = gid.slice(0, K10_GID_LEN - 1);
        return Object.keys(activeGroupsRef.current)
          .filter(g => g.startsWith(prefix) && g.length === K10_GID_LEN);
      };

      // Monta pex-family comprimido: base = sufixos em TODOS, branches = deltas por grupo
      // Retorna null se a família tiver só 1 membro (sem ganho de compressão)
      const buildFamilyPex = (referenceGid) => {
        const family = findGroupFamily(referenceGid);
        if (family.length < 2) return null;
        const memberSets = family.map(gid =>
          new Set(
            Array.from(activeGroupsRef.current[gid]?.members || new Set())
              .map(pid => extractSuffix(pid)).filter(Boolean)
          )
        );
        const base = [...memberSets[0]].filter(s => memberSets.every(set => set.has(s)));
        const branches = family.map((gid, i) => ({
          ext: gid[K10_GID_LEN - 1],
          delta: [...memberSets[i]].filter(s => !base.includes(s))
        }));
        return { type: 'pex-family', prefix: referenceGid.slice(0, K10_GID_LEN - 1), base, branches, ttl: 6 };
      };

      // FASE-2: diretório global de grupos no servidor
      // { [gid]: { size: number, reservados: string[], members: Set<peerId> } }
      // V23: GID inicial gerado dinamicamente (4 chars, 62-charset)
      const _initialGid = nextSequentialGid(); // 'AAAA' na primeira execução
      k10bin.registerGid(_initialGid); // V26: registra GID inicial no registry binário
      const activeGroupsRef = useRef({ [_initialGid]: { size: 0, reservados: [], members: new Set(), positions: [] } });
      // FASE-2: mapeia peerId → groupId para decrementar ao desconectar
      const peerGroupMapRef = useRef(new Map());
      // V25: mapeia peerId → {gid, posIdx} para swap-on-leave eficiente
      const peerPositionMapRef = useRef(new Map());

      // V24: Verifica e executa troca de GID quando filho domina o pai em tamanho
      // Chamado após cada split e periodicamente pelo GC
      const checkAndPromote = (gidA, gidB) => {
        const ga = activeGroupsRef.current[gidA];
        const gb = activeGroupsRef.current[gidB];
        if (!ga || !gb) return;
        const sA = ga.members.size, sB = gb.members.size;
        if (sA === sB || Math.min(sA, sB) === 0) return;
        // Só troca se diferença for >20% para evitar flip-flop contínuo
        if (Math.abs(sA - sB) / Math.min(sA, sB) < 0.2) return;
        // Só troca entre grupos da mesma família (prefixo de 3 chars igual)
        if (gidA.slice(0, K10_GID_LEN - 1) !== gidB.slice(0, K10_GID_LEN - 1)) return;
        const [dominant, recessive] = sA > sB ? [gidA, gidB] : [gidB, gidA];
        // Swap no diretório
        const tmp = activeGroupsRef.current[dominant];
        activeGroupsRef.current[dominant] = activeGroupsRef.current[recessive];
        activeGroupsRef.current[recessive] = tmp;
        // Atualiza peerGroupMap
        peerGroupMapRef.current.forEach((gid, peer) => {
          if (gid === dominant) peerGroupMapRef.current.set(peer, recessive);
          else if (gid === recessive) peerGroupMapRef.current.set(peer, dominant);
        });
        // V26: gid-promote BINÁRIO (7 bytes vs ~80 bytes JSON)
        const binPromote = k10bin.encodeGidPromote(dominant, recessive, 8);
        const jsonPromote = {
          type: 'gid-promote',
          msgId: Date.now().toString(36) + Math.random().toString(36).slice(2),
          formerDominantGid: dominant,
          formerRecessiveGid: recessive,
          ttl: 8
        };
        k10BroadcastBinary(binPromote, jsonPromote);
        addAudit(`[K10-V26] Promoção GID binária: ${dominant} ↔ ${recessive} (${Math.max(sA,sB)} vs ${Math.min(sA,sB)} users)`, 'info');
      };

      // FIX BUG-I: seenMessagesRef crescia sem limite → memory leak grave no servidor
      // Mantém no máximo 2 000 entradas; ao ultrapassar, descarta a metade mais antiga (FIFO)
      const pruneSeenSrv = () => {
        const s = seenMessagesRef.current;
        if (s.size > 2000) {
          const keep = [...s].slice(-1000);
          seenMessagesRef.current = new Set(keep);
        }
      };

      
      // ── Estado do Quiz quando o SERVIDOR assume a transmissão ──
      const [serverQuizActive, setServerQuizActive] = useState(false);
      const serverQuizActiveRef = useRef(false);
      const srvQuizDisciplineRef = useRef('world');
      const srvQuizIntervalRef = useRef(SRV_MIN_QUIZ_INTERVAL);
      const srvLastQuizTimeRef = useRef(0);
      const srvQuizUsedImagesRef = useRef(new Set());
      const srvQuizTimerRef = useRef(null);
      const srvCurrentQuizRef = useRef(null);
      const srvWorldPlaceIdxRef = useRef(0);

      // V9: Garbage Collector para conexões WebRTC fantasmas (onde o evento on('close') não dispara)
      useEffect(() => {
        const ghostGcIv = setInterval(() => {
          activeConnectionsRef.current.forEach((conn, peerId) => {
            if (!conn.peerConnection) return;
            const state = conn.peerConnection.connectionState;
            if (state === 'failed' || state === 'closed' || state === 'disconnected') {
              addAudit(`[GhostGC] Peer fantasma [${peerId}] detectado e removido (${state})`, 'warn');
              try { conn.close(); } catch(e){}
              
              // Limpeza manual já que o evento close pode não disparar
              if (quizBotPeerRef.current === peerId) {
                quizBotPeerRef.current = null;
                activeConnectionsRef.current.forEach((c) => {
                  try { c.send({ type: 'quiz-bot-status', active: false }); } catch(e) {}
                });
              }
              
              // V25: swap-on-leave para manter positions[] contíguo
              const ghostPosInfo = peerPositionMapRef.current.get(peerId);
              if (ghostPosInfo) {
                const { gid: ghostGid, posIdx: ghostPosIdx } = ghostPosInfo;
                const ghostGroup = activeGroupsRef.current[ghostGid];
                if (ghostGroup && ghostGroup.positions) {
                  const oldLen = ghostGroup.positions.length;
                  if (oldLen > 0 && ghostPosIdx < oldLen) {
                    if (ghostPosIdx < oldLen - 1) {
                      // Move o último para o buraco
                      const lastPeer = ghostGroup.positions[oldLen - 1];
                      ghostGroup.positions[ghostPosIdx] = lastPeer;
                      peerPositionMapRef.current.set(lastPeer, { gid: ghostGid, posIdx: ghostPosIdx });
                      // FIX V25-BUG1 / V26: notifica peer movido — position-update BINÁRIO
                      const movedConn = activeConnectionsRef.current.get(lastPeer);
                      if (movedConn && movedConn.open) {
                        const binPosUpd = k10bin.encodePositionUpdate(ghostGid, ghostPosIdx);
                        const jsonPosUpd = { type: 'position-update', gid: ghostGid, user: K10_POSITION_LIST[ghostPosIdx] };
                        k10Send(movedConn, binPosUpd, jsonPosUpd);
                      }
                    }
                    ghostGroup.positions.pop();
                    // V26: broadcast pex-update BINÁRIO (7 bytes vs ~65 bytes JSON)
                    const newCount = ghostGroup.positions.length;
                    const binPexUpd = k10bin.encodePexUpdate(ghostGid, newCount, 6);
                    const jsonPexUpd = {
                      type: 'pex-update', gid: ghostGid,
                      user: K10_POSITION_LIST[oldLen - 1], ttl: 6,
                      msgId: Date.now().toString(36) + Math.random().toString(36).slice(2)
                    };
                    k10BroadcastBinary(binPexUpd, jsonPexUpd);
                  }
                  ghostGroup.members.delete(peerId);
                  ghostGroup.size = ghostGroup.positions.length;
                }
                peerPositionMapRef.current.delete(peerId);
              } else {
                // Fallback: remoção antiga (sem posição rastreada)
                const peerGroupId = peerGroupMapRef.current.get(peerId);
                if (peerGroupId && activeGroupsRef.current[peerGroupId]) {
                  activeGroupsRef.current[peerGroupId].size = Math.max(0, activeGroupsRef.current[peerGroupId].size - 1);
                  activeGroupsRef.current[peerGroupId].members.delete(peerId);
                }
              }
              
              peerGroupMapRef.current.delete(peerId);
              activeConnectionsRef.current.delete(peerId);
              
              setConnections(Array.from(activeConnectionsRef.current.keys()));
              setStats(prev => ({
                ...prev,
                activeConnections: activeConnectionsRef.current.size,
                hydraNodes: recentPeersRef.current.length
              }));
            }
          });
        }, 5000);
        return () => clearInterval(ghostGcIv);
      }, []);
      const srvQuizAllIdxRef = useRef(0);
      const HYDRA_THRESHOLD = 150;
      const CHUNK_SIZE = 16 * 1024;

      // ── Reconexão robusta ──────────────────────────────────────────────
      const reconnectAttemptsRef = useRef(0);
      const reconnectTimerRef    = useRef(null);
      const keepaliveTimerRef    = useRef(null);
      const isManualDisconnectRef = useRef(false); // distingue desconexão manual
      const MAX_RECONNECT_ATTEMPTS = 20; // circuit-breaker

      // ═══ V8-F10: GC periódico de members fantasmas em activeGroupsRef ═══
      useEffect(() => {
        const gc = setInterval(() => {
          try {
            const livePeers = new Set(activeConnectionsRef.current.keys());
            for (const gid in activeGroupsRef.current) {
              const g = activeGroupsRef.current[gid];
              if (!g || !g.members) continue;
              let removed = 0;
              for (const p of Array.from(g.members)) {
                if (!livePeers.has(p)) { g.members.delete(p); removed++; }
              }
              // V25: reconstrói positions[] com base nos membros vivos, mantendo ordem original
              if (Array.isArray(g.positions)) {
                const oldLen = g.positions.length;
                g.positions = g.positions.filter(p => livePeers.has(p));
                // Atualiza posIdx para cada peer restante
                g.positions.forEach((p, idx) => {
                  peerPositionMapRef.current.set(p, { gid, posIdx: idx });
                });
                // Remove do peerPositionMapRef os peers que foram removidos
                for (const p of Array.from(peerPositionMapRef.current.keys())) {
                  if (peerPositionMapRef.current.get(p)?.gid === gid && !g.positions.includes(p)) {
                    peerPositionMapRef.current.delete(p);
                  }
                }
                if (oldLen !== g.positions.length) {
                  addAudit(`[V25-GC] posições grupo ${gid}: ${oldLen}→${g.positions.length}`, 'info');
                  // FIX-AUDIT-SRV4 / V26: broadcast pex-update BINÁRIO para clientes corrigirem groupSize
                  const newLen = g.positions.length;
                  const gcBinPex = k10bin.encodePexUpdate(gid, newLen, 4);
                  const gcPexUpd = {
                    type: 'pex-update', gid,
                    user: K10_POSITION_LIST[newLen] || 'AA', ttl: 4,
                    msgId: 'gc_' + gid + '_' + Date.now().toString(36)
                  };
                  k10BroadcastBinary(gcBinPex, gcPexUpd);
                }
              }
              g.size = Math.max(0, g.members.size);
              g.reservados = (g.reservados || []).filter(p => livePeers.has(p)).slice(0, 10);
              if (removed > 0) addAudit(`[V8-F10] GC grupo ${gid}: -${removed} fantasmas, size=${g.size}`, 'warn');
              // V23: remove grupo vazio exceto o primeiro grupo da rede (índice 0 do gidCounter)
              const firstGid = Object.keys(activeGroupsRef.current)[0];
              if (g.members.size === 0 && gid !== firstGid) {
                delete activeGroupsRef.current[gid];
              }
            }
          } catch(e) { console.warn('[V8-F10] gc error', e); }
        }, 60000);
        return () => clearInterval(gc);
      }, []);

      const BASE_RECONNECT_DELAY   = 2000; // 2s inicial

      // Backoff exponencial com jitter: 2s, 4s, 8s … até 60s
      const getBackoffDelay = (attempt) => {
        const exp = Math.min(BASE_RECONNECT_DELAY * Math.pow(2, attempt), 60000);
        return exp + Math.random() * 1000; // jitter de até 1s
      };

      // Cancela qualquer timer de reconexão pendente
      const clearReconnectTimer = () => {
        if (reconnectTimerRef.current) {
          clearTimeout(reconnectTimerRef.current);
          reconnectTimerRef.current = null;
        }
      };

      // Para o keepalive
      const stopKeepalive = () => {
        if (keepaliveTimerRef.current) {
          clearInterval(keepaliveTimerRef.current);
          keepaliveTimerRef.current = null;
        }
      };

      // Keepalive: envia um ping ao servidor PeerJS a cada 25s para evitar timeout silencioso
      const startKeepalive = () => {
        stopKeepalive();
        keepaliveTimerRef.current = setInterval(() => {
          const p = peerInstance.current;
          if (p && !p.destroyed && !p.disconnected) {
            // FIX S-9: p.socket._socket era API privada inexistente no PeerJS 1.5+ → código morto + erro silencioso.
            // PeerJS 1.5+ já faz keep-alive automático via pingInterval:5000 configurado no new Peer(). Linha removida.
            // Também detecta conexões mortas e remove
            activeConnectionsRef.current.forEach((conn, id) => {
              try {
                const state = conn.peerConnection && conn.peerConnection.connectionState;
                if (state === 'failed' || state === 'closed') {
                  console.warn(`Keepalive: removendo conexão morta ${id}`);
                  activeConnectionsRef.current.delete(id);
                  setConnections(Array.from(activeConnectionsRef.current.keys()));
                }
              } catch(e) {}
            });
          } else if (p && p.disconnected && !p.destroyed) {
            // peer desconectado — scheduleReconnect será chamado
            scheduleReconnect();
          }
        }, 25000);
      };

      // Ref para sempre ter o peerId mais recente dentro dos closures dos timers
      const peerIdRef = useRef(peerId);
      useEffect(() => { peerIdRef.current = peerId; }, [peerId]);

      // Agenda reconexão com backoff – único ponto de entrada para retentativas
      const scheduleReconnect = () => {
        if (isManualDisconnectRef.current) return;
        clearReconnectTimer();

        if (reconnectAttemptsRef.current >= MAX_RECONNECT_ATTEMPTS) {
          console.error(`Circuit-breaker: ${MAX_RECONNECT_ATTEMPTS} tentativas falharam. Desistindo.`);
          setConnectionStatus('errorFatal');
          stopKeepalive();
          return;
        }

        const delay = getBackoffDelay(reconnectAttemptsRef.current);
        reconnectAttemptsRef.current += 1;
        addAudit(`🔄 Reconectando em ${(delay/1000).toFixed(1)}s (tentativa ${reconnectAttemptsRef.current}/${MAX_RECONNECT_ATTEMPTS})`, 'warn');
        setConnectionStatus(`reconnecting (${reconnectAttemptsRef.current}/${MAX_RECONNECT_ATTEMPTS})`);

        reconnectTimerRef.current = setTimeout(() => {
          const p = peerInstance.current;
          if (p && !p.destroyed) {
            try {
              p.reconnect();
              return;
            } catch(e) {
              console.warn("p.reconnect() falhou, recriando peer:", e);
            }
          }
          // Se reconnect() falhar ou peer estiver destruído, recria do zero
          setupPeer();
        }, delay);
      };

      useEffect(() => {
        if (messagesEndRef.current) {
          messagesEndRef.current.scrollIntoView({ behavior: "smooth" });
        }
      }, [messages]);

      const toggleConnection = () => {
        if (connectionStatus === 'connected' || connectionStatus.startsWith('reconnecting') || connectionStatus === 'connecting') {
          disconnectPeer();
        } else {
          isManualDisconnectRef.current = false;
          reconnectAttemptsRef.current = 0;
          setupPeer();
        }
      };

      const disconnectPeer = () => {
        isManualDisconnectRef.current = true; // impede reconexão automática
        clearReconnectTimer();
        stopKeepalive();
        if (peerInstance.current) {
          try {
            // desconexão manual
            activeConnectionsRef.current.forEach((conn) => {
              try { conn.close(); } catch (e) {}
            });
            activeConnectionsRef.current.clear();
            setConnections([]);
            peerInstance.current.destroy();
            peerInstance.current = null;
            setConnectionStatus('disconnected');
            setStats({ messagesReceived: 0, messagesDistributed: 0, activeConnections: 0, hydraNodes: 0 });
            // peer destruído com sucesso
          } catch (err) {
            console.error("Erro ao desconectar peer:", err);
          }
        }
      };

      const setupPeer = () => {
        // BUG S-1 FIX: usamos peerIdRef.current em vez de peerId (closure) para que
        // handleIdChange funcione corretamente após setPeerId() assincrônico.
        const currentId = peerIdRef.current;
        if (!currentId) return;
        if (isManualDisconnectRef.current) return; // respeita desconexão manual

        // setupPeer: currentId carregado
        setConnectionStatus('connecting');
        stopKeepalive();
        clearReconnectTimer();
        
        if (peerInstance.current) {
          try { peerInstance.current.destroy(); } catch (err) {}
          peerInstance.current = null;
        }
        
        const peer = new Peer(currentId, {
          host: '0.peerjs.com',
          port: 443,
          secure: true,
          pingInterval: 5000, // PeerJS interno: ping a cada 5s
          config: {
            iceServers: [
              { urls: 'stun:stun.l.google.com:19302' },
              { urls: 'stun:stun1.l.google.com:19302' },
              { urls: 'stun:stun2.l.google.com:19302' },
              { urls: 'stun:stun3.l.google.com:19302' },
              // ⚠️ BUG-4 WARNING: These are public demo TURN credentials with no SLA.
              // Voice/video calls behind strict NAT may fail in production.
              // For reliability, replace with your own credentials:
              // Free tier: https://dashboard.metered.ca/  (sign up → create app → copy credentials)
              { urls: 'turn:openrelay.metered.ca:80',                username: 'openrelayproject', credential: 'openrelayproject' },
              { urls: 'turn:openrelay.metered.ca:443',               username: 'openrelayproject', credential: 'openrelayproject' },
              { urls: 'turn:openrelay.metered.ca:443?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' },
              { urls: 'turn:openrelay.metered.ca:80?transport=tcp',  username: 'openrelayproject', credential: 'openrelayproject' }
            ]
          },
          debug: 1
        });

        peer.on('open', (id) => {
          reconnectAttemptsRef.current = 0; // reset do circuit-breaker ao conectar
          setConnectionStatus('connected');
          addAudit(`✅ Servidor online: ${id}`, 'ok');
          startKeepalive();
          
          // FIX: usa ref para evitar stale closure – knownServers pode estar desatualizado
          knownServersRef.current.forEach(serverId => {
            if (serverId !== id) {
              addAudit(`🔗 Auto-conectando a: ${serverId}`, 'info');
              const conn = peer.connect(serverId);
              setupConnection(conn);
            }
          });
        });

        peer.on('connection', (conn) => {
          // FIX-AUDIT-SRV-HYDRA: cap de conexões também no modo Hydra
          // Sem este guard, modo Hydra aceitava conexões ilimitadas → DoS por esgotamento de memória
          const MAX_HYDRA_CONNECTIONS = 500; // Hydra suporta mais pois fecha em 2s
          const MAX_SERVER_CONNECTIONS = 200;

          if (isHydraModeRef.current) {
            if (recentPeersRef.current.length >= MAX_HYDRA_CONNECTIONS) {
              setTimeout(() => { try { conn.close(); } catch (e) {} }, 200);
              return;
            }
            setupConnection(conn);
            return;
          }

          if (activeConnectionsRef.current.size >= MAX_SERVER_CONNECTIONS) {
            setTimeout(() => { try { conn.close(); } catch (e) {} }, 500);
            return;
          }
          
          setupConnection(conn);
        });

        // ── Tratamento robusto de erros ──────────────────────────────────
        peer.on('error', (err) => {
          console.error("Erro no peer:", err.type, err);
          addAudit(`❌ Erro PeerJS: ${err.type}`, 'err');

          // Erros FATAIS: não adianta reconectar com o mesmo ID
          if (err.type === 'unavailable-id' || err.type === 'invalid-id') {
            setConnectionStatus('errorIdUnavailable');
            console.error("ID já em uso ou inválido. Altere o ID e tente novamente.");
            addAudit('⛔ ID indisponível ou inválido — altere o ID', 'err');
            stopKeepalive();
            return;
          }

          // Erros de peer remoto não afetam o servidor em si
          if (err.type === 'peer-unavailable') {
            console.warn("Peer remoto indisponível:", err.message);
            addAudit(`⚠️ Peer remoto indisponível: ${err.message}`, 'warn');
            return; // não reconecta – o servidor continua de pé
          }

          // Erros de REDE / SERVIDOR – reconecta automaticamente
          setConnectionStatus('error');
          if (!isManualDisconnectRef.current) {
            scheduleReconnect();
          }
        });

        // Sinalização desconectou (não o peer em si) – tenta reconectar
        peer.on('disconnected', () => {
          if (isManualDisconnectRef.current) return;
          // sinalização perdida — scheduleReconnect
          addAudit('⚠️ Sinalização perdida — reconectando…', 'warn');
          setConnectionStatus('reconnecting');
          scheduleReconnect();
        });

        // Peer completamente fechado (raro, mas tratado)
        peer.on('close', () => {
          if (isManualDisconnectRef.current) return;
          console.warn("Peer fechou completamente. Recriando...");
          addAudit('🔄 Peer fechou — recriando…', 'warn');
          stopKeepalive();
          peerInstance.current = null;
          scheduleReconnect();
        });

        peerInstance.current = peer;
      };

      // ── Reconecta quando a internet voltar ──────────────────────────────
      useEffect(() => {
        const handleOnline = () => {
          // rede online
          if (!isManualDisconnectRef.current) {
            const p = peerInstance.current;
            const isOk = p && !p.destroyed && !p.disconnected;
            if (!isOk) {
              // reconectando após rede voltar
              reconnectAttemptsRef.current = 0;
              setupPeer();
            }
          }
        };
        window.addEventListener('online', handleOnline);
        return () => window.removeEventListener('online', handleOnline);
      }, [peerId]);

      useEffect(() => {
        // Monitora saúde da conexão a cada 15s – funciona em TODOS os estados (inclusive 'error')
        // FIX BUG-1: guards now use the same English strings that setConnectionStatus() actually writes
        if (connectionStatus === 'disconnected' || connectionStatus === 'errorFatal') return;
        
        const checkConnectionInterval = setInterval(() => {
          const p = peerInstance.current;

          // Se estiver no estado 'error' aguarda o scheduleReconnect atuar
          if (connectionStatus.startsWith('error')) return;

          if (p && p.disconnected && !p.destroyed) {
            // monitor: peer desconectado
            if (!isManualDisconnectRef.current) scheduleReconnect();
          }
          
          // Limpeza de heartbeats antigos (> 45s)
          const now = Date.now();
          let changed = false;
          heartbeatsRef.current.forEach((time, id) => {
            if (now - time > 45000) {
              heartbeatsRef.current.delete(id);
              worldQuizNodesRef.current.delete(id);
              changed = true;
            }
          });
          if (changed) setStats(prev => ({ ...prev, hydraNodes: heartbeatsRef.current.size }));
          
          // Broadcast de estatísticas para todos os conectados
          const statsMsg = {
            type: 'network-stats',
            totalOnline: heartbeatsRef.current.size,
            timestamp: now,
            worldQuizNodes: Array.from(worldQuizNodesRef.current)
          };
          activeConnectionsRef.current.forEach(conn => { try { conn.send(statsMsg); } catch(e) {} });
          
        }, 15000);

        return () => clearInterval(checkConnectionInterval);
      }, [connectionStatus]);

      const handleIdChange = (newId) => {
        disconnectPeer();
        // Após limpar, reconecta automaticamente com o novo ID
        setTimeout(() => {
          isManualDisconnectRef.current = false;
          reconnectAttemptsRef.current = 0;
          setupPeer();
        }, 600);
      };

      const broadcastMyYoutubeVideo = () => {
        const url = prompt('Digite a URL do vídeo do YouTube para transmitir:');
        if (!url) return;
        
        let finalYoutubeId = '';
        try {
          const parsedUrl = new URL(url);
          if (parsedUrl.hostname === 'youtu.be') {
            finalYoutubeId = parsedUrl.pathname.slice(1);
          } else if (parsedUrl.hostname.includes('youtube.com')) {
            if (parsedUrl.pathname === '/playlist') {
              const list = parsedUrl.searchParams.get('list');
              if (list) finalYoutubeId = `playlist:${list}`;
            } else if (parsedUrl.pathname === '/watch') {
              const v = parsedUrl.searchParams.get('v');
              const list = parsedUrl.searchParams.get('list');
              if (list) {
                finalYoutubeId = `playlist:${list}`;
              } else if (v) {
                finalYoutubeId = v;
              }
            } else if (parsedUrl.pathname.startsWith('/embed/')) {
              finalYoutubeId = parsedUrl.pathname.split('/')[2];
            }
          }
        } catch (e) {}

        if (!finalYoutubeId) {
          const regExp = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]*).*/;
          const match = url.match(regExp);
          if (match && match[2].length === 11) {
            finalYoutubeId = match[2];
          }
        }

        if (!finalYoutubeId) {
          alert('URL do YouTube inválida');
          return;
        }

        const serverId = peerInstance.current ? peerInstance.current.id : 'SERVER';
        const startTime = Date.now() + 5000; // 5s delay for sync
        const duration = 300; // 5 minutes limit
        const radioId = serverId + '_yt_' + Date.now();
        const msg = { 
          type: 'radio-youtube-start', 
          id: radioId + '_start', 
          radioId,
          youtubeId: finalYoutubeId, 
          startTime,
          duration,
          sender: serverId,
          senderName: t(lang, 'serverName'),
          ttl: 15 
        };
        
        setYoutubeBroadcasts(prev => ({ ...prev, [serverId]: { videoId: finalYoutubeId, senderName: t(lang, 'serverName') } }));
        distributeMessage(msg, null);
      };

      const stopMyYoutubeVideo = () => {
        const pId = peerInstance.current ? peerInstance.current.id : 'SERVER';
        const msg = { 
          type: 'radio-youtube-stop', 
          id: pId + '_stop_yt_video_' + Date.now(), 
          sender: pId,
          senderName: t(lang, 'serverName'),
          ttl: 15 
        };
        
        setYoutubeBroadcasts(prev => {
          const next = { ...prev };
          delete next[pId];
          return next;
        });
        distributeMessage(msg, null);
      };

      const handleIncomingData = (data, sourceConn) => {
        // Handle Heartbeat from any user (even if not directly connected long-term)
        if (data && data.type === 'heartbeat') {
          heartbeatsRef.current.set(sourceConn.peer, Date.now());
          if (data.worldQuizAtivo) {
            worldQuizNodesRef.current.add(sourceConn.peer);
          } else {
            worldQuizNodesRef.current.delete(sourceConn.peer);
          }
          setStats(prev => ({
            ...prev,
            hydraNodes: heartbeatsRef.current.size
          }));
          
          // Responde com as estatísticas para que o nó saiba quem são os distribuidores
          try {
            sourceConn.send({
              type: 'network-stats',
              totalOnline: heartbeatsRef.current.size,
              timestamp: Date.now(),
              worldQuizNodes: Array.from(worldQuizNodesRef.current)
            });
          } catch(e) {}
          
          // If it's just a heartbeat and we are in Hydra Mode, we can close the connection to save resources
          if (isHydraModeRef.current) {
            setTimeout(() => {
              try { sourceConn.close(); } catch(e) {}
            }, 1000);
          }
          return;
        }

        // Se estiver no modo Hydra, ignora qualquer mensagem de chat/dados
        if (isHydraModeRef.current) return;

        // FIX-AUDIT-SRV2: log mínimo — não loga conteúdo de mensagens (privacidade)
        // console.log(`[SRV] tipo:${data.type} de:${sourceConn.peer}`);
        
        if (data.type === 'pex') {
          // V23 S-10: PEX comprimido — data.gid (4 chars) + data.users ([2 chars each])
          // Mantém compatibilidade com formato antigo (data.groupId) para transição suave
          const gid = data.gid || data.groupId;
          if (gid) {
            if (!activeGroupsRef.current[gid]) {
              activeGroupsRef.current[gid] = { size: 0, reservados: [], members: new Set(), positions: [] };
            }
            const g = activeGroupsRef.current[gid];
            if (!g.positions) g.positions = [];
            // Reconstrói peerId completo para registrar no members
            if (data.peerId) {
              g.members.add(data.peerId);
            } else if (data.suffix) {
              // V23: sender informa seu sufixo; reconstrói peerId
              g.members.add(buildPeerId(gid, data.suffix));
            }
            // V25: se veio count, atualiza size
            if (data.count !== undefined) {
              g.size = Math.max(g.size, data.count);
            } else if (Array.isArray(data.users)) {
              // Compatibilidade V24: lista comprimida de usuários
              data.users.forEach(s => {
                if (typeof s === 'string' && s.length === K10_SUFFIX_LEN) {
                  g.members.add(buildPeerId(gid, s));
                }
              });
              const reportedSize = data.groupSize !== undefined ? data.groupSize : data.users.length;
              g.size = Math.max(reportedSize, g.members.size);
            }
            if (data.isReservado && (data.peerId || data.suffix)) {
              const reservadoPid = data.peerId || buildPeerId(gid, data.suffix);
              const set = new Set(g.reservados);
              set.add(reservadoPid);
              g.reservados = [...set].slice(0, 10);
            }
          }
          return; // Servidor não precisa processar PEX de clientes além disso
        }

        // V25: pex-update — relay compacto de saída de peer
        // { type:'pex-update', gid, user, ttl, msgId }
        // 'user' = sufixo da última posição que "saiu" → K10_POSITION_LIST.indexOf(user) = nova contagem
        if (data.type === 'pex-update') {
          if (!data.id) data = { ...data, id: data.msgId || (sourceConn.peer + '_pexupd_' + Date.now()) };
          if (seenMessagesRef.current.has(data.id)) return;
          seenMessagesRef.current.add(data.id); pruneSeenSrv();
          // Atualiza contagem local do grupo
          if (data.gid && data.user) {
            const newCount = K10_POSITION_LIST.indexOf(data.user);
            if (newCount >= 0 && activeGroupsRef.current[data.gid]) {
              activeGroupsRef.current[data.gid].size = Math.min(
                activeGroupsRef.current[data.gid].size,
                newCount
              );
            }
          }
          // Relay com TTL decrementado
          if ((data.ttl || 0) > 0) {
            distributeMessage({ ...data, ttl: data.ttl - 1 }, sourceConn.peer);
          }
          return;
        }

        // ═══ V8-BUG#2: directory-announce — servidor escuta para diretório global ═══
        if (data.type === 'directory-announce') {
          if (!data.groupId || typeof data.groupId !== 'string' || data.groupId.length > 50) return;
          if (data.msgId && seenMessagesRef.current.has(data.msgId)) return;
          if (data.msgId) { seenMessagesRef.current.add(data.msgId); pruneSeenSrv(); } // FIX BUG-I
          if (!activeGroupsRef.current[data.groupId]) {
            // FIX-AUDIT-SRV3: sempre inicializa com positions:[] para evitar inconsistência no GC V25
            activeGroupsRef.current[data.groupId] = { size: 0, reservados: [], members: new Set(), positions: [] };
          }
          const g = activeGroupsRef.current[data.groupId];
          if (typeof data.groupSize === 'number' && data.groupSize >= 0 && data.groupSize <= 100000) {
            g.size = Math.max(g.size, data.groupSize, g.members.size);
          }
          if (Array.isArray(data.reservados)) {
            const set = new Set([...g.reservados, ...data.reservados.filter(x => typeof x === 'string').slice(0, 10)]);
            g.reservados = [...set].slice(0, 10);
          }
          // Re-broadcast para outros peers conectados (relay com TTL decrementado)
          const ttl = (data.ttl || 0) - 1;
          if (ttl > 0) {
            const relay = { ...data, ttl };
            activeConnectionsRef.current.forEach((c, pid) => {
              if (pid !== sourceConn.peer && c.open) try { c.send(relay); } catch(e) {}
            });
          }
          return;
        }

        // ═══ V8-BUG#2: group-split / group-merge — servidor relay + atualiza diretório ═══
        if (data.type === 'group-split') {
          addAudit(`[Hydra] Split: ${data.oldGroupId} gerou ${data.newGroupId}`, 'info');
          if (data.msgId && seenMessagesRef.current.has(data.msgId)) return;
          if (data.msgId) { seenMessagesRef.current.add(data.msgId); pruneSeenSrv(); } // FIX BUG-I
          if (data.newGroupId && !activeGroupsRef.current[data.newGroupId]) {
            // FIX-AUDIT-SRV3: positions:[] obrigatório
            activeGroupsRef.current[data.newGroupId] = { size: 0, reservados: Array.isArray(data.migratedReservados) ? data.migratedReservados.slice(0,10) : [], members: new Set(), positions: [] };
          }
          const ttl = (data.ttl || 0) - 1;
          if (ttl > 0) {
            const relay = { ...data, ttl };
            activeConnectionsRef.current.forEach((c, pid) => {
              if (pid !== sourceConn.peer && c.open) try { c.send(relay); } catch(e) {}
            });
          }
          // V24: verifica dominância entre o grupo original e o novo após split
          if (data.oldGroupId && data.newGroupId) {
            setTimeout(() => checkAndPromote(data.oldGroupId, data.newGroupId), 5000);
          }
          return;
        }
        if (data.type === 'group-merge') {
          addAudit(`[Hydra] Merge: ${data.absorbedGroupId} absorvido por ${data.survivingGroupId}`, 'info');
          if (data.msgId && seenMessagesRef.current.has(data.msgId)) return;
          if (data.msgId) { seenMessagesRef.current.add(data.msgId); pruneSeenSrv(); } // FIX BUG-I
          const { survivingGroupId, absorbedGroupId } = data;
          if (survivingGroupId && absorbedGroupId && activeGroupsRef.current[absorbedGroupId]) {
            // FIX-AUDIT-SRV3: positions:[] obrigatório em criação via merge
            const surv = activeGroupsRef.current[survivingGroupId] || (activeGroupsRef.current[survivingGroupId] = { size: 0, reservados: [], members: new Set(), positions: [] });
            const abs = activeGroupsRef.current[absorbedGroupId];
            // merge members
            abs.members.forEach(p => surv.members.add(p));
            const mergedR = new Set([...surv.reservados, ...abs.reservados]);
            surv.reservados = [...mergedR].slice(0, 10);
            // V8: groupSize = MAX (idempotente)
            surv.size = Math.max(surv.size, surv.members.size, (surv.size || 0) + (abs.size || 0));
            // remap peerGroupMap
            abs.members.forEach(p => peerGroupMapRef.current.set(p, survivingGroupId));
            delete activeGroupsRef.current[absorbedGroupId];
          }
          const ttl = (data.ttl || 0) - 1;
          if (ttl > 0) {
            const relay = { ...data, ttl };
            activeConnectionsRef.current.forEach((c, pid) => {
              if (pid !== sourceConn.peer && c.open) try { c.send(relay); } catch(e) {}
            });
          }
          return;
        }

        // V24: gid-promote — relay do servidor para todos os peers
        if (data.type === 'gid-promote') {
          if (data.msgId && seenMessagesRef.current.has(data.msgId)) return;
          if (data.msgId) { seenMessagesRef.current.add(data.msgId); pruneSeenSrv(); }
          addAudit(`[K10-V24] Relay gid-promote: ${data.formerDominantGid} ↔ ${data.formerRecessiveGid}`, 'info');
          const ttlP = (data.ttl || 0) - 1;
          if (ttlP > 0) {
            const relay = { ...data, ttl: ttlP };
            activeConnectionsRef.current.forEach((c, pid) => {
              if (pid !== sourceConn.peer && c.open) try { c.send(relay); } catch(e) {}
            });
          }
          return;
        }

        // V24: pex-family — relay do servidor para peers da família
        if (data.type === 'pex-family') {
          if (!data.prefix || typeof data.prefix !== 'string') return;
          const ttlF = (data.ttl || 0) - 1;
          if (ttlF > 0) {
            const relay = { ...data, ttl: ttlF };
            activeConnectionsRef.current.forEach((c, pid) => {
              if (pid !== sourceConn.peer && c.open) {
                const peerGid = peerGroupMapRef.current.get(pid);
                if (peerGid && peerGid.startsWith(data.prefix)) {
                  try { c.send(relay); } catch(e) {}
                }
              }
            });
          }
          return;
        }

        // ── Quiz Bot: controle de slot único por servidor ────────────────
        if (data.type === 'subscribe-world-quiz') {
          addAudit(`[Quiz] Usuário ${sourceConn.peer} inscrito no Quiz Mundial`, 'info');
          // O servidor apenas repassa essa mensagem para o distribuidor correto
          const distributorConn = activeConnectionsRef.current.get(data.distributorId);
          if (distributorConn) {
            try { distributorConn.send(data); } catch(e) {}
          }
          return;
        }

        if (data.type === 'quiz-bot-start') {
          // Se o SERVIDOR estava transmitindo: cede o controle ao usuário
          // (para timer, limpa estado, mas NÃO anuncia status:false — o owner muda direto)
          if (serverQuizActiveRef.current) {
            serverQuizActiveRef.current = false;
            setServerQuizActive(false);
            if (srvQuizTimerRef.current) { clearTimeout(srvQuizTimerRef.current); srvQuizTimerRef.current = null; }
            srvCurrentQuizRef.current = null;
            // FIX BUG-2: marca timestamp agora para cooldown ficar correto
            // quando/se o servidor retomar depois
            srvLastQuizTimeRef.current = Date.now();
          }
          quizBotPeerRef.current = sourceConn.peer;
          // Notifica TODOS os conectados que o bot está ativo
          activeConnectionsRef.current.forEach((c, id) => {
            try { c.send({ type: 'quiz-bot-status', active: true, owner: sourceConn.peer }); } catch(e) {}
          });
          return;
        }
        if (data.type === 'quiz-bot-stop') {
          if (quizBotPeerRef.current === sourceConn.peer) {
            quizBotPeerRef.current = null;
            activeConnectionsRef.current.forEach((c) => {
              try { c.send({ type: 'quiz-bot-status', active: false }); } catch(e) {}
            });
          }
          return;
        }
        // ── HANDOFF: usuário desligou bot e nos passa o estado pra continuar ──
        if (data.type === 'quiz-handoff') {
          handleQuizHandoff(data, sourceConn.peer);
          return;
        }

        if (data.type === 'message' || data.type === 'torrent-request') {
          if (data.id) {
            if (seenMessagesRef.current.has(data.id)) {
              return; // FIX-AUDIT-SRV: não logar anti-loop, evita spam de log
            }
            seenMessagesRef.current.add(data.id);
            pruneSeenSrv(); // FIX BUG-I: substitui purga manual por pruneSeenSrv() consistente
          }

          if (data.type === 'message') {
            // Role Tracking Global: se é um quiz de um usuário, atualiza cooldown do servidor
            if (data.text === '__QUIZ__' && data.quizPayload) {
              srvLastQuizTimeRef.current = Date.now();
            }
            
            if (data.text && data.text.length > 2000) {
              return; // FIX-AUDIT-SRV: descartar silenciosamente — não logar conteúdo
            }
            setStats(prev => ({
              ...prev,
              messagesReceived: prev.messagesReceived + 1
            }));

            // FIX-AUDIT-SRV5: limitar senderName a 60 chars — previne OOM por string gigante
            const senderName = String(data.senderName || sourceConn.peer).slice(0, 60);
            
            const newMessage = {
              id: data.id || (Date.now() + Math.random().toString(36).substring(2)),
              text: data.text,
              sender: senderName,
              timestamp: new Date().toISOString(),
              source: sourceConn.peer
            };
            
            setMessages(prev => [...prev, newMessage].slice(-100));
          }
          
          distributeMessage(data, sourceConn.peer);
        }
        else if (data.type === 'radio-start' || data.type === 'radio-stream-start' || data.type === 'radio-chunk' || data.type === 'radio-sync' || data.type === 'radio-request-sync') {
          if (!data.id) data = { ...data, id: Date.now() + Math.random().toString(36).substring(2) };
          if (seenMessagesRef.current.has(data.id)) return;
          seenMessagesRef.current.add(data.id); pruneSeenSrv(); // FIX BUG-I
          
          if (data.type === 'radio-start' || data.type === 'radio-stream-start' || data.type === 'radio-sync') {
            radioStateRef.current = {
              status: 'playing',
              radioType: data.type === 'radio-stream-start' || data.radioType === 'stream' ? 'stream' : 'file',
              startTime: data.startTime,
              duration: data.duration,
              fileName: data.fileName,
              senderName: data.senderName,
              streamUrl: data.streamUrl
            };
          }
          
          // O Servidor também atua como um relay para a rádio
          distributeMessage(data, sourceConn.peer);
        }
        else if (data.type === 'audio-start' || data.type === 'audio-chunk') {
          if (data.type === 'audio-start' && data.audioSize > 2 * 1024 * 1024) {
            return; // áudio muito longo — descartado silenciosamente
          }
          // FIX BUG-E: garante ID para dedup sempre funcionar, mesmo em chunks sem ID
          if (!data.id) data = { ...data, id: sourceConn.peer + '_' + data.type + '_' + (data.audioId || '') + '_' + (data.offset || 0) };
          if (seenMessagesRef.current.has(data.id)) return;
          seenMessagesRef.current.add(data.id); pruneSeenSrv(); // FIX BUG-I
          distributeMessage(data, sourceConn.peer);
        }
        else if (data.type === 'file-start' || data.type === 'file-chunk') {
          return; // Servidor só repassa texto, torrents e áudio — arquivos bloqueados
        }
        else if (data.type === 'e2ee-secret' || data.type === 'server-e2ee-invite' || data.type === 'youtube-cam-start' || data.type === 'youtube-cam-stop' || data.type === 'youtube-chat-start' || data.type === 'radio-youtube-start' || data.type === 'radio-youtube-stop' || data.type === 'radio-world-start' || data.type === 'radio-world-stop') {
           // Relay para segredos E2EE, YouTube Cam, YouTube Chat e Radio YouTube
           // FIX BUG-G: garante ID para dedup sempre funcionar
           if (!data.id) data = { ...data, id: sourceConn.peer + '_' + data.type + '_' + Date.now() };
           if (seenMessagesRef.current.has(data.id)) return;
           seenMessagesRef.current.add(data.id); pruneSeenSrv(); // FIX BUG-I
           if (data.type === 'youtube-chat-start') {
             if (youtubeChatIdRef.current) return;
             // FIX-AUDIT-SRV5: valida formato do youtubeId — previne injeção de string maliciosa
             const ytId = String(data.youtubeId || '');
             const validYtId = /^[a-zA-Z0-9_-]{6,50}$/.test(ytId) || /^playlist:[a-zA-Z0-9_-]{6,50}$/.test(ytId);
             if (!validYtId) return;
             setYoutubeChatId(ytId);
           }
           if (data.type === 'radio-youtube-start') {
             setYoutubeBroadcasts(prev => ({ ...prev, [data.sender || sourceConn.peer]: { videoId: data.youtubeId, senderName: data.senderName } }));
           }
           if (data.type === 'radio-youtube-stop') {
             setYoutubeBroadcasts(prev => {
               const next = { ...prev };
               delete next[data.sender || sourceConn.peer];
               return next;
             });
           }
           distributeMessage(data, sourceConn.peer);
        }
        else if (data.type === 'youtube-chat-stop') {
           // FIX BUG-G: garante ID para dedup
           if (!data.id) data = { ...data, id: sourceConn.peer + '_yt_stop_' + Date.now() };
           if (seenMessagesRef.current.has(data.id)) return;
           seenMessagesRef.current.add(data.id); pruneSeenSrv(); // FIX BUG-I
           setYoutubeChatId(null);
           // FIX S-7: relay para todos os outros peers — sem isso, clientes ficavam com aba YT presa
           // porque apenas o servidor limpava o estado, mas nenhum cliente recebia o stop.
           distributeMessage(data, sourceConn.peer);
        }
      };

      const distributeMessage = (data, sourceId) => {
        let distributionCount = 0;
        
        // FIX-AUDIT-SRV1: TTL clampado [0..15] — impede relay amplificado por TTL injetado
        const rawTtl = data.ttl !== undefined ? data.ttl : 8;
        let currentTtl = Math.min(Math.max(0, parseInt(rawTtl) || 0), 15);
        if (currentTtl <= 0) {
          return; // descarta silenciosamente — não loga para não vazar metadados
        }
        
        const relayData = { ...data, ttl: currentTtl - 1 };
        
        activeConnectionsRef.current.forEach((conn, connPeerId) => {
          // BUG S-2 FIX: checa conn.open antes de enviar para evitar erros desnecessários
          if (connPeerId !== sourceId && conn.open) {
            try {
              conn.send(relayData);
              distributionCount++;
            } catch (err) {
              console.error(`Erro ao enviar para ${connPeerId}:`, err);
            }
          }
        });
        
        setStats(prev => ({
          ...prev,
          messagesDistributed: prev.messagesDistributed + distributionCount
        }));
      };

      const setupConnection = (conn) => {
        conn.on('open', () => {
          addAudit(`🔗 Conexão aberta: ${conn.peer}`, 'ok');
          
          if (isHydraModeRef.current) {
            // MODO HYDRA: Apenas envia a lista de peers e desconecta
            if (!recentPeersRef.current.includes(conn.peer)) {
              recentPeersRef.current.push(conn.peer);
              // FASE-1/M1: cap expandido 1.000→5.000; remoção aleatória evita viés temporal
              if (recentPeersRef.current.length > 5000) {
                const idx = Math.floor(Math.random() * recentPeersRef.current.length);
                recentPeersRef.current.splice(idx, 1);
              }
              
              setStats(prev => ({
                ...prev,
                hydraNodes: recentPeersRef.current.length
              }));
            }
            
            // FASE-1/M1: amostra aleatória de 50 – elimina ilhas temporais do slice(-50)
            const filtered = recentPeersRef.current.filter(p => p !== conn.peer);
            const peersToSend = filtered.sort(() => 0.5 - Math.random()).slice(0, 50);
            
            try {
              conn.send({
                type: 'migrate-to-p2p',
                peers: peersToSend,
                message: t(langRef.current, 'hydraModeMessage') // FIX S1
              });
            } catch (err) {}
            
            // Desconecta após enviar a lista para não pesar o servidor
            setTimeout(() => {
              try { conn.close(); } catch(e) {}
            }, 2000);
            return;
          }

          activeConnectionsRef.current.set(conn.peer, conn);
          
          // Informa ao novo peer se já há um Quiz Bot ativo no servidor
          if (quizBotPeerRef.current) {
            try { conn.send({ type: 'quiz-bot-status', active: true, owner: quizBotPeerRef.current }); } catch(e) {}
          }
          
          setConnections(Array.from(activeConnectionsRef.current.keys()));
          
          setStats(prev => ({
            ...prev,
            activeConnections: activeConnectionsRef.current.size,
            hydraNodes: recentPeersRef.current.length
          }));

          // VERIFICA SE ATINGIU O LIMITE PARA VIRAR HYDRA AUTOMATICAMENTE
          if (activeConnectionsRef.current.size >= HYDRA_THRESHOLD && !isHydraModeRef.current) {
            isHydraModeRef.current = true;
            addAudit(`🌊 Modo Hydra ativado — ${activeConnectionsRef.current.size} conexões`, 'warn');
            
            const allPeers = Array.from(activeConnectionsRef.current.keys());
            recentPeersRef.current = [...allPeers]; // Salva os peers atuais no cache do Hydra
            
            // Avisa todos os conectados para formarem a rede P2P
            activeConnectionsRef.current.forEach(c => {
              try {
                c.send({
                  type: 'migrate-to-p2p',
                  peers: allPeers,
                  message: t(langRef.current, 'serverFullMigration') // FIX S1
                });
              } catch (err) {}
            });
            
            // Opcional: O servidor pode fechar as conexões depois de um tempo, 
            // mas os próprios clientes vão se conectar entre si.
            // Para garantir que o servidor fique leve, vamos desconectar todos após 5 segundos.
            setTimeout(() => {
              activeConnectionsRef.current.forEach(c => {
                try { c.close(); } catch(e) {}
              });
              activeConnectionsRef.current.clear();
              setConnections([]);
              setStats(prev => ({ ...prev, activeConnections: 0 }));
            }, 5000);
          }
          
          // FIX S-8 V20: cada send em try-catch individual — falha em handshake não descarta peer-list
          // Always send handshake from server so clients know it's a central server
          try { conn.send({ type: 'handshake', peerId: peerIdRef.current }); } catch(e) {}
          if (youtubeChatIdRef.current) {
            try { conn.send({ type: 'youtube-chat-start', id: Date.now() + Math.random().toString(), youtubeId: youtubeChatIdRef.current, ttl: 0 }); } catch(e) {}
          }

          // ── S-12 V25: Atribuição de GID + sufixo (sistema K10 Posicional) ──
          // Seleciona o grupo com vagas (<1800); se todos cheios, cria filho derivado
          const groups = Object.entries(activeGroupsRef.current);
          let assignedGid = null;

          // Procura grupo com vagas; prefere o mais populoso (agrupa em vez de fragmentar)
          const available = groups.filter(([, g]) => (g.positions || []).length < K10_MAX_GROUP);
          if (available.length > 0) {
            assignedGid = available.reduce((a, b) =>
              (a[1].positions||[]).length > (b[1].positions||[]).length ? a : b
            )[0];
          } else {
            // Todos cheios — deriva novo GID do grupo mais populoso (herança hierárquica)
            const allGids = Object.keys(activeGroupsRef.current);
            const largestGid = allGids.reduce((best, g) =>
              (activeGroupsRef.current[g]?.positions?.length || 0) > (activeGroupsRef.current[best]?.positions?.length || 0) ? g : best
            , allGids[0]);
            assignedGid = generateChildGid(largestGid);
            activeGroupsRef.current[assignedGid] = { size: 0, reservados: [], members: new Set(), positions: [] };
            k10bin.registerGid(assignedGid); // V26: registra novo grupo no registry binário
            addAudit(`[K10-V25] Novo grupo filho ${assignedGid} derivado de ${largestGid}`, 'info');
          }

          // Garante que o grupo existe com positions[]
          if (!activeGroupsRef.current[assignedGid]) {
            activeGroupsRef.current[assignedGid] = { size: 0, reservados: [], members: new Set(), positions: [] };
          }
          if (!activeGroupsRef.current[assignedGid].positions) {
            activeGroupsRef.current[assignedGid].positions = [];
          }

          const assignedGroup = activeGroupsRef.current[assignedGid];
          const posIdx = assignedGroup.positions.length; // próxima posição disponível
          let assignedSuffix = K10_POSITION_LIST[posIdx];

          // Fallback: posIdx fora da lista (não deveria acontecer pois verificamos vagas)
          if (!assignedSuffix) {
            const fallbackGid = generateChildGid(assignedGid);
            activeGroupsRef.current[fallbackGid] = { size: 0, reservados: [], members: new Set(), positions: [] };
            k10bin.registerGid(fallbackGid); // V26
            assignedGid = fallbackGid;
            assignedSuffix = K10_POSITION_LIST[0];
            addAudit(`[K10-V25] Fallback hierárquico: novo grupo ${fallbackGid}`, 'warn');
          }

          // Registra o peer no grupo
          activeGroupsRef.current[assignedGid].positions.push(conn.peer);
          activeGroupsRef.current[assignedGid].members.add(conn.peer);
          activeGroupsRef.current[assignedGid].size = activeGroupsRef.current[assignedGid].positions.length;
          peerGroupMapRef.current.set(conn.peer, assignedGid);
          peerPositionMapRef.current.set(conn.peer, { gid: assignedGid, posIdx });

          // V25: peer-list compacto — {gid, user, count}
          // 'user' = sufixo atribuído ao novo peer (K10_POSITION_LIST[posIdx])
          // 'count' = total de membros no grupo
          // O cliente reconstrói quem conectar: K10 + gid + K10_POSITION_LIST[0..count-1]
          // FIX V25-BANDA: removido users:[] — V24 compat mantém só 'suffix' (scalar, não array)
          // V26: gidIdx adicionado — cliente aprende o índice binário do GID nesta mensagem
          const groupCount = activeGroupsRef.current[assignedGid].positions.length;
          const gidIdx = k10bin.getIdx(assignedGid); // V26: índice uint16 do GID
          try {
            conn.send({
              type: 'peer-list',
              gid: assignedGid,            // 4 chars — ID do grupo (texto, para UI)
              gidIdx,                      // V26: índice binário do GID (uint16)
              user: assignedSuffix,         // V25: sufixo atribuído (posição do novo peer)
              count: groupCount,            // V25: total de membros (substitui users:[])
              suffix: assignedSuffix,       // compat V24 mínima (scalar, sem custo)
              // REMOVIDO: users:[N sufixos] — V25 usa K10_POSITION_LIST[0..count-1]
              // Economia total V26: peer-list enviado 1×; eventos seguintes em 7 bytes binários
            });
          } catch(e) { console.warn('[K10-V26] Erro ao enviar peer-list:', e); }

          addAudit(`[K10-V25] Peer ${conn.peer} → grupo ${assignedGid} posição ${posIdx+1}/${groupCount}`, 'ok');

          // V24: se o grupo faz parte de uma família, envia pex-family comprimido
          // para todos os peers da família (informam novos membros uns aos outros)
          try {
            const familyPex = buildFamilyPex(assignedGid);
            if (familyPex) {
              const familyGids = new Set(findGroupFamily(assignedGid));
              activeConnectionsRef.current.forEach((c, pid) => {
                const peerGid = peerGroupMapRef.current.get(pid);
                if (peerGid && familyGids.has(peerGid) && c.open && pid !== conn.peer) {
                  try { c.send(familyPex); } catch(e) {}
                }
              });
              // Envia também para o novo peer (ele precisa conhecer a família)
              try { conn.send(familyPex); } catch(e) {}
            }
          } catch(e) { console.warn('[K10-V24] Erro ao enviar pex-family:', e); }

          // V24: verifica dominância entre grupos irmãos após nova entrada
          try {
            const siblings = findGroupFamily(assignedGid).filter(g => g !== assignedGid);
            siblings.forEach(sibGid => {
              setTimeout(() => checkAndPromote(assignedGid, sibGid), 4000);
            });
          } catch(e) {}

          // Here is the critical change to ensure we operate in pure server mode:
          // We'll send a special message to mark this as a server connection
          // when pure server mode is enabled
          if (pureServerModeRef.current) {
            try {
              conn.send({
                type: 'server-info',
                isServer: true,
                message: t(langRef.current, 'pureServerModeConnected') // FIX S1
              });
            } catch (err) {
              console.error(`Erro ao enviar informação de servidor para ${conn.peer}:`, err);
            }
          }

          // Se a rádio estiver tocando, avisa o novato imediatamente
          if (radioStateRef.current.status === 'playing') {
            const now = Date.now();
            if (radioStateRef.current.radioType === 'stream') {
              // FIX S-11 V22: cada send em try-catch individual — se radio-sync falha, '#$%' não era enviado
              try {
                conn.send({
                  type: 'radio-sync',
                  radioType: 'stream',
                  startTime: radioStateRef.current.startTime,
                  streamUrl: radioStateRef.current.streamUrl,
                  fileName: radioStateRef.current.fileName || t(langRef.current, 'globalRadio'), // FIX S1
                  senderName: radioStateRef.current.senderName || t(langRef.current, 'k10Server') // FIX S1
                });
              } catch (e) {}
              try {
                conn.send({
                  type: 'message',
                  text: '#$%',
                  senderName: t(langRef.current, 'k10Server'), // FIX S1
                  id: 'radio_block_' + Date.now()
                });
              } catch (e) {}
            } else {
              const endTime = radioStateRef.current.startTime + radioStateRef.current.duration * 1000;
              if (now < endTime) {
                // FIX S-12 V22: cada send em try-catch individual — se radio-sync falha, '#$%' não era enviado
                try {
                  conn.send({
                    type: 'radio-sync',
                    radioType: 'file',
                    startTime: radioStateRef.current.startTime,
                    duration: radioStateRef.current.duration,
                    fileName: radioStateRef.current.fileName || t(langRef.current, 'globalRadio'), // FIX S1
                    senderName: radioStateRef.current.senderName || t(langRef.current, 'k10Server') // FIX S1
                  });
                } catch (e) {}
                try {
                  conn.send({
                    type: 'message',
                    text: '#$%',
                    senderName: t(langRef.current, 'k10Server'), // FIX S1
                    id: 'radio_block_' + Date.now()
                  });
                } catch (e) {}
              } else {
                radioStateRef.current.status = 'idle';
              }
            }
          }
        });

        conn.on('data', (data) => {
          handleIncomingData(data, conn);
        });

        conn.on('close', () => {
          addAudit(`🔌 Conexão encerrada: ${conn.peer}`, 'warn');
          
          // Libera slot do Quiz Bot se era o dono
          if (quizBotPeerRef.current === conn.peer) {
            quizBotPeerRef.current = null;
            activeConnectionsRef.current.forEach((c) => {
              try { c.send({ type: 'quiz-bot-status', active: false }); } catch(e) {}
            });
          }
          
          // V25: swap-on-leave — mantém positions[] sempre contíguo
          // Quando peer P sai de um grupo de N:
          //   1. Internamente: último (posição N) ocupa buraco de P
          //   2. Broadcast: anuncia que a ÚLTIMA posição (sufixo N) saiu
          //   → Todos entendem: grupo tinha N, agora tem N-1, sem buracos
          const posInfo = peerPositionMapRef.current.get(conn.peer);
          if (posInfo) {
            const { gid: peerGid, posIdx } = posInfo;
            const group = activeGroupsRef.current[peerGid];
            if (group && group.positions) {
              const oldLen = group.positions.length;
              if (oldLen > 0 && posIdx < oldLen) {
                // O sufixo da última posição será o que anunciamos como "saiu"
                const lastSuffix = K10_POSITION_LIST[oldLen - 1];
                
                if (posIdx < oldLen - 1) {
                  // Peer saiu do MEIO — move o último para o buraco
                  const lastPeer = group.positions[oldLen - 1];
                  group.positions[posIdx] = lastPeer;
                  peerPositionMapRef.current.set(lastPeer, { gid: peerGid, posIdx });
                  // FIX V25-BUG1 / V26: notifica peer movido — position-update BINÁRIO
                  const movedConn = activeConnectionsRef.current.get(lastPeer);
                  if (movedConn && movedConn.open) {
                    const binPosUpd = k10bin.encodePositionUpdate(peerGid, posIdx);
                    const jsonPosUpd = { type: 'position-update', gid: peerGid, user: K10_POSITION_LIST[posIdx] };
                    k10Send(movedConn, binPosUpd, jsonPosUpd);
                  }
                  addAudit(`[K10-V26] Swap: pos${oldLen}(${lastPeer.slice(-2)})→pos${posIdx+1} grupo ${peerGid} [binário]`, 'info');
                }
                group.positions.pop();
                group.members.delete(conn.peer);
                group.size = group.positions.length;

                // V26: pex-update BINÁRIO (7 bytes) — substitui ~65 bytes JSON
                // newCount = group.positions.length (após pop)
                const newCount = group.positions.length;
                const binPexUpd = k10bin.encodePexUpdate(peerGid, newCount, 6);
                const jsonPexUpd = {
                  type: 'pex-update', gid: peerGid, user: lastSuffix, ttl: 6,
                  msgId: Date.now().toString(36) + Math.random().toString(36).slice(2)
                };
                k10BroadcastBinary(binPexUpd, jsonPexUpd, conn.peer);
                addAudit(`[K10-V26] pex-update binário: grupo ${peerGid} → ${newCount} usuários`, 'ok');
              }
            }
            peerPositionMapRef.current.delete(conn.peer);
          } else {
            // Fallback: peer sem posição rastreada (conexão antiga/legada)
            const peerGroupId = peerGroupMapRef.current.get(conn.peer);
            if (peerGroupId && activeGroupsRef.current[peerGroupId]) {
              activeGroupsRef.current[peerGroupId].size = Math.max(0, activeGroupsRef.current[peerGroupId].size - 1);
              activeGroupsRef.current[peerGroupId].members.delete(conn.peer);
            }
          }
          peerGroupMapRef.current.delete(conn.peer);
          
          activeConnectionsRef.current.delete(conn.peer);
          
          setConnections(Array.from(activeConnectionsRef.current.keys()));
          
          setStats(prev => ({
            ...prev,
            activeConnections: activeConnectionsRef.current.size,
            hydraNodes: recentPeersRef.current.length
          }));
        });

        conn.on('error', (err) => {
          addAudit(`⚠️ Erro na conexão ${conn.peer}: ${err?.message || err?.type || 'desconhecido'}`, 'warn');
        });
      };

      
      // ════════════════════════════════════════════════════════════════════
      // SERVIDOR — transmissão do Quiz após handoff (mesmo wire-format)
      // ════════════════════════════════════════════════════════════════════
      const srvSendQuizQuestion = (quizData) => {
        const ts = new Date();
        srvLastQuizTimeRef.current = ts.getTime();
        const wireMsg = {
          type: 'message',
          id: Date.now() + Math.random().toString(36).substring(2),
          ttl: 15,
          // FIX BUG-4: campo sender presente para que o filtro de vigilância
          // identifique corretamente a fonte e não aplique spam ao peerId do servidor
          sender: 'server-self',
          senderName: '🤖 Quiz Bot',
          direct: false,
          time: ts.toLocaleTimeString('en-US'),
          timestamp: ts.getTime(),
          text: '__QUIZ__',
          quizPayload: quizData
        };
        activeConnectionsRef.current.forEach(c => { try { c.send(wireMsg); } catch(e) {} });
      };
      const srvSendQuizReveal = (quizId, votes) => {
        const ts = new Date();
        const wireMsg = {
          type: 'message',
          id: Date.now() + Math.random().toString(36).substring(2),
          ttl: 15,
          // FIX BUG-4: idem — sender explícito
          sender: 'server-self',
          senderName: '🤖 Quiz Bot',
          direct: false,
          time: ts.toLocaleTimeString('en-US'),
          text: '__QUIZ_REVEAL__',
          quizRevealPayload: { quizId, votes: votes || {} }
        };
        activeConnectionsRef.current.forEach(c => { try { c.send(wireMsg); } catch(e) {} });
      };

      const srvNextWorldPlace = () => {
        const i = srvWorldPlaceIdxRef.current % WORLD_PLACES.length;
        srvWorldPlaceIdxRef.current = (srvWorldPlaceIdxRef.current + 1) % WORLD_PLACES.length;
        return WORLD_PLACES[i];
      };

      const srvAskWorldQuestion = async () => {
        if (!serverQuizActiveRef.current) return;
        if (srvQuizTimerRef.current) clearTimeout(srvQuizTimerRef.current);

        const place = srvNextWorldPlace();
        const hit = await srvFetchWorldImage(place.query, srvQuizUsedImagesRef.current);
        const imgUrl = hit ? (hit.largeImageURL || hit.webformatURL) : null;
        const imgId = hit ? hit.id : null;

        const [countryOpts, countryCorrectIdx] = srvBuildAlternatives(ALL_COUNTRIES, place.country);
        const quizId1 = 'quiz-srv-w1-' + Date.now() + '-' + Math.random().toString(36).substring(2);
        const quizData1 = {
          quizId: quizId1,
          quizQuestion: '🌍 Em qual PAÍS fica este lugar famoso?',
          quizOptions: countryOpts,
          quizCorrect: countryCorrectIdx,
          quizSubject: '📸 Lugares do Mundo',
          quizStage: 1,
          quizImage: imgUrl || undefined,
          quizImageId: imgId || undefined,
          nonce: Math.random().toString(36).substring(2, 10)
        };
        srvCurrentQuizRef.current = { ...quizData1, votes: {} };
        srvSendQuizQuestion(quizData1);

        srvQuizTimerRef.current = setTimeout(() => {
          if (!serverQuizActiveRef.current) return;
          srvSendQuizReveal(quizId1, {});
          srvCurrentQuizRef.current = null;

          setTimeout(() => {
            if (!serverQuizActiveRef.current) return;
            const statePool = place.statePool || ALL_COUNTRIES;
            const [stateOpts, stateCorrectIdx] = srvBuildAlternatives(statePool, place.state);
            const quizId2 = 'quiz-srv-w2-' + Date.now() + '-' + Math.random().toString(36).substring(2);
            const quizData2 = {
              quizId: quizId2,
              quizQuestion: '🗺️ Em qual ESTADO ou CIDADE fica este lugar?',
              quizOptions: stateOpts,
              quizCorrect: stateCorrectIdx,
              quizSubject: '📸 Lugares do Mundo',
              quizStage: 2,
              quizImage: imgUrl || undefined,
              nonce: Math.random().toString(36).substring(2, 10)
            };
            srvCurrentQuizRef.current = { ...quizData2, votes: {} };
            srvSendQuizQuestion(quizData2);

            srvQuizTimerRef.current = setTimeout(() => {
              if (!serverQuizActiveRef.current) return;
              srvSendQuizReveal(quizId2, {});
              srvCurrentQuizRef.current = null;
              setTimeout(() => { if (serverQuizActiveRef.current) srvAskNextQuestion(); }, 10000);
            }, srvQuizIntervalRef.current * 1000);
          }, 5000);
        }, srvQuizIntervalRef.current * 1000);
      };

      const srvAskDisciplineQuestion = async () => {
        if (!serverQuizActiveRef.current) return;
        if (srvQuizTimerRef.current) clearTimeout(srvQuizTimerRef.current);

        const ALL_POOL = QUIZ_SUBJECTS.filter(s => s.id !== 'world');
        let subj;
        if (srvQuizDisciplineRef.current === 'all') {
          subj = ALL_POOL[srvQuizAllIdxRef.current % ALL_POOL.length];
          srvQuizAllIdxRef.current = (srvQuizAllIdxRef.current + 1) % ALL_POOL.length;
        } else {
          subj = QUIZ_SUBJECTS.find(s => s.id === srvQuizDisciplineRef.current) || ALL_POOL[0];
        }
        if (!subj || !subj.url) subj = ALL_POOL[0];

        let questions = [];
        try {
          const res = await fetch(subj.url);
          const data = await res.json();
          const arr = Array.isArray(data) ? data : (Object.values(data).find(v => Array.isArray(v)) || []);
          questions = arr.filter(p => p.pergunta && Array.isArray(p.opcoes) && typeof p.correta === 'number');
        } catch(e) { console.warn('Server quiz fetch err', e); }
        if (!questions.length) {
          questions = [
            { pergunta:'Qual a capital do Brasil?', opcoes:['São Paulo','Rio de Janeiro','Brasília','Salvador'], correta:2 }
          ];
        }
        const q = questions[Math.floor(Math.random() * questions.length)];
        const cleanOpts = q.opcoes.map(s => s.replace(/^[A-Fa-f]\)\s*/, '').trim());
        const quizId = 'quiz-srv-' + Date.now() + '-' + Math.random().toString(36).substring(2);
        const quizData = {
          quizId,
          quizQuestion: q.pergunta,
          quizOptions: cleanOpts,
          quizCorrect: q.correta,
          quizSubject: `${subj.emoji} ${subj.name}`,
          quizStage: 0,
          nonce: Math.random().toString(36).substring(2, 10)
        };
        srvCurrentQuizRef.current = { ...quizData, votes: {} };
        srvSendQuizQuestion(quizData);

        srvQuizTimerRef.current = setTimeout(() => {
          if (!serverQuizActiveRef.current) return;
          srvSendQuizReveal(quizId, {});
          srvCurrentQuizRef.current = null;
          setTimeout(() => { if (serverQuizActiveRef.current) srvAskNextQuestion(); }, 15000);
        }, srvQuizIntervalRef.current * 1000);
      };

      const srvAskNextQuestion = async () => {
        if (!serverQuizActiveRef.current) return;
        
        // FIX: Respeita o cooldown global antes de disparar próxima pergunta
        const now = Date.now();
        const elapsed = now - srvLastQuizTimeRef.current;
        const minIntervalMs = SRV_MIN_QUIZ_INTERVAL * 1000;
        
        if (elapsed < minIntervalMs) {
          const wait = minIntervalMs - elapsed + 1000;
          addAudit(`[Quiz] Cooldown ativo: aguardando ${Math.round(wait/1000)}s`, 'info');
          srvQuizTimerRef.current = setTimeout(srvAskNextQuestion, wait);
          return;
        }

        if (srvQuizDisciplineRef.current === 'world') return srvAskWorldQuestion();
        return srvAskDisciplineQuestion();
      };

      // ── Receber HANDOFF: o usuário desligou e entregou o controle ──
      const handleQuizHandoff = (data, fromPeer) => {
        if (serverQuizActiveRef.current) {
          addAudit('[Quiz] Handoff ignorado: servidor já transmite', 'warn');
          return;
        }
        // FIX BUG-3a: se outro peer (não quem enviou) ainda é dono do bot, ignora
        if (quizBotPeerRef.current && quizBotPeerRef.current !== fromPeer && quizBotPeerRef.current !== 'server-self') {
          addAudit(`[Quiz] Handoff ignorado: outro peer (${fromPeer}) já é dono`, 'warn');
          return;
        }
        // Hidrata estado a partir do handoff (URL+ID, sem binário)
        srvQuizDisciplineRef.current = data.quizDiscipline || 'world';
        srvQuizIntervalRef.current = Math.max(SRV_MIN_QUIZ_INTERVAL, data.quizInterval || SRV_MIN_QUIZ_INTERVAL);
        srvQuizUsedImagesRef.current = new Set(data.usedImageIds || []);
        if (data.lastQuizTime) srvLastQuizTimeRef.current = data.lastQuizTime;
        // Hidrata cache de hits Pixabay (já buscados pelo cliente — evita refetch)
        if (data.bufferedHits && typeof data.bufferedHits === 'object') {
          for (const q in data.bufferedHits) {
            if (Array.isArray(data.bufferedHits[q])) {
              _srvImgCache[q] = data.bufferedHits[q].slice(0);
            }
          }
        }
        // Toma posse do slot único (igual quiz-bot-start)
        quizBotPeerRef.current = 'server-self';
        activeConnectionsRef.current.forEach(c => {
          try { c.send({ type: 'quiz-bot-status', active: true, owner: 'server-self' }); } catch(e) {}
        });
        serverQuizActiveRef.current = true;
        setServerQuizActive(true);
        addAudit(`[Quiz] Servidor assumiu Quiz via handoff de ${fromPeer}`, 'ok');

        // FIX BUG-3b: jitter inteligente — espera o cooldown restante + 3s de segurança,
        // evitando que o servidor envie pergunta antes do MIN_QUIZ_INTERVAL do cliente (120s)
        // expirar. Jitter fixo de 1500ms era insuficiente e causava violação de spam.
        const now = Date.now();
        const elapsed = now - srvLastQuizTimeRef.current;
        const minMs = SRV_MIN_QUIZ_INTERVAL * 1000;
        const cooldownRemaining = Math.max(0, minMs - elapsed);
        const jitter = cooldownRemaining + 3000; // 3s extra de folga para mensagens em trânsito
        addAudit(`[Quiz] Handoff jitter: ${Math.round(jitter/1000)}s (cooldown: ${Math.round(cooldownRemaining/1000)}s)`, 'info');
        srvQuizTimerRef.current = setTimeout(() => { if (serverQuizActiveRef.current) srvAskNextQuestion(); }, jitter);
      };

      // ── Botão "Parar Quiz" — só funciona se o servidor está transmitindo ──
      const stopServerQuiz = () => {
        if (!serverQuizActiveRef.current) return;
        serverQuizActiveRef.current = false;
        setServerQuizActive(false);
        if (srvQuizTimerRef.current) { clearTimeout(srvQuizTimerRef.current); srvQuizTimerRef.current = null; }
        srvCurrentQuizRef.current = null;
        if (quizBotPeerRef.current === 'server-self') {
          quizBotPeerRef.current = null;
          activeConnectionsRef.current.forEach(c => {
            try { c.send({ type: 'quiz-bot-status', active: false }); } catch(e) {}
          });
        }
        addAudit('[Quiz] Quiz parado manualmente pelo servidor', 'warn');
      };

      const broadcastYoutubeChat = () => {
        if (youtubeChatId) { alert(t(lang, 'chatAlreadyActive')); return; }
        const url = prompt(t(lang, 'enterYoutubeUrl'));
        if (!url) return;
        let yId = null;
        try {
          let parsedUrl = url;
          if (!parsedUrl.startsWith('http')) parsedUrl = 'https://' + parsedUrl;
          if (parsedUrl.includes('youtu.be/')) yId = parsedUrl.split('youtu.be/')[1].split('?')[0];
          else if (parsedUrl.includes('youtube.com/watch')) yId = new URL(parsedUrl).searchParams.get('v');
          else if (parsedUrl.includes('youtube.com/live/')) yId = parsedUrl.split('youtube.com/live/')[1].split('?')[0];
        } catch (e) {}
        if (!yId) { alert(t(lang, 'invalidYoutubeUrl')); return; }
        
        setYoutubeChatId(yId);
        const msgId = Date.now() + Math.random().toString(36).substring(2);
        // BUG S-4 FIX: adiciona ao seenMessages antes de broadcast para evitar loop de relay
        seenMessagesRef.current.add(msgId);
        pruneSeenSrv();
        const msgData = { type: 'youtube-chat-start', id: msgId, youtubeId: yId, ttl: 15 };
        // BUG S-5 FIX: checa conn.open antes de enviar
        activeConnectionsRef.current.forEach((c) => { if (c.open) try { c.send(msgData); } catch(e){} });
      };

      const stopYoutubeChat = () => {
        setYoutubeChatId(null);
        // BUG S-3 FIX: faltava broadcast do stop para que os clientes
        // saibam que o chat foi encerrado e limpem o tab YouTube.
        const msgId = Date.now() + Math.random().toString(36).substring(2);
        seenMessagesRef.current.add(msgId);
        pruneSeenSrv();
        const msgData = { type: 'youtube-chat-stop', id: msgId, ttl: 8 };
        activeConnectionsRef.current.forEach((c) => { if (c.open) try { c.send(msgData); } catch(e){} });
      };

      return (
        <div>
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '10px' }}>
            <h1 style={{ margin: 0 }}>{t(lang, 'serverTitle')}</h1>
            <div style={{ display: 'flex', gap: '10px' }}>
              <button
                onClick={() => setDarkMode(d => !d)}
                title={t(lang, 'darkMode')}
                style={{
                  padding: '5px 10px',
                  fontSize: '14px',
                  borderRadius: '4px',
                  border: '1px solid #334155',
                  background: darkMode ? '#1e293b' : '#f1f5f9',
                  color: darkMode ? '#e2e8f0' : '#1e293b',
                  cursor: 'pointer'
                }}
              >
                {darkMode ? '☀️' : '🌙'}
              </button>
              <a 
                href="https://andradepsa.github.io/MATEMATICO10/chat/manual.html"
                target="_blank"
                rel="noopener noreferrer"
                style={{
                  padding: '5px 10px',
                  fontSize: '12px',
                  borderRadius: '4px',
                  border: '1px solid #1e3a5f',
                  background: '#1e40af',
                  color: 'white',
                  cursor: 'pointer',
                  fontWeight: 'bold',
                  textDecoration: 'none',
                  display: 'inline-flex',
                  alignItems: 'center'
                }}
              >
                📖 Manual
              </a>
              <button 
                onClick={() => setLang(lang === 'en' ? 'pt' : 'en')}
                style={{
                  padding: '5px 10px',
                  fontSize: '12px',
                  borderRadius: '4px',
                  border: '1px solid #0369a1',
                  background: '#0ea5e9',
                  color: 'white',
                  cursor: 'pointer',
                  fontWeight: 'bold'
                }}
              >
                {t(lang, 'language')}
              </button>
            </div>
          </div>

          <p>{t(lang, 'idDescription1')}</p>
          <p>{t(lang, 'idDescription2')}</p>
          <p>{t(lang, 'idDescription3')}</p>
          <p>{t(lang, 'idDescription4')}</p>
          <div style={{ background: '#f0f9ff', border: '1px solid #bae6fd', padding: '10px', borderRadius: '8px', marginBottom: '15px', fontSize: '13px', color: '#0369a1' }}>
            <i className="fas fa-info-circle"></i> {t(lang, 'ytChatExplanation')}
          </div>
          <div className="peer-id-container">
            <div style={{ display: 'flex', alignItems: 'center', gap: '10px', flexWrap: 'wrap' }}>
              <span className={`connection-badge ${
                connectionStatus === 'connected' ? 'connected' :
                (connectionStatus === 'connecting' || connectionStatus.startsWith('reconnecting')) ? 'connecting' :
                (connectionStatus.startsWith('error') && connectionStatus !== 'errorFatal') ? 'connecting' :
                'disconnected'
              }`}>
                <span className={`status-indicator status-${
                  connectionStatus === 'connected' ? 'online' :
                  (connectionStatus === 'connecting' || connectionStatus.startsWith('reconnecting')) ? 'connecting' : 'offline'
                }`}></span>
                {t(lang, 'status')} {t(lang, connectionStatus.split(' ')[0])} {connectionStatus.includes('(') ? connectionStatus.substring(connectionStatus.indexOf('(')) : ''}
              </span>
              <button onClick={toggleConnection} style={{ background: (connectionStatus === 'connected' || connectionStatus.startsWith('reconnecting')) ? '#ef4444' : '#4CAF50' }}>
                {connectionStatus === 'connected' || connectionStatus === 'connecting' || connectionStatus.startsWith('reconnecting') ? t(lang, 'disconnect') : t(lang, 'connect')}
              </button>
              {connectionStatus === 'errorFatal' && (
                <button onClick={() => { reconnectAttemptsRef.current = 0; isManualDisconnectRef.current = false; setupPeer(); }} style={{ background: '#ef4444', marginLeft: 8 }}>
                  {t(lang, 'forceReconnect')}
                </button>
              )}
            </div>
          </div>
          
          <IdBackupTools 
            peerId={peerId} 
            setPeerId={setPeerId} 
            onSaveId={handleIdChange} 
            isConnected={connectionStatus === 'connected' || connectionStatus === 'connecting' || connectionStatus.startsWith('reconnecting')}
            lang={lang}
          />
          
          {/* New component for controlling server mode */}
          <div className="server-mode-container">
            <div style={{ display: 'flex', alignItems: 'center', gap: '10px', flex: 1 }}>
              <strong>{t(lang, 'pureServerMode')}</strong>
              <input 
                type="checkbox" 
                checked={pureServerMode} 
                onChange={(e) => {
                  setPureServerMode(e.target.checked);
                  if (connectionStatus === 'connected') {
                    disconnectPeer();
                    setTimeout(setupPeer, 500);
                  }
                }} 
                id="serverModeCheckbox"
              />
              <label htmlFor="serverModeCheckbox">
                {t(lang, 'activatePureServer')}
              </label>
            </div>
            <div style={{ display: 'flex', gap: '10px' }}>
              <button onClick={broadcastYoutubeChat} disabled={Boolean(youtubeChatId)} style={{ backgroundColor: youtubeChatId ? '#cccccc' : '#eab308', cursor: youtubeChatId ? 'not-allowed' : 'pointer', color: youtubeChatId ? '#666666' : 'black' }}>
                <i className="fab fa-youtube"></i> {t(lang, 'startYoutubeChat')}
              </button>
              {youtubeChatId && (
                <button onClick={stopYoutubeChat} style={{ backgroundColor: '#ef4444' }}>
                  <i className="fas fa-times"></i> {t(lang, 'stopYoutubeChat')}
                </button>
              )}
              {serverQuizActive && (
                <button onClick={stopServerQuiz} style={{ backgroundColor: '#dc2626', color: 'white', fontWeight: 'bold' }} title={t(lang, 'quizActiveOnServer')}>
                  <i className="fas fa-robot"></i> {t(lang, 'stopQuiz')}
                </button>
              )}
            </div>
          </div>

          <div className="server-mode-container">
            <div style={{ display: 'flex', alignItems: 'center', gap: '10px', flex: 1 }}>
              <strong>{t(lang, 'connectToOtherServer')}</strong>
              <input 
                type="text" 
                value={newServerId} 
                onChange={(e) => setNewServerId(e.target.value)} 
                placeholder={t(lang, 'serverIdPlaceholder')}
              />
              <button onClick={() => {
                if (newServerId && newServerId !== peerId) {
                  setKnownServers(prev => {
                    const updated = [...new Set([...prev, newServerId])];
                    localStorage.setItem('knownServers', JSON.stringify(updated));
                    return updated;
                  });
                  if (peerInstance.current) {
                    const conn = peerInstance.current.connect(newServerId);
                    setupConnection(conn);
                  }
                  setNewServerId('');
                } else if (newServerId === peerId) {
                  alert(t(lang, 'serverSelfAdd'));
                }
              }}>{t(lang, 'connect')}</button>
            </div>
          </div>
          
          <div className="server-mode-container">
            <strong>{t(lang, 'knownServers')}</strong>
            {knownServers.map(id => (
              <span key={id} style={{ background: '#e2e8f0', padding: '2px 8px', borderRadius: '4px', margin: '0 5px' }}>
                {id} <button onClick={() => {
                  setKnownServers(prev => {
                    const updated = prev.filter(s => s !== id);
                    localStorage.setItem('knownServers', JSON.stringify(updated));
                    return updated;
                  });
                }}>x</button>
              </span>
            ))}
          </div>
          
          <div className="distribution-stats">
            <h3>{t(lang, 'distributionStats')}</h3>
            <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(150px, 1fr))', gap: '10px' }}>
              <div style={{ background: '#f8fafc', padding: '10px', borderRadius: '8px', border: '1px solid #e2e8f0' }}>
                <div style={{ fontSize: '10px', color: '#64748b', textTransform: 'uppercase' }}>{t(lang, 'messagesReceived')}</div>
                <div style={{ fontSize: '18px', fontWeight: 'bold' }}>{stats.messagesReceived}</div>
              </div>
              <div style={{ background: '#f8fafc', padding: '10px', borderRadius: '8px', border: '1px solid #e2e8f0' }}>
                <div style={{ fontSize: '10px', color: '#64748b', textTransform: 'uppercase' }}>{t(lang, 'messagesDistributed')}</div>
                <div style={{ fontSize: '18px', fontWeight: 'bold' }}>{stats.messagesDistributed}</div>
              </div>
              <div style={{ background: '#f8fafc', padding: '10px', borderRadius: '8px', border: '1px solid #e2e8f0' }}>
                <div style={{ fontSize: '10px', color: '#64748b', textTransform: 'uppercase' }}>{t(lang, 'activeConnections')}</div>
                <div style={{ fontSize: '18px', fontWeight: 'bold', color: '#3b82f6' }}>{stats.activeConnections}</div>
              </div>
              <div style={{ background: '#f0fdf4', padding: '10px', borderRadius: '8px', border: '1px solid #bbf7d0' }}>
                <div style={{ fontSize: '10px', color: '#166534', textTransform: 'uppercase' }}>{t(lang, 'hydraWebSize')}</div>
                <div style={{ fontSize: '18px', fontWeight: 'bold', color: '#15803d' }}>{stats.hydraNodes}</div>
                <div style={{ fontSize: '9px', color: '#166534' }}>{t(lang, 'estimatedP2PNodes')}</div>
              </div>
            </div>
          </div>
          
          <div className="connected-peers">
            <h3>{t(lang, 'activeConnections')} ({connections.length})</h3>
            {connections.length === 0 ? (
              <p>{t(lang, 'noActiveConnections')}</p>
            ) : (
              <div>
                {connections.map((connPeerId, index) => (
                 <div key={index} className="peer-item">
                    <span className="status-indicator status-online"></span>
                    {connPeerId}
                  </div>
                ))}
              </div>
            )}
          </div>

          <div style={{ marginTop: '20px' }}>
            <h3>{t(lang, 'messages')}</h3>
            <div style={{ maxHeight: '300px', overflowY: 'auto', border: '1px solid #ddd', padding: '10px' }}>
              {messages.length === 0 ? (
                <p>{t(lang, 'noMessagesReceived')}</p>
              ) : (
                <div>
                  {messages.map((msg, index) => (
                    <div key={index} className={`message other`}>
                      <div>{msg.text}</div>
                      <div className="message-source">
                        {t(lang, 'origin')} {msg.source} | {new Date(msg.timestamp).toLocaleTimeString()}
                      </div>
                    </div>
                  ))}
                  <div ref={messagesEndRef} />
                </div>
              )}
            </div>
          </div>

          {/* ── AUDIT LOG ── */}
          <div style={{ marginTop: '20px' }}>
            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '6px' }}>
              <h3 style={{ margin: 0, fontSize: '13px' }}>📋 Audit Log</h3>
              <button onClick={() => { auditLogRef.current = []; setAuditLog([]); }} style={{ fontSize: '11px', padding: '3px 8px', background: '#ef4444', color: 'white', border: 'none', borderRadius: '4px', cursor: 'pointer' }}>
                {t(lang, 'clearAuditLog')}
              </button>
            </div>
            <div className="audit-log">
              {auditLog.length === 0
                ? <span style={{ color: '#94a3b8', fontSize: '11px' }}>{t(lang, 'noAuditEvents')}</span>
                : auditLog.map((e, i) => (
                  <div key={i} className="audit-entry">
                    <span className="audit-ts">{e.ts}</span>
                    <span className={`audit-msg ${e.type}`}>{e.msg}</span>
                  </div>
                ))
              }
            </div>
          </div>
        </div>
      );
    };

    ReactDOM.createRoot(document.getElementById('root')).render(<DistributorApp />);
  </script>
  <script>
    (async () => {
      try {
        await esbuild.initialize({ wasmURL: 'https://cdn.jsdelivr.net/npm/esbuild-wasm@0.20.1/esbuild.wasm' });
        const script = document.getElementById('esbuild-main').textContent;
        const { code } = await esbuild.transform(script, { loader: 'tsx', target: 'esnext' });
        const s = document.createElement('script');
        s.textContent = code;
        document.body.appendChild(s);
      } catch (e) {
        console.error('Esbuild error:', e);
        document.getElementById('k10-loading').innerHTML = '<p style="color:red;text-align:center;margin-top:20px">Erro ao carregar o servidor. Por favor, recarregue a página.</p>';
      }
    })();
  </script>
</body>
</html>