vimp-engine 0.35.6 → 0.37.0

package/src/client/main.js

@@ -50,6 +50,7 @@ import { dispatchSocketMessage } from './lib/socketDispatch.js';
 import { pickActiveGame, isGameAvailable } from './lib/pickActiveGame.js';
 import { readCoreAbi, dispatchCoreOp, ABI_UNKNOWN } from '../lib/coreAbi.js';
 import { ABI_OP_DEBUG_JSON } from '../config/abiOps.js';
+import engineChatMessages from '../config/chatMessages.js';
 import { createDebugApi, debugLog, DEBUG_PREFIX } from './debug.js';
 import { buildClientCoreConfig } from '../lib/clientCoreConfig.js';
 import { buildSnapshotKeysById } from '../lib/reconstructHot.js';
@@ -59,14 +60,17 @@ import { sanitizeMessage } from '../lib/sanitizers.js';
 import { validateAuth } from '../lib/validators.js';
 import SoundManager from './SoundManager.js';
 import SignalingClient from './network/SignalingClient.js';
-import WebRtcManager from './network/WebRtcManager.js';
-import HostController from './network/HostController.js';
-import HostConnectionManager from './network/HostConnectionManager.js';
 import LoopbackTransport from './network/LoopbackTransport.js';
 import WebSocketTransport from './network/WebSocketTransport.js';
 import InlineHostBridge from './network/InlineHostBridge.js';
-import { supportsModuleWorker } from './network/workerSupport.js';
+import SessionSupervisor, {
+  SESSION_STATES,
+} from './network/SessionSupervisor.js';
+import FpsMeter from './lib/FpsMeter.js';
+import HostUnloadGuard from './lib/hostUnloadGuard.js';
+import { createPageReload } from './lib/pageReload.js';
 import {
+  isKickClose,
   POLICY_CLOSE_INFORMS,
   shouldReloadAfterClose,
 } from './network/policyClose.js';
@@ -79,13 +83,38 @@ import LobbyAuthCtrl from './components/controller/LobbyAuth.js';
 import GamesModel from './components/model/Games.js';
 import GamesView from './components/view/Games.js';
 import GamesCtrl from './components/controller/Games.js';
+import { createRoomContext } from './session/roomContext.js';
+import { createHostRoomPrep } from './session/hostRoomPrep.js';
+import Membership from './session/Membership.js';
+import StandbyRole from './session/StandbyRole.js';
+import HostRole from './session/HostRole.js';
+import HandoffFlow from './session/HandoffFlow.js';
+import PromotionFlow from './session/PromotionFlow.js';
+import GuestSession from './session/GuestSession.js';
+import RouteBoot from './session/RouteBoot.js';
 import ClientReportsModel from './components/model/ClientReports.js';
 import ClientReportsView from './components/view/ClientReports.js';
 import ClientReportsCtrl from './components/controller/ClientReports.js';
+import RoomMenuModel from './components/model/RoomMenu.js';
+import RoomMenuView from './components/view/RoomMenu.js';
+import RoomMenuCtrl from './components/controller/RoomMenu.js';
+import {
+  absoluteLink,
+  decideExitRoute,
+  formatGameLink,
+  formatRoomLink,
+  setRoute,
+} from './lib/roomLink.js';
+import {
+  CHANGE_HOST_VOTE,
+  answerValue,
+  parseChangeHost,
+} from './lib/hostVoteCommand.js';
 import BakingProvider from './providers/BakingProvider.js';
 import DependencyProvider from './providers/DependencyProvider.js';
 import wsports from '../config/wsports.js';
 import GAME_CODES from '../config/gameCodes.js';
+import { buildSystemMessage } from '../host/meta/modules/chat/systemMessages.js';
 import {
   fetchGamesManifest,
   fetchGameManifest as fetchGamePluginManifest,
@@ -154,7 +183,9 @@ const isLobbyMode = bootMode === 'lobby';
 // свой бокс; SDK (solo) — только если встраивающий передал reportUrl
 const diagnostics = createDiagnostics({
   url:
-    bootMode === 'solo' ? (boot.reportUrl ?? null) : lobbyConfig.clientReportUrl,
+    bootMode === 'solo'
+      ? (boot.reportUrl ?? null)
+      : lobbyConfig.clientReportUrl,
   context: {
     mode: bootMode,
     role: 'client',
@@ -253,6 +284,8 @@ const PS_CHAT_DATA = wsports.server.CHAT_DATA;
 const PS_VOTE_DATA = wsports.server.VOTE_DATA;
 const PS_KEYSET_DATA = wsports.server.KEYSET_DATA;
 const PS_ACCOLADES_DATA = wsports.server.ACCOLADES_DATA;
+const PS_SESSION_DATA = wsports.server.SESSION_DATA;
+const PS_RESUME_RESULT = wsports.server.RESUME_RESULT;
 
 // PC (client ports): порты получения данных от клиента
 const PC_CONFIG_READY = wsports.client.CONFIG_READY;
@@ -264,6 +297,7 @@ const PC_KEYS_DATA = wsports.client.KEYS_DATA;
 const PC_CHAT_DATA = wsports.client.CHAT_DATA;
 const PC_VOTE_DATA = wsports.client.VOTE_DATA;
 const PC_PONG = wsports.client.PONG;
+const PC_LEAVE = wsports.client.LEAVE;
 
 // сигнальный WebSocket мастера (лобби + установка P2P); игровой трафик идёт
 // по WebRTC (transport), не через мастер
@@ -273,12 +307,14 @@ const signaling = isLobbyMode
   ? new SignalingClient(`${wsProtocol}//${location.host}/`)
   : null;
 
-// активное P2P-соединение с хостом (создаётся при выборе сервера в лобби)
-let transport = null;
+// супервизор сессии (host-migration этап 4): держит текущий транспорт к
+// хосту и переживает его обрыв — переподключается и возвращает место в
+// матче. Создаётся при входе в комнату (или в solo/dedicated-матч)
+let supervisor = null;
 
-// hostId комнаты, к которой подключён гость (для /like·/unlike напрямую
-// мастеру). У хоста-игрока (своя вкладка) остаётся null — за себя не проголосовать
-let currentHostId = null;
+// оверлей «Reconnecting…» на время переподключения (только лобби-режим)
+const sessionOverlay = document.getElementById('session-overlay');
+const sessionOverlayText = document.getElementById('session-overlay-text');
 
 const modules = {};
 
@@ -332,6 +368,9 @@ const GAME_ROUND_START_CODE = GAME_CODES.roundStart[0];
 // показан ли терминальный tech-код (кик, полная комната): причина закрытия
 // соединения важнее общего сообщения handleDisconnect
 let terminalInformShown = false;
+// ключ последнего терминального tech-кода: по нему лобби-режим отличает кик
+// (policyClose.isKickClose) от закрытия комнаты — в P2P кода закрытия нет
+let terminalTechKey = null;
 // снятие предыдущего animationend-листенера логотипа при повторном
 // playLogoRoundStart — иначе листенеры копятся при частых стартах раунда
 let logoAnimationEndHandler = null;
@@ -342,6 +381,10 @@ let entitiesOnCanvas = {}; // сущности, отображаемые на п
 let currentMapSetId; // текущий id набора конструкторов для карт
 const socketMethods = []; // методы для обработки сокет-данных
 
+// модули матча запущены (AUTH_RESULT без ошибки): повторный успешный
+// AUTH_RESULT в живой сессии — ошибка протокола
+let sessionStarted = false;
+
 // клиентское ядро (WASM, срез 2.6): интерполяция снапшотов, предикт своего
 // танка, визуальный спавн выстрелов и распаковка кадров v3 — создаётся при
 // получении конфига; wasm — результат init() для zero-copy чтения памяти
@@ -371,6 +414,13 @@ let snapshotKeysById = null;
 
 // config data
 socketMethods[PS_CONFIG_DATA] = async data => {
+  // повторное рукопожатие в живой сессии (например, хост не понял resume)
+  // построило бы второе ядро и второй Application поверх первых
+  if (clientCore) {
+    handleProtocolError('CONFIG_DATA');
+    return;
+  }
+
   gameSets = data.parts.gameSets;
   entitiesOnCanvas = data.parts.entitiesOnCanvas;
 
@@ -587,6 +637,12 @@ socketMethods[PS_AUTH_RESULT] = async err => {
   }
 
   if (!err) {
+    if (sessionStarted) {
+      handleProtocolError('AUTH_RESULT');
+      return;
+    }
+
+    sessionStarted = true;
     await soundManager.init(soundData);
     runModules(modulesConfig);
     document.addEventListener('visibilitychange', handleVisibilityChange);
@@ -599,13 +655,33 @@ socketMethods[PS_AUTH_RESULT] = async err => {
       }
     }
 
+    roomMenu?.setInPanel(initIdList.includes('panel'));
+
     sending(PC_MODULES_READY);
+
+    // вход в комнату состоялся — мастер узнаёт состав комнаты от участника
+    // (хост — участник своей комнаты с register_host)
+    if (roomCtx.roomId && !hostRole.controller) {
+      membership.sendJoinRoom();
+    }
   }
 };
 
 // map data
 socketMethods[PS_MAP_DATA] = data => {
   lastMapData = data;
+
+  // карта пакета возобновления (host-migration): участник уже в матче —
+  // это не загрузка (setLoading закончил бы пакет), MAP_READY хост не ждёт.
+  // Признак — метка хоста, не supervisor.resuming: неготовому участнику
+  // (карта сменилась за паузу) хост в том же окне шлёт обычную загрузку
+  if (data?.resume === true) {
+    applyMapData(data, { notifyHost: false });
+    return;
+  }
+
+  // хост законно молчит до первого кадра новой карты (сторожок тишины)
+  supervisor?.setLoading(true);
   applyMapData(data);
 };
 
@@ -751,9 +827,17 @@ socketMethods[PS_FIRST_SHOT_DATA] = data => {
   const [game, camera] = data;
 
   applyShot(game, camera);
+  supervisor?.setLoading(false);
+
+  // кадр пакета возобновления (host-migration этап 4): участник уже в
+  // матче — подтверждать нечего, разовый автостарт уже отработал
+  if (supervisor?.resuming) {
+    return;
+  }
 
   // подтверждение получения первого шота
   sending(PC_FIRST_SHOT_READY);
+  supervisor?.enterGame();
 
   // solo: выход из наблюдателей и чат-команды игры (боты) — см. autostart.js
   runAutostart();
@@ -877,6 +961,7 @@ socketMethods[PS_TECH_INFORM_DATA] = data => {
       // терминальные коды (кик, полная комната) — причина закрытия соединения,
       // последующий handleDisconnect не должен затирать её общим сообщением
       terminalInformShown = key !== TECH_LOADING_CODE;
+      terminalTechKey = terminalInformShown ? key : null;
     } else {
       message = data;
     }
@@ -887,6 +972,7 @@ socketMethods[PS_TECH_INFORM_DATA] = data => {
   } else {
     modules.controls?.enableKeys();
     terminalInformShown = false;
+    terminalTechKey = null;
     techInformer.textContent = '';
     techInformer.style.display = 'none';
   }
@@ -929,6 +1015,21 @@ socketMethods[PS_CLEAR] = function (setIdList) {
   soundManager.reset();
 };
 
+// session data: секрет места в матче (host-migration этап 4) — с ним
+// супервизор вернётся после обрыва. Последнее сообщение пакета
+// возобновления: набор клавиш в пакете уже пришёл, и удерживаемые клавиши,
+// которые хост отпустил на время паузы, можно нажать снова
+socketMethods[PS_SESSION_DATA] = data => {
+  if (supervisor?.setSession(data ?? {})) {
+    modules.controls?.resendHeld();
+  }
+};
+
+// resume result: ответ хоста на RESUME_REQUEST
+socketMethods[PS_RESUME_RESULT] = data => {
+  supervisor?.resumeResult(data);
+};
+
 // console: логи авторитетной половины (Worker изолирован от DevTools вкладки —
 // иначе его события в браузере не видны вовсе, этап 6 плана plan/done/ai-debug)
 socketMethods[PS_CONSOLE] = data => {
@@ -1047,6 +1148,7 @@ function runModules(data) {
     cacheMin: chatData.params.cacheMin,
     cacheMax: chatData.params.cacheMax,
     messages: chatData.params.messages,
+    defaultMessages: engineChatMessages,
     sanitizeMessage,
     formatMessage,
   });
@@ -1183,7 +1285,7 @@ function runModules(data) {
     sending(PC_KEYS_DATA, `${inputSeq}:aim:${wx}:${wy}:${flags}`);
   });
   chatModel.publisher.on('socket', handleChatSend);
-  voteModel.publisher.on('socket', data => sending(PC_VOTE_DATA, data));
+  voteModel.publisher.on('socket', handleVoteSend);
 
   //==========================================//
   // Рендер-цикл интерполяции
@@ -1212,44 +1314,47 @@ function openMode(mode) {
 // reliable=false — по ненадёжному state-каналу (только pong: замер RTT
 // должен отражать сетевой путь, а не reliable-поток с ретрансмиссиями)
 function sending(name, data, reliable = true) {
-  transport?.send(JSON.stringify([name, data]), reliable);
+  supervisor?.send(JSON.stringify([name, data]), reliable);
 }
 
-// перехватывает /like·/unlike <причина> и шлёт голос напрямую мастеру по
-// сигнальному WS, минуя хоста: его CommandProcessor мог бы отфильтровать
-// голос против самого себя (server-rating этап 2, замена /ban). Причина
-// обязательна (публично не отображается). Остальной чат уходит хосту
+// отправка сообщения чата хосту (точка перехвата команд, адресованных
+// мастеру, а не хосту)
 function handleChatSend(message) {
-  const likeMatch = message === '/like' || message.startsWith('/like ');
-  const unlikeMatch = message === '/unlike' || message.startsWith('/unlike ');
-
-  // вне лобби мастера нет — голосовать некому, команда уходит хосту как
-  // обычное сообщение чата
-  if (isLobbyMode && (likeMatch || unlikeMatch)) {
-    const command = likeMatch ? '/like' : '/unlike';
-    const reason = message.slice(command.length).trim();
-    const token = lobbyAuthModel.getToken();
-
-    if (!currentHostId) {
-      modules.chat.add([`${command} is available to room guests only`]);
-    } else if (!token) {
-      modules.chat.add([`${command} requires signing in`]);
-    } else if (!reason) {
-      modules.chat.add([`${command} requires a reason: ${command} <reason>`]);
-    } else if (!signaling.connected) {
-      modules.chat.add(['No connection to the master server — vote not sent']);
-    } else if (likeMatch) {
-      signaling.likeHost(currentHostId, reason, token);
-      modules.chat.add(['Vote sent to the master server']);
-    } else {
-      signaling.unlikeHost(currentHostId, reason, token);
-      modules.chat.add(['Vote sent to the master server']);
+  const changeHost = parseChangeHost(message, bootMode);
+
+  if (changeHost === null) {
+    sending(PC_CHAT_DATA, message);
+    return;
+  }
+
+  // голосование «Change host» считает мастер (этап 10): хост не должен
+  // видеть и не может заблокировать голосование против себя
+  const notice = key => modules.chat?.add(buildSystemMessage(key));
+
+  if (changeHost === 'usage') {
+    notice('HOST_VOTE_USAGE');
+  } else if (hostRole.controller) {
+    notice('HOST_VOTE_IS_HOST');
+  } else if (!signaling?.connected || !roomCtx.roomId) {
+    notice('HOST_VOTE_OFFLINE');
+  } else {
+    signaling.hostVoteStart(roomCtx.roomId);
+  }
+}
+
+// ответ в окне голосования: «Change host?» — мастеру, остальное — хосту
+function handleVoteSend(data) {
+  if (Array.isArray(data) && data[0] === CHANGE_HOST_VOTE) {
+    const value = answerValue(data[1]);
+
+    if (guest.hostVote && value && signaling?.connected) {
+      signaling.hostVoteAnswer({ ...guest.hostVote, value });
     }
 
     return;
   }
 
-  sending(PC_CHAT_DATA, message);
+  sending(PC_VOTE_DATA, data);
 }
 
 // распаковывает данные
@@ -1273,9 +1378,12 @@ function handleVisibilityChange() {
   if (document.visibilityState === 'hidden') {
     hiddenAt = performance.now();
     soundManager.mute();
-    // иначе включение звука при возвращении
+    // иначе включение звука при возвращении (кроме паузы переподключения и
+    // смены хоста — его включит возобновление сессии)
   } else {
-    soundManager.unmute();
+    if (!isSessionPaused()) {
+      soundManager.unmute();
+    }
 
     const hiddenMs = hiddenAt === null ? 0 : performance.now() - hiddenAt;
 
@@ -1422,6 +1530,11 @@ function handleMessage(data) {
   // бинарный кадр (snapshot, порт SHOT_DATA) — в ядро: распаковка, вставка
   // в буфер по seq, reconciliation предикта по player-блоку
   if (data instanceof ArrayBuffer) {
+    // бета помнит seq последнего кадра хоста (seqFloor, этап 6) — до
+    // push_frame: ядро может забрать буфер
+    standby.noteFrame(data);
+    // восстановленный матч пошёл — сторожок тишины снимает фору
+    supervisor?.noteFrame();
     clientCore?.push_frame(new Uint8Array(data), performance.now());
 
     return;
@@ -1432,11 +1545,14 @@ function handleMessage(data) {
   dispatchSocketMessage(socketMethods, unpacking(data));
 }
 
-// разрыв P2P: выход хоста = смерть комнаты (host-migration нет). Останавливаем
-// рендер, показываем заглушку и возвращаемся в лобби перезагрузкой. closeCode
-// приходит только от WebSocket-транспорта (dedicated), остальные транспорты
-// эмитят close без него
+// терминальное закрытие сессии (супервизор: возвращаться некуда — кик,
+// политика, уход хоста, окно переподключения истекло). Останавливаем
+// рендер, показываем заглушку и возвращаемся в лобби перезагрузкой.
+// closeCode приходит только от WebSocket-транспорта (dedicated), остальные
+// транспорты эмитят close без него
 function handleDisconnect(closeCode) {
+  showSessionOverlay(null);
+
   // app.stop() здесь не зовём: при sharedTicker это Ticker.shared.stop()
   // глобально, а autoStart вернёт тикер к жизни при первом add() из любого
   // part'а — уже без renderTick. Рендер снят строкой выше, страницу и так
@@ -1461,18 +1577,21 @@ function handleDisconnect(closeCode) {
   soundManager.destroy();
   modules.controls?.disableKeys();
 
-  // если мы были хостом — гасим комнату: heartbeat, WebRTC-пиры, Worker
-  if (hostHeartbeat) {
-    clearInterval(hostHeartbeat);
-    hostHeartbeat = null;
+  // гость выбыл из матча (кик уводит на главную без перезагрузки — сессия
+  // сигналинга жива): снять членство, иначе вкладка «призраком» числится в
+  // комнате. Best-effort; хост комнату так не покидает — его снимает мастер
+  if (isLobbyMode && roomCtx.roomId && !hostRole.controller) {
+    signaling.leaveRoom(roomCtx.roomId);
   }
 
-  hostConnections?.destroy();
-  hostController?.destroy();
-  hostConnections = null;
-  hostController = null; // останавливает и reconnect-петлю сигналинга
-  diagnostics.setContext({ role: 'client' });
-  hostRegistration = null;
+  // если мы были хостом — гасим комнату: heartbeat, WebRTC-пиры, Worker
+  promotionFlow.cancel();
+  hostRole.teardown();
+  standby.teardown();
+  roomCtx.roomId = null;
+  membership.forget();
+  membership.clearTokenCapsTimer();
+  refreshRoomControls();
 
   // solo: хост крутится в этом же потоке — его таймеры переживут матч
   inlineHost?.destroy();
@@ -1488,7 +1607,7 @@ function handleDisconnect(closeCode) {
     socketMethods[PS_TECH_INFORM_DATA](
       policyInform ??
         (isLobbyMode
-          ? 'Host left — the room is closed. Returning to lobby…'
+          ? 'Host left — the room is closed. Finding another room…'
           : 'The match is over — connection to the host is closed.'),
     );
   }
@@ -1496,9 +1615,36 @@ function handleDisconnect(closeCode) {
   // в solo перезагружаться некуда: лобби нет, а матч поднимается с нуля.
   // В dedicated сервер жив — переподключение перезагрузкой уместно, но не
   // тогда, когда он сам нас и отбил по политике (network/policyClose.js)
-  if (bootMode !== 'solo' && shouldReloadAfterClose(closeCode)) {
-    setTimeout(() => location.reload(), 3000);
+  if (bootMode === 'solo' || !shouldReloadAfterClose(closeCode)) {
+    return;
+  }
+
+  if (!isLobbyMode) {
+    setTimeout(() => reloadPage(), 3000);
+
+    return;
+  }
+
+  roomMenu?.setLink(null);
+
+  // лобби-режим (host-migration, этап 3): кик и несостоявшийся старт комнаты
+  // — на главную без перезагрузки (причина остаётся в #tech-informer, клик
+  // по нему открывает лобби); закрытие комнаты — в быструю игру той же игры
+  const exit = decideExitRoute({
+    kicked: isKickClose(closeCode, terminalTechKey) || roomCtx.startFailed,
+    gameId: activeGameManifest?.id,
+  });
+
+  if (exit.reload === undefined) {
+    setRoute(exit.route);
+    techInformer.addEventListener('click', () => reloadPage(), {
+      once: true,
+    });
+
+    return;
   }
+
+  setTimeout(() => reloadPage(exit.reload), 3000);
 }
 
 /**
@@ -1508,269 +1654,405 @@ function handleDisconnect(closeCode) {
  * teardown у SDK нет специально — путь останова один на все режимы.
  */
 export function stopGame() {
-  transport?.close();
+  supervisor?.close();
 }
 
-// БУТСТРАП: лобби и установка P2P через мастер-сервер
-
-let lobby = null;
-
-// ресурсы роли хоста (комната в этой же вкладке)
-let hostController = null;
-let hostConnections = null;
-let hostHeartbeat = null;
-
-// solo: авторитетный хост в главном потоке (без Worker'а)
-let inlineHost = null;
-
-if (isDevBuild) {
-  window.__vimpDebug = createDebugApi({
-    getHostController: () => hostController,
-    getClientCore: () => clientCore,
-    reportUrl: lobbyConfig.debugReportUrl,
+// ***** супервизор сессии (host-migration этап 4) ***** //
+
+// берёт транспорт под надзор. reconnect — фабрика попыток переподключения
+// (только гость в лобби); без неё любое закрытие терминально, как раньше
+function startSession(transport, reconnect = null) {
+  supervisor = new SessionSupervisor({
+    onMessage: handleMessage,
+    onTerminal: handleDisconnect,
+    onStateChange: handleSessionState,
+    onResumed: handleSessionResumed,
+    onResumeRejected: handleResumeRejected,
+    onHostLost: reportHostUnreachable,
+    onColdRestart: handleColdRestart,
+    // кик (TECH_INFORM перед закрытием) и отказы политики не лечатся
+    // переподключением
+    isTerminalClose: closeCode =>
+      terminalInformShown || !shouldReloadAfterClose(closeCode),
+    reconnect,
+    timing: lobbyConfig.session,
   });
 
-  debugLog(
-    'window.__vimpDebug is available: dump, startRecording, stopRecording, divergence',
-  );
+  supervisor.attach(transport);
 }
 
-// WebRTC обязателен для P2P-игры. В Firefox RTCPeerConnection может
-// отсутствовать (media.peerconnection.enabled = false, resistFingerprinting,
-// приватные сборки) — честное сообщение вместо падения с чёрным экраном
-function ensureWebRtcAvailable() {
-  if (typeof RTCPeerConnection !== 'undefined') {
-    return true;
+// оверлей сессии: text — показать с текстом, null — скрыть
+function showSessionOverlay(text) {
+  if (!sessionOverlay) {
+    return;
   }
 
-  socketMethods[PS_TECH_INFORM_DATA](
-    'WebRTC is unavailable in this browser: P2P play is impossible. ' +
-      'In Firefox check that media.peerconnection.enabled is on.',
-  );
+  if (text) {
+    sessionOverlayText.textContent = text;
+    sessionOverlay.style.display = 'flex';
+  } else {
+    sessionOverlayText.textContent = '';
+    sessionOverlay.style.display = 'none';
+  }
+}
 
-  return false;
+// сессия на паузе: транспорта к хосту нет, мир стоит
+function isSessionPaused() {
+  return (
+    supervisor?.state === SESSION_STATES.reconnecting ||
+    supervisor?.state === SESSION_STATES.migrating
+  );
 }
 
-// устанавливает P2P-соединение с выбранным хостом и уходит из лобби
-function connectToHost(hostId) {
-  if (!ensureWebRtcAvailable()) {
-    return;
+// пауза переподключения или смены хоста: мир стоит, ввод и звук выключены
+// (зацикленные звуки не должны гудеть одной нотой всю паузу). Рендер не
+// останавливается — кадр стоит, независимые от снапшотов анимации идут
+function handleSessionState(state, prev) {
+  if (state === SESSION_STATES.migrating) {
+    showSessionOverlay('Switching host…');
+    modules.controls?.disableKeys();
+    soundManager.mute();
+  } else if (state === SESSION_STATES.reconnecting) {
+    // после смены хоста оверлей тот же до конца возобновления
+    if (prev !== SESSION_STATES.migrating) {
+      showSessionOverlay('Reconnecting…');
+    }
+
+    modules.controls?.disableKeys();
+    soundManager.mute();
+  } else if (state === SESSION_STATES.inGame) {
+    showSessionOverlay(null);
   }
+}
 
-  currentHostId = hostId;
+// транспорт к хосту оборвался в матче: мастер узнаёт об этом от гостя
+// раньше, чем сам (host-migration этап 7.2) — проба хоста или его смена.
+// Эпоха — хоста, к которому был транспорт: чужую мастер отбросит
+function reportHostUnreachable() {
+  if (isLobbyMode) {
+    guest.reportHostUnreachable();
+  }
+}
 
-  transport = new WebRtcManager(signaling, {
-    iceServers: signaling.iceServers,
-  });
+// новый хост поднял матч заново (cold): возобновлять нечего — чистый вход в
+// ту же комнату с полным рукопожатием
+function handleColdRestart() {
+  reloadToRoom();
+}
 
-  transport.publisher.on('message', handleMessage);
-  transport.publisher.on('close', handleDisconnect);
-  transport.connect(hostId);
+// место возвращено: предсказание начинается с чистого листа (вводы,
+// ушедшие в оборванный транспорт, хост не получит никогда — переигрывать
+// их нельзя), голосование хоста паузу не пережило. Дальше хост шлёт пакет
+// входа: CLEAR, полный кадр, набор клавиш, SESSION_DATA
+function handleSessionResumed() {
+  clientCore?.reset();
+  // «Change host?» ведёт мастер — оно паузу переживает
+  modules.vote?.removeHostVotes();
+  modules.controls?.enableKeys();
 
-  lobby?.close();
+  if (document.visibilityState !== 'hidden') {
+    soundManager.unmute();
+  }
 }
 
-// поднимает комнату в этой же вкладке (Worker хоста): хост-игрок играет через
-// loopback, удалённые клиенты — по WebRTC (answerer). Клиентский код одинаков,
-// отличается лишь транспорт. Выход хоста = смерть комнаты — как у клиента
-async function connectAsHost(room) {
-  // фича-детект вместо classic-фолбэка (запретил бы ESM/инлайн WASM,
-  // см. PLAN.md риск №5): честная ошибка, join остаётся доступен
-  if (!supportsModuleWorker()) {
-    socketMethods[PS_TECH_INFORM_DATA](
-      'This browser cannot be a host: ES module Web Workers are ' +
-        'unsupported. You can still join existing rooms.',
-    );
+// место потеряно (ожидание истекло, ключ не принят): чистый вход в ту же
+// комнату с полным рукопожатием
+function handleResumeRejected(reason) {
+  console.warn(`[session] resume rejected: ${reason}`);
+  showSessionOverlay(null);
+  reloadToRoom();
+}
 
-    return;
-  }
+// ссылка на текущую комнату (иначе — на быструю игру той же игры)
+function reloadToRoom() {
+  const gameId = activeGameManifest?.id;
 
-  if (!ensureWebRtcAvailable()) {
+  if (!gameId) {
+    reloadPage('');
     return;
   }
 
-  // фактическая карта комнаты (из 'ready'; далее актуализируется map_changed)
-  let currentMapName = null;
+  reloadPage(
+    roomCtx.roomId
+      ? formatRoomLink(gameId, roomCtx.roomId)
+      : formatGameLink(gameId),
+  );
+}
 
-  // отладочный контур (этап 6): рекордер живого матча и хостовый CONSOLE-лог
-  // поднимаются только в dev-сборке
-  room.isDevMode = isDevBuild;
+// хост начал рукопожатие заново посреди живой сессии (порт — какой
+// именно). Второе ядро/Application не строим: в лобби — чистый вход в ту же
+// комнату, в остальных режимах только журнал
+function handleProtocolError(port) {
+  diagnostics.warn('engine.session.protocol', { port }, { source: 'client' });
 
-  // Этап 6.4: Worker грузит HostPlugin динамически по entries.host/entries.wasm
-  // активной игры — движок больше не знает игру статически
-  room.game = {
-    id: activeGameManifest.id,
-    version: activeGameManifest.version,
-    hostEntryUrl: activeGameManifest.entries.host,
-    wasmUrl: activeGameManifest.entries.wasm,
-  };
+  if (isLobbyMode) {
+    reloadToRoom();
+  }
+}
 
-  // Этап 5.1: комната стартует на актуальных картах мастера;
-  // недоступность каталога некритична — Worker возьмёт карты из бандла
-  try {
-    const catalog = await fetchMasterMaps();
+// БУТСТРАП: лобби и установка P2P через мастер-сервер
 
-    room.maps = catalog.maps;
-    hostMapsVersion = catalog.version;
-  } catch (e) {
-    console.warn('[maps] master catalog unavailable, using bundled maps:', e);
-  }
+let lobby = null;
 
-  // Этап 5.2: Worker создаётся по манифесту мастера — бандл страницы после
-  // деплоя исчезает из раздачи; без манифеста (dev) — бандловый URL,
-  // обновления кода отключены
-  let workerUrl = null;
+// id вкладки — ключ участника комнаты на мастере; живёт в памяти (не в
+// storage): две вкладки одного профиля — два участника
+const memberId = isLobbyMode ? crypto.randomUUID() : null;
+
+// меню комнаты внутри матча (этапы 3 и 8d) и защита вкладки хоста от
+// случайного закрытия (этап 8.4): только лобби-режим
+let roomMenu = null;
+let unloadGuard = null;
+// любая программная перезагрузка — только через неё (client/lib/pageReload.js)
+const reloadPage = createPageReload({ getGuard: () => unloadGuard });
+
+// ***** сценарии комнаты (client/session/*): здесь только сборка ***** //
+
+const isPageHidden = () => document.visibilityState === 'hidden';
+const informTech = text => socketMethods[PS_TECH_INFORM_DATA](text);
+const chatNotice = message => modules.chat?.add(message);
+const getSupervisor = () => supervisor;
+const getToken = () => lobbyAuthModel.getToken();
+const getTokenExpiresAt = () => lobbyAuthModel.getTokenExpiresAt();
+
+// комната вкладки: id, эпоха хоста, членство, вход и несостоявшийся старт
+const roomCtx = createRoomContext();
+
+const hostRoomPrep = createHostRoomPrep({
+  getActiveGame: () => activeGameManifest,
+  config: lobbyConfig,
+  isDevBuild,
+  fetchGamePluginManifest,
+});
 
-  try {
-    const manifest = await fetchWorkerManifest();
+const membership = new Membership({
+  signaling,
+  ctx: roomCtx,
+  memberId,
+  getToken,
+  getTokenExpiresAt,
+  isHost: () => Boolean(hostRole.controller),
+  config: lobbyConfig,
+});
 
-    // составной codeVersion (Этап 6.5): движок (worker-бандл) + игра
-    // (id/version активного манифеста, с которым комната стартует)
-    hostCodeVersion = {
-      engine: manifest.version,
-      game: { id: activeGameManifest.id, version: activeGameManifest.version },
-    };
-    workerUrl = manifest.url;
-  } catch (e) {
-    console.warn('[worker] master manifest unavailable, using bundled:', e);
-  }
+const standby = new StandbyRole({
+  signaling,
+  ctx: roomCtx,
+  isHost: () => Boolean(hostRole.controller),
+  prepareRoom: hostRoomPrep.prepareHostRoom,
+  diagnostics,
+  config: lobbyConfig.migration,
+  debug: isDevBuild ? debugLog : null,
+});
 
-  diagnostics.setContext({ role: 'host' });
+const hostRole = new HostRole({
+  signaling,
+  ctx: roomCtx,
+  membership,
+  config: lobbyConfig,
+  diagnostics,
+  prep: hostRoomPrep,
+  getActiveGame: () => activeGameManifest,
+  getToken,
+  getHandoff: () => handoff,
+  onPromotionRegistered: hostPromotion => promotionFlow.finish(hostPromotion),
+  isLobbyMode,
+  debug: isDevBuild ? debugLog : null,
+  ui: {
+    showRoomLink,
+    refreshRoomControls,
+    setHandoffMenu: state => roomMenu?.setHandoff(state),
+    isHidden: isPageHidden,
+    informTech,
+    ensureWebRtc: ensureWebRtcAvailable,
+    startSession: transport => startSession(transport),
+    closeLobby: () => lobby?.close(),
+    // Worker не поднялся (WASM/конфиг): гасим комнату и возвращаемся в лобби
+    onStartFailed: msg => {
+      roomCtx.startFailed = true;
+      handleDisconnect();
+      informTech(
+        `Failed to start the room: ${msg.message || 'unknown error'}. Click to return to the lobby.`,
+      );
+    },
+  },
+});
 
-  hostController = new HostController(room, {
-    workerUrl,
-    diagnostics,
-    onReady: readyMsg => {
-      currentMapName = readyMsg?.mapName;
+const handoff = new HandoffFlow({
+  signaling,
+  ctx: roomCtx,
+  hostRole,
+  standby,
+  membership,
+  getPromotion: () => promotionFlow,
+  getSupervisor,
+  getTokenExpiresAt,
+  config: lobbyConfig.migration,
+  ui: {
+    showSessionOverlay,
+    disableControls: () => modules.controls?.disableKeys(),
+    enableControls: () => modules.controls?.enableKeys(),
+    mute: () => soundManager.mute(),
+    unmute: () => soundManager.unmute(),
+    isHidden: isPageHidden,
+    setHandoffMenu: state => roomMenu?.setHandoff(state),
+    sendLeave: () => sending(PC_LEAVE),
+    reloadPage,
+  },
+});
 
-      // seed мира приезжает в 'ready' (этап 1): без него запись матча
-      // невоспроизводима, поэтому он виден в консоли сразу
-      if (isDevBuild) {
-        debugLog('room ready', {
-          map: currentMapName,
-          seed: readyMsg?.seed,
-        });
-      }
+const guest = new GuestSession({
+  signaling,
+  ctx: roomCtx,
+  membership,
+  hostRole,
+  standby,
+  getPromotion: () => promotionFlow,
+  getSupervisor,
+  getToken,
+  logout: () => lobbyAuthModel.logout(),
+  config: lobbyConfig,
+  diagnostics,
+  ui: {
+    ensureWebRtc: ensureWebRtcAvailable,
+    showRoomLink: roomId => showRoomLink(activeGameManifest?.id, roomId),
+    startSession,
+    closeLobby: () => lobby?.close(),
+    leaveRoomWith,
+    chat: chatNotice,
+    getVote: () => modules.vote,
+  },
+});
 
-      // периодический heartbeat/актуализация комнаты у мастера
-      const update = () =>
-        signaling.updateHost({
-          currentPlayers: 1 + (hostConnections?.peerCount || 0),
-          mapName: currentMapName,
-        });
-
-      // регистрация комнаты; повторно вызывается при reconnect сигналинга
-      hostRegistration = () => {
-        signaling.registerHost({
-          name: room.name,
-          maxPlayers: room.maxPlayers,
-          mapName: currentMapName,
-          gameId: room.game.id,
-          gameVersion: room.game.version,
-          token: lobbyAuthModel.getToken(),
-        });
-
-        clearInterval(hostHeartbeat);
-        hostHeartbeat = setInterval(
-          update,
-          lobbyConfig.create.heartbeatInterval,
-        );
-      };
+const promotionFlow = new PromotionFlow({
+  signaling,
+  ctx: roomCtx,
+  hostRole,
+  standby,
+  membership,
+  getHandoff: () => handoff,
+  getGuest: () => guest,
+  getSupervisor,
+  getActiveGameId: () => activeGameManifest?.id,
+  getToken,
+  prepareRoom: hostRoomPrep.prepareHostRoom,
+  config: lobbyConfig,
+  diagnostics,
+  ui: {
+    reloadPage,
+    reloadToRoom,
+    showSessionOverlay,
+    disableControls: () => modules.controls?.disableKeys(),
+    mute: () => soundManager.mute(),
+    informTech,
+    chat: chatNotice,
+  },
+});
 
-      hostRegistration();
-    },
+if (isLobbyMode) {
+  const roomMenuModel = new RoomMenuModel();
 
-    // смена карты голосованием/таймером — сразу отразить в лобби мастера
-    onMapChange: mapName => {
-      currentMapName = mapName;
-      signaling.updateHost({ mapName });
+  roomMenu = new RoomMenuCtrl(
+    roomMenuModel,
+    new RoomMenuView(roomMenuModel, lobbyConfig.roomMenu),
+    {
+      onLeave: () => handoff.leaveByUser(),
+      onHandover: () => handoff.start({ reason: 'handover', stay: true }),
     },
+  );
 
-    // Worker не поднялся (WASM/конфиг): гасим комнату и возвращаемся в лобби
-    onError: msg => {
-      handleDisconnect();
-      socketMethods[PS_TECH_INFORM_DATA](
-        `Failed to start the room: ${msg.message || 'unknown error'}. Returning to lobby…`,
-      );
+  unloadGuard = new HostUnloadGuard({
+    // мастер начинает аварийную миграцию сразу, не дожидаясь обрыва WS
+    onHostLeave: () => {
+      if (hostRole.room) {
+        signaling.hostLeaving(hostRole.room.roomId, hostRole.room.epoch);
+      }
     },
+    // место освобождается сразу, а не через resumeGraceMs
+    onGuestLeave: () => handoff.announceGuestLeave(),
   });
+}
 
-  // удалённые клиенты по WebRTC; актуализация currentPlayers при их вход/выходе
-  hostConnections = new HostConnectionManager(signaling, hostController, {
-    iceServers: signaling.iceServers,
-    onPeersChange: count => signaling.updateHost({ currentPlayers: 1 + count }),
+// роль вкладки в комнате для меню и защиты закрытия: хост — пока у неё
+// Worker комнаты (и во время промоушена), гость — пока она в комнате
+function refreshRoomControls() {
+  const role = !roomCtx.roomId ? null : hostRole.controller ? 'host' : 'guest';
+  const othersPresent = role === 'host' && hostRole.peerCount > 0;
+
+  roomMenu?.setRole({
+    role,
+    othersPresent,
+    hasSuccessor: role === 'host' && hostRole.successorMemberId !== null,
   });
+  unloadGuard?.update({ role, othersPresent });
+}
 
-  // хост-игрок в этой же вкладке (socketId согласован с kick-исключением)
-  transport = new LoopbackTransport(
-    hostController,
-    lobbyConfig.create.hostSocketId,
-  );
+// адресная строка показывает ссылку на комнату, пока вкладка в ней: её
+// можно скопировать прямо оттуда, как и пунктом меню комнаты
+function showRoomLink(gameId, roomId) {
+  if (!gameId) {
+    return;
+  }
 
-  transport.publisher.on('message', handleMessage);
-  transport.publisher.on('close', handleDisconnect);
-  transport.connect();
+  const link = formatRoomLink(gameId, roomId);
 
-  // сигнальный WS хоста должен жить постоянно (офферы, heartbeat, выдача) —
-  // при разрыве переподключаемся с бэкоффом; welcome вызовет re-register
-  let reconnectAttempt = 0;
+  setRoute(link);
+  roomMenu?.setLink(absoluteLink(link));
+  refreshRoomControls();
+}
 
-  signaling.publisher.on('close', () => {
-    if (!hostController) {
-      return; // комната уже погашена
-    }
+// средний FPS рендера гостя за интервал отчёта (этап 9c)
+const fpsMeter = new FpsMeter();
 
-    const { baseDelay, maxDelay } = lobbyConfig.reconnect;
-    const delay = Math.min(maxDelay, baseDelay * 2 ** reconnectAttempt);
+document.addEventListener('visibilitychange', () => {
+  const hidden = isPageHidden();
 
-    reconnectAttempt += 1;
-    setTimeout(() => signaling.connect(), delay);
-  });
+  hostRole.setHidden(hidden);
+  handoff.setHidden(hidden);
 
-  signaling.publisher.on('welcome', () => {
-    reconnectAttempt = 0;
-    hostRegistration?.();
-  });
+  // кадры скрытой вкладки (их нет) не тянут средний FPS вниз
+  if (!hidden) {
+    fpsMeter.reset();
+  }
+});
 
-  // мастер отвечает актуальными версиями каталога карт и worker-бандла:
-  // расхождение (деплой, пока комната жила) — подтянуть каталог к следующей
-  // смене карты / заменить Worker эстафетой на границе раунда (Этап 5.2)
-  signaling.publisher.on('host_registered', msg => {
-    // кодревью №1 (plan/server-rating/review.md): hostId + per-room секрет не
-    // известны Worker'у до этого момента — прокидываем их, чтобы PlayerDataSync
-    // атрибутировал последующие rank/state-flush к этой комнате (секрет
-    // доказывает мастеру владение hostId)
-    hostController?.setHostId(msg.hostId, msg.hostSecret);
-
-    if (msg.mapsVersion && msg.mapsVersion !== hostMapsVersion) {
-      refreshHostMaps();
-    }
+// закрытие скрытой вкладки: эпизод закрывается сводкой сейчас — журнал свой
+// pagehide уже отработал (подписан раньше), поэтому отправка явная
+window.addEventListener('pagehide', () => {
+  if (hostRole.flushHiddenLog()) {
+    diagnostics.flush();
+  }
+});
 
-    if (
-      msg.codeVersion &&
-      hostCodeVersion &&
-      codeVersionChanged(msg.codeVersion, hostCodeVersion)
-    ) {
-      refreshHostWorker();
-    }
+// solo: авторитетный хост в главном потоке (без Worker'а)
+let inlineHost = null;
+
+if (isDevBuild) {
+  window.__vimpDebug = createDebugApi({
+    getHostController: () => hostRole.controller,
+    getClientCore: () => clientCore,
+    reportUrl: lobbyConfig.debugReportUrl,
+    startHandoff: options => handoff.start(options),
   });
 
-  // сигнал мастера об обновлении каталога карт/кода (hot-reload в будущем)
-  signaling.publisher.on('update_available', msg => {
-    if (!msg.mapsVersion || msg.mapsVersion !== hostMapsVersion) {
-      refreshHostMaps();
-    }
+  debugLog(
+    'window.__vimpDebug is available: dump, startRecording, stopRecording, divergence',
+  );
+}
 
-    if (
-      msg.codeVersion &&
-      hostCodeVersion &&
-      codeVersionChanged(msg.codeVersion, hostCodeVersion)
-    ) {
-      refreshHostWorker();
-    }
-  });
+// WebRTC обязателен для P2P-игры. В Firefox RTCPeerConnection может
+// отсутствовать (media.peerconnection.enabled = false, resistFingerprinting,
+// приватные сборки) — честное сообщение вместо падения с чёрным экраном
+function ensureWebRtcAvailable() {
+  if (typeof RTCPeerConnection !== 'undefined') {
+    return true;
+  }
+
+  socketMethods[PS_TECH_INFORM_DATA](
+    'WebRTC is unavailable in this browser: P2P play is impossible. ' +
+      'In Firefox check that media.peerconnection.enabled is on.',
+  );
 
-  lobby?.close();
+  return false;
 }
 
 // solo-режим: авторитетный матч в этом же потоке (standalone SDK). Ни
@@ -1796,163 +2078,20 @@ async function connectSolo() {
   // хендшейк начинается в connect() — хост к этому моменту обязан быть готов
   await inlineHost.ready;
 
-  transport = new LoopbackTransport(inlineHost, socketId);
+  const transport = new LoopbackTransport(inlineHost, socketId);
 
-  transport.publisher.on('message', handleMessage);
-  transport.publisher.on('close', handleDisconnect);
+  startSession(transport);
   transport.connect();
 }
 
 // dedicated-режим: прямой WebSocket к Node-серверу игры
 function connectDedicated() {
-  transport = new WebSocketTransport(boot.wsUrl);
+  const transport = new WebSocketTransport(boot.wsUrl);
 
-  transport.publisher.on('message', handleMessage);
-  transport.publisher.on('close', handleDisconnect);
+  startSession(transport);
   transport.connect();
 }
 
-// версия каталога карт мастера, с которой поднята комната (Этап 5.1)
-let hostMapsVersion = null;
-
-// составной codeVersion комнаты (Этап 5.2/6.5): { engine, game: { id, version } };
-// null — обновления кода отключены (манифест недоступен при старте)
-let hostCodeVersion = null;
-
-// версия, своп на которую не удался — не ретраить её на каждом re-register
-let failedCodeVersion = null;
-
-// сравнимый ключ составного codeVersion (Этап 6.5): движок + игра —
-// расхождение любой половины (деплой движка ИЛИ деплой игры) запускает эстафету
-function codeVersionKey(cv) {
-  return cv
-    ? `${cv.engine ?? ''}:${cv.game?.id ?? ''}:${cv.game?.version ?? ''}`
-    : null;
-}
-
-function codeVersionChanged(remote, local) {
-  return codeVersionKey(remote) !== codeVersionKey(local);
-}
-
-// защита от параллельных эстафет Worker'ов
-let workerSwapInProgress = false;
-
-// повторная регистрация комнаты у мастера (reconnect сигналинга)
-let hostRegistration = null;
-
-// Этап 5.1/6.4: скачивает каталог карт мастера активной игры (манифест +
-// все карты)
-async function fetchMasterMaps() {
-  const manifestRes = await fetch(lobbyConfig.maps.manifestUrl(activeGameManifest));
-
-  if (!manifestRes.ok) {
-    throw new Error(`maps manifest: HTTP ${manifestRes.status}`);
-  }
-
-  const manifest = await manifestRes.json();
-
-  const entries = await Promise.all(
-    manifest.maps.map(async name => {
-      const url = `${lobbyConfig.maps.baseUrl(activeGameManifest)}/${encodeURIComponent(name)}`;
-      const res = await fetch(url);
-
-      if (!res.ok) {
-        throw new Error(`map ${name}: HTTP ${res.status}`);
-      }
-
-      return [name, await res.json()];
-    }),
-  );
-
-  return { version: manifest.version, maps: Object.fromEntries(entries) };
-}
-
-// перечитывает каталог карт мастера и передаёт в Worker:
-// применится со следующей смены карты (текущий раунд не трогается)
-async function refreshHostMaps() {
-  try {
-    const catalog = await fetchMasterMaps();
-
-    hostMapsVersion = catalog.version;
-    hostController?.updateMaps(catalog.maps);
-  } catch (e) {
-    console.warn('[maps] refresh from master failed:', e);
-  }
-}
-
-// Этап 5.2: скачивает манифест worker-бандла мастера ({ version, url })
-async function fetchWorkerManifest() {
-  const res = await fetch(lobbyConfig.worker.manifestUrl);
-
-  if (!res.ok) {
-    throw new Error(`worker manifest: HTTP ${res.status}`);
-  }
-
-  return res.json();
-}
-
-// Этап 6.5: перечитывает манифест активной игры мастера — своп не должен
-// нести новому Worker'у закэшированный с момента создания комнаты
-// hostEntryUrl/wasmUrl (деплой игры мог обновиться независимо от движка)
-async function fetchGameManifest(gameId) {
-  return fetchGamePluginManifest(lobbyConfig.game.manifestUrl(gameId));
-}
-
-// Этап 5.2/6.5: эстафета Worker'ов — новая версия кода (движка ИЛИ игры) у
-// мастера. Worker заменяется на границе раунда без разрыва P2P; сбой свопа
-// не смертелен — комната продолжает жить на прежней версии
-async function refreshHostWorker() {
-  if (workerSwapInProgress || !hostController) {
-    return;
-  }
-
-  workerSwapInProgress = true;
-
-  let manifest = null;
-  let game = null;
-
-  try {
-    manifest = await fetchWorkerManifest();
-    const gameManifest = await fetchGameManifest(activeGameManifest.id);
-
-    game = {
-      id: gameManifest.id,
-      version: gameManifest.version,
-      hostEntryUrl: gameManifest.entries.host,
-      wasmUrl: gameManifest.entries.wasm,
-    };
-
-    const nextCodeVersion = {
-      engine: manifest.version,
-      game: { id: game.id, version: game.version },
-    };
-    const nextKey = codeVersionKey(nextCodeVersion);
-
-    if (
-      !manifest.version ||
-      !manifest.url ||
-      nextKey === codeVersionKey(hostCodeVersion) ||
-      nextKey === codeVersionKey(failedCodeVersion)
-    ) {
-      return;
-    }
-
-    await hostController.swapWorker(manifest.url, game);
-
-    hostCodeVersion = nextCodeVersion;
-    failedCodeVersion = null;
-    console.info(`[worker] room migrated to code version ${nextKey}`);
-  } catch (e) {
-    if (manifest?.version) {
-      failedCodeVersion = { engine: manifest.version, game };
-    }
-
-    console.warn('[worker] swap to new version failed:', e);
-  } finally {
-    workerSwapInProgress = false;
-  }
-}
-
 // REST-запрос списка серверов у мастера (поиск игнорирует пагинацию)
 async function fetchServers({ offset, limit, search }) {
   const params = new URLSearchParams();
@@ -2102,8 +2241,9 @@ function clearLobbyError() {
 }
 
 // активирует игру и перепривязывает манифест/плагин/CSS; false — отказ уже
-// показан игроку, лобби остаётся рабочим
-async function selectActiveGame(gameId) {
+// показан игроку (report, по умолчанию строкой формы лобби), лобби остаётся
+// рабочим
+async function selectActiveGame(gameId, { report = showLobbyError } = {}) {
   // сверка идёт с самим манифестом, а не с его id: каталог вкладки может
   // пополниться застейдженной версией той же игры (registerGameManifest), и
   // сравнение по id оставило бы активной одобренную версию
@@ -2125,7 +2265,7 @@ async function selectActiveGame(gameId) {
     return true;
   } catch (e) {
     console.error(`[game] failed to activate "${gameId}":`, e);
-    showLobbyError(
+    report(
       `Failed to load ${gamesById.get(gameId)?.title ?? gameId}: ${e.message}`,
     );
 
@@ -2146,7 +2286,7 @@ const stagedGameIds = new Set();
  * так админ может поднять по нему комнату, не трогая каталог игроков.
  * Дальше всё работает существующим путём: createGameActivator грузит
  * ClientPlugin по entries.client (ключ кеша версионный, поэтому плагин
- * черновика не подменит одобренный), connectAsHost поднимает комнату, а
+ * черновика не подменит одобренный), hostRole.createRoom поднимает комнату, а
  * мастер помечает её скрытой по версии манифеста.
  * @param {Object} manifest - Манифест застейдженной версии из /admin/games.
  * @returns {void}
@@ -2251,8 +2391,8 @@ function initLobby() {
   });
 
   // умный пинг видимого сервера — сигнальным путём (замер приблизительный)
-  lobbyModel.publisher.on('ping-request', ({ hostId, pingId }) => {
-    signaling.pingHost(hostId, pingId);
+  lobbyModel.publisher.on('ping-request', ({ roomId, pingId }) => {
+    signaling.pingHost(roomId, pingId);
   });
 
   signaling.publisher.on('pong_host', msg => {
@@ -2262,7 +2402,7 @@ function initLobby() {
   // выбор сервера → активация игры комнаты и установка P2P. gameId нет у
   // хостов старше 6.4 — тогда заходим на активной игре, как раньше: неизвестная
   // версия не повод запретить вход
-  lobbyModel.publisher.on('join', async ({ hostId, gameId }) => {
+  lobbyModel.publisher.on('join', async ({ roomId, gameId }) => {
     if (gameId && gamesById.has(gameId)) {
       if (!(await selectActiveGame(gameId))) {
         return;
@@ -2275,7 +2415,7 @@ function initLobby() {
       return;
     }
 
-    connectToHost(hostId);
+    guest.connectToRoom(roomId);
   });
 
   // Leaderboard (lobby-page-plan): контроллер сигнализирует, для какой игры
@@ -2324,7 +2464,9 @@ function initLobby() {
   // реестр игр (master-game-registry, этап 4): заявка разработчика и панель
   // модерации живут в том же лобби. Триплет поднимается вместе с лобби —
   // панель доступна любому авторизованному, кнопку модерации показывает роль
-  const gamesModel = new GamesModel(lobbyConfig.games, () => lobbyAuthModel.getToken());
+  const gamesModel = new GamesModel(lobbyConfig.games, () =>
+    lobbyAuthModel.getToken(),
+  );
   const gamesView = new GamesView(gamesModel, lobbyConfig.games);
   const games = new GamesCtrl(gamesModel, gamesView);
 
@@ -2335,11 +2477,18 @@ function initLobby() {
 
   // журнал клиентских ошибок (plan/client-reports, этап 5): кнопку «Errors»
   // видит только админ; фильтр по игре — каталог вкладки
-  const clientReportsModel = new ClientReportsModel(lobbyConfig.clientReports, () =>
-    lobbyAuthModel.getToken(),
+  const clientReportsModel = new ClientReportsModel(
+    lobbyConfig.clientReports,
+    () => lobbyAuthModel.getToken(),
+  );
+  const clientReportsView = new ClientReportsView(
+    clientReportsModel,
+    lobbyConfig.clientReports,
+  );
+  const clientReports = new ClientReportsCtrl(
+    clientReportsModel,
+    clientReportsView,
   );
-  const clientReportsView = new ClientReportsView(clientReportsModel, lobbyConfig.clientReports);
-  const clientReports = new ClientReportsCtrl(clientReportsModel, clientReportsView);
 
   clientReportsView.setGames([...gamesById.values()]);
   clientReports.setAdmin(lobbyAuthModel.getRole() === 'admin');
@@ -2361,22 +2510,24 @@ function initLobby() {
     // мастера синхронным циклом, и без очереди два черновика при пустом
     // каталоге ушли бы активироваться одновременно — активной осталась бы
     // одна игра, а форма комнаты собралась бы по другой
-    stagedActivation = stagedActivation.then(async () => {
-      if (activeGameManifest) {
-        return; // предыдущий черновик уже стал активным
-      }
+    stagedActivation = stagedActivation
+      .then(async () => {
+        if (activeGameManifest) {
+          return; // предыдущий черновик уже стал активным
+        }
 
-      // только на успехе: отказ активации уже написал в ту же строку СВОЮ
-      // причину («Failed to load X: …»), и общее «игр пока не опубликовано»
-      // затёрло бы её — админ увидел бы не то, что случилось
-      if (await selectActiveGame(manifest.id)) {
-        syncCatalogState();
-      }
-    }).catch(e => {
-      // отказ не должен заклинить очередь: следующий черновик обязан
-      // получить свой шанс стать активной игрой
-      console.error('[game] staged activation failed:', e);
-    });
+        // только на успехе: отказ активации уже написал в ту же строку СВОЮ
+        // причину («Failed to load X: …»), и общее «игр пока не опубликовано»
+        // затёрло бы её — админ увидел бы не то, что случилось
+        if (await selectActiveGame(manifest.id)) {
+          syncCatalogState();
+        }
+      })
+      .catch(e => {
+        // отказ не должен заклинить очередь: следующий черновик обязан
+        // получить свой шанс стать активной игрой
+        console.error('[game] staged activation failed:', e);
+      });
   });
 
   // создание комнаты в этой же вкладке (хост-игрок через loopback)
@@ -2402,8 +2553,6 @@ function initLobby() {
     liveErrors.disarm();
   });
 
-  const nameInput = document.getElementById(lobbyConfig.elems.nameId);
-
   hostBtn?.addEventListener('click', async () => {
     // валидация (pattern/required/min/max) — единственная граница
     // room-формы: она едет клиенту как JSON манифеста, JS-валидаторы
@@ -2419,8 +2568,6 @@ function initLobby() {
     }
 
     const manifest = gamesById.get(gameSelect?.value) ?? activeGameManifest;
-    const name =
-      (nameInput?.value || '').trim() || lobbyConfig.create.defaultName;
 
     // значения формы снимаем до await: активация асинхронна, а roomFormFields
     // пересобираются при смене игры — в комнату должно уехать то, что игрок
@@ -2441,8 +2588,7 @@ function initLobby() {
       return;
     }
 
-    connectAsHost({
-      name,
+    hostRole.createRoom({
       hostSocketId: lobbyConfig.create.hostSocketId,
       ...overrides,
     });
@@ -2461,9 +2607,52 @@ let lobbyAuthView = null;
 let welcomeReceived = false;
 let authenticated = false;
 
+// прямые ссылки и быстрая игра (client/session/RouteBoot.js)
+const route = new RouteBoot({
+  ctx: roomCtx,
+  signaling,
+  membership,
+  config: lobbyConfig,
+  gamesById,
+  selectActiveGame,
+  connectToRoom: roomId => guest.connectToRoom(roomId),
+  createRoom: (room, options) => hostRole.createRoom(room, options),
+  fetchServers,
+  ui: {
+    initLobby,
+    selectLobbyGame: gameId => {
+      const gameSelect = document.getElementById(lobbyConfig.elems.gameId);
+
+      if (gameSelect) {
+        gameSelect.value = gameId;
+        gameSelect.dispatchEvent(new Event('change'));
+      }
+    },
+    informTech,
+    onInformerClick: handler =>
+      techInformer.addEventListener('click', handler, { once: true }),
+    getHash: () => location.hash,
+    setRoute,
+    reloadPage,
+  },
+});
+
 function maybeInitLobby() {
   if (welcomeReceived && authenticated) {
-    initLobby();
+    route.boot();
+  }
+}
+
+// показывает терминальную причину и возвращает в лобби (путь
+// handleDisconnect: закрытие транспорта → перезагрузка)
+function leaveRoomWith(message) {
+  socketMethods[PS_TECH_INFORM_DATA](message);
+  terminalInformShown = true;
+
+  if (supervisor) {
+    supervisor.close();
+  } else {
+    handleDisconnect();
   }
 }
 
@@ -2480,15 +2669,51 @@ if (isLobbyMode) {
     maybeInitLobby();
   });
 
+  guest.bind();
+  hostRole.bind();
+  standby.bind();
+  promotionFlow.bind();
+  handoff.bind();
+
+  document.addEventListener('visibilitychange', () => membership.sendUpdate());
+
+  // свежий средний FPS гостя мастеру (этап 9c); хост его не шлёт
+  Ticker.shared.add(() => fpsMeter.frame());
+  setInterval(
+    () => membership.setFps(fpsMeter.sample()),
+    lobbyConfig.migration.auto.fpsReportIntervalMs,
+  );
+
   lobbyAuthModel.publisher.on('authenticated', () => {
     authenticated = true;
     maybeInitLobby();
+    // новый вход — новый срок: canHost пересчитается по нему, передача роли
+    // хоста — тоже
+    membership.armTokenCapsTimer();
+
+    if (hostRole.controller) {
+      handoff.armTokenHandoff();
+    }
+
+    // повторный вход после logout: маршрут уже разобран, а логин-гейт
+    // спрятал лобби — вернуть его, если вкладка не в комнате
+    if (route.booted && !roomCtx.entered) {
+      lobby?.open();
+    }
   });
 
+  // OAuth-возврат: токены из query прочитаны — чистим только query, hash
+  // (маршрут #/<gameId>[/<roomId>]) остаётся
   if (lobbyAuthCtrl.init(window.location.search)) {
-    window.history.replaceState(null, '', window.location.pathname);
+    window.history.replaceState(
+      null,
+      '',
+      window.location.pathname + window.location.hash,
+    );
   }
 
+  window.addEventListener('hashchange', () => route.handleHashChange());
+
   signaling.connect();
 } else if (bootMode === 'solo') {
   try {