vimp-engine 0.2.0 → 0.4.0

package/src/host/HostGame.js

@@ -11,7 +11,9 @@ import VoteCoordinator from './meta/core/VoteCoordinator.js';
 import RoundManager from './meta/core/RoundManager.js';
 import CommandProcessor from './meta/core/CommandProcessor.js';
 import { sanitizeMessage } from '../lib/sanitizers.js';
+import clock from '../lib/clock.js';
 import GameCoreAdapter from './GameCoreAdapter.js';
+import DebugRecorder from './DebugRecorder.js';
 
 // Версия формата handoff-меты эстафеты Worker'ов (Этап 5.2; →2 в Этапе 6.5 —
 // добавлены gameId/gameVersion; →3 в Этапе Д3 — нейтральное поле scripted).
@@ -70,6 +72,8 @@ export default class HostGame {
    * @param {string} [opts.gameVersion] - версия игры комнаты (room.game.version,
    *   Этап 6.5): едет в handoff-мете рядом с gameId — расхождение с игрой
    *   восстанавливающего Worker'а валит init тем же путём, что и версия формата.
+   * @param {number} [opts.seed] - seed мира, которым инициализировано ядро
+   *   (createHostRuntime): без него записанный сценарий невоспроизводим.
    */
   constructor(
     data,
@@ -81,9 +85,12 @@ export default class HostGame {
       onMapChange = null,
       handoff = null,
       gameVersion = null,
+      playerDataFetch = null,
+      seed = null,
     } = {},
   ) {
     this._isDevMode = data.isDevMode || false;
+    this._seed = seed;
 
     this._hostSocketId = hostSocketId;
     this._onMapChange = onMapChange;
@@ -126,13 +133,21 @@ export default class HostGame {
     // обратно на мастер по границам раунда/карты (см. RoundManager)
     this._playerDataSync = new PlayerDataSync(this._gameId, {
       defaultState: data.playerState?.defaultState ?? {},
+      // headless-прогону некуда ходить за профилем (относительный URL и нет
+      // мастера) — подменяется только там, в проде остаётся глобальный fetch
+      ...(playerDataFetch ? { fetchImpl: playerDataFetch } : {}),
     });
     this._chat = new Chat();
     this._vote = new Vote();
 
     this._socketManager = socketManager;
 
-    this._snapshotManager = new SnapshotThrottle(data.timers.networkSendRate);
+    this._networkSendRate = data.timers.networkSendRate;
+    this._snapshotManager = new SnapshotThrottle(this._networkSendRate);
+
+    // рекордер живого матча (этап 6 плана plan/ai-debug) — только в dev-режиме;
+    // в проде null, и все точки записи ниже вырождаются в ?.
+    this._recorder = this._isDevMode ? new DebugRecorder() : null;
 
     // игровые host-модули (scripted-модуль игры)
     this._scripted = hostPlugin.createModules({
@@ -282,6 +297,9 @@ export default class HostGame {
 
   // создаёт кадр игры (core-driven)
   _onShotTick(dt) {
+    // номер тика — единственная временная координата сценария (этап 6)
+    this._recorder?.tick(dt);
+
     // шаг ядра + проекция событий (kill/health/ammo/weapon/shake) в мету
     this._game.updateData(dt);
 
@@ -313,7 +331,7 @@ export default class HostGame {
     const chat = this._chat.shift();
     const vote = this._vote.shift();
 
-    const serverTime = Date.now();
+    const serverTime = clock.now();
     this._seq = (this._seq + 1) >>> 0;
     const seq = this._seq;
     const activeList = this._participants.getActiveList();
@@ -398,7 +416,7 @@ export default class HostGame {
 
   // проверяет игроков на бездействие и кикает, если превышен порог
   _kickIdleUsers() {
-    const now = Date.now();
+    const now = clock.now();
     const usersToKick = [];
 
     for (const user of this._participants.getHumans()) {
@@ -493,6 +511,94 @@ export default class HostGame {
     this._mapList.push(...Object.keys(this._maps));
   }
 
+  // ***** отладочный контур (этап 6 плана plan/ai-debug) ***** //
+  // Всё ниже живёт под флагом isDevMode: в проде рекордера нет, а дамп
+  // отдаёт только то, что и так знает мета.
+
+  get isRecording() {
+    return this._recorder?.isRecording === true;
+  }
+
+  // начинает запись живого матча в формат сценария headless-runner'а.
+  // Возвращает false, если dev-режим выключен — тишины быть не должно
+  startRecording() {
+    if (!this._recorder) {
+      return false;
+    }
+
+    this._recorder.start({
+      seed: this._seed,
+      map: this._roundManager.currentMap,
+      networkSendRate: this._networkSendRate,
+      participants: this._participants.getHumans().map(user => ({
+        gameId: user.gameId,
+        name: user.name,
+        model: user.model,
+        socketId: user.socketId,
+        team: user.team === this._spectatorTeam ? null : user.team,
+      })),
+    });
+
+    this._debugConsole('recording started');
+
+    return true;
+  }
+
+  // останавливает запись и отдаёт сценарий (parseScenario принимает как есть)
+  stopRecording() {
+    const scenario = this._recorder?.stop() ?? null;
+
+    if (scenario) {
+      this._debugConsole(
+        `recording stopped: ${scenario.ticks} tick(s), ` +
+          `${scenario.timeline.length} op(s)`,
+      );
+    }
+
+    return scenario;
+  }
+
+  // курированный срез хоста: мета рядом с дампом мира ядра (этап 4) —
+  // расхождение «в ядре тело есть, на холсте пусто» видно только вместе
+  debugSnapshot() {
+    return {
+      seed: this._seed,
+      seq: this._seq,
+      tick: this._recorder?.tickCount ?? null,
+      recording: this.isRecording,
+      currentMap: this._roundManager.currentMap,
+      participants: {
+        humans: this._participants.getHumans().map(user => ({
+          gameId: user.gameId,
+          socketId: user.socketId,
+          name: user.name,
+          team: user.team,
+          isReady: user.isReady,
+          isWatching: user.isWatching,
+        })),
+        scripted: this._participants.getScripted().map(user => ({
+          gameId: user.gameId,
+          name: user.name,
+          team: user.team,
+        })),
+        activeList: this._participants.getActiveList(),
+      },
+      core: this._game.debugJson(),
+    };
+  }
+
+  // структурированный лог хоста в консоль клиентов (порт CONSOLE): Worker
+  // изолирован от DevTools вкладки, поэтому его события иначе не видны
+  _debugConsole(message) {
+    if (!this._isDevMode) {
+      return;
+    }
+
+    for (const user of this._participants.getNetworkedReady()) {
+      this._socketManager.sendConsole(user.socketId, message);
+    }
+  }
+
   // ***** эстафета Worker'ов (Этап 5.2) ***** //
 
   // запрашивает перенос: на ближайшей границе раунда игра останавливается
@@ -683,6 +789,13 @@ export default class HostGame {
     const gameId = this._participants.createHuman(params, socketId);
     const name = this._participants.get(gameId).name;
 
+    this._recorder?.noteJoin({
+      gameId,
+      name,
+      model: params.model,
+      socketId,
+    });
+
     this._chat.addUser(gameId);
     this._vote.addUser(gameId);
     this._stat.addUser(gameId, this._spectatorId, { name });
@@ -708,6 +821,8 @@ export default class HostGame {
 
     const { team, teamId } = user;
 
+    this._recorder?.noteLeave(gameId);
+
     this._RTTManager.removeUser(gameId);
     this._stat.removeUser(gameId, teamId);
     this._chat.removeUser(gameId);
@@ -717,7 +832,7 @@ export default class HostGame {
     // финальная синхронизация rank/state перед уходом участника (Этап B4)
     this._playerDataSync
       .flush(gameId)
-      .catch(() => {})
+      .catch(err => console.warn('[playerData] final flush failed:', err.message))
       .finally(() => this._playerDataSync.removeUser(gameId));
 
     // если не наблюдатель — удалить танк из ядра (null-маркер ставит ядро)
@@ -740,7 +855,9 @@ export default class HostGame {
 
     const [seq, action, name] = keyStr.split(':');
 
-    user.lastActionTime = Date.now();
+    this._recorder?.noteKey(gameId, action, name);
+
+    user.lastActionTime = clock.now();
     user.lastInputSeq = Number(seq) >>> 0;
 
     if (user.isWatching === true) {
@@ -766,7 +883,7 @@ export default class HostGame {
       return;
     }
 
-    user.lastActionTime = Date.now();
+    user.lastActionTime = clock.now();
 
     message = sanitizeMessage(message);
 
@@ -775,6 +892,9 @@ export default class HostGame {
     }
 
     if (message) {
+      // пишется уже вычищенный текст — ровно тот, что применяется к матчу
+      this._recorder?.noteChat(gameId, message);
+
       if (message.charAt(0) === '/') {
         this._commandProcessor.parseCommand(gameId, message);
       } else {
@@ -791,7 +911,9 @@ export default class HostGame {
       return;
     }
 
-    user.lastActionTime = Date.now();
+    this._recorder?.noteVote(gameId, data);
+
+    user.lastActionTime = clock.now();
 
     if (typeof data === 'string') {
       if (data === 'teams') {

package/src/host/host.worker.js

@@ -7,17 +7,11 @@
 // (JSON-строки и бинарные ArrayBuffer'ы через Transferable).
 
 import authClientConfig from '../config/authClient.js';
-import clientDefaults from '../config/clientDefaults.js';
 import lobbyConfig from '../config/lobby.js';
 import wsports from '../config/wsports.js';
-import { applyRoomOverrides } from '../lib/applyRoomOverrides.js';
-import { buildClientConfig } from '../lib/buildClientConfig.js';
-import { buildCoreConfig } from '../lib/coreConfig.js';
+import { createHostRuntime } from '../lib/createHostRuntime.js';
 import { validateAuth } from '../lib/validators.js';
 import { verifyIdentityToken } from '../lib/jwt.js';
-import { assertGameConfigShape } from '../lib/gamePlugin.js';
-import SocketManager from './meta/SocketManager.js';
-import HostGame from './HostGame.js';
 
 // PC (client ports): порты получения данных от клиента
 const PC_CONFIG_READY = wsports.client.CONFIG_READY;
@@ -130,54 +124,28 @@ function makeWorkerSocket(socketId) {
 // эстафеты Worker'ов (Этап 5.2): комната восстанавливается вместо
 // холодного старта, порт-машины клиентов поднимутся минуя хендшейк
 async function onInit(room, handoff = null) {
-  const pluginModule = await import(/* @vite-ignore */ room.game.hostEntryUrl);
-
-  hostPlugin = pluginModule.default;
-  assertGameConfigShape(hostPlugin);
-
-  const game = applyRoomOverrides(room, hostPlugin);
-  const seed = (Math.random() * 2 ** 32) >>> 0;
-
-  const core = await hostPlugin.createCore(
-    JSON.stringify(
-      buildCoreConfig(hostPlugin.gameConfig, {
-        friendlyFire: game.parts.friendlyFire,
-        seed,
-      }),
-    ),
-    { wasmUrl: room.game.wasmUrl },
-  );
-
-  clientCfg = buildClientConfig(
-    game,
-    clientDefaults,
-    hostPlugin.buildClientGameConfig(),
-  );
-  socketManager = new SocketManager(wsports.server, {
-    soundCues: game.soundCues,
-    initialVote: game.initialVote,
-  });
-  host = new HostGame(game, socketManager, core, hostPlugin, {
-    hostSocketId: room?.hostSocketId ?? null,
-    onMapChange: mapName => self.postMessage({ type: 'map_changed', mapName }),
-    handoff,
-    gameVersion: room.game.version,
+  // общая с headless-runner'ом сборка (lib/createHostRuntime.js) — чтобы
+  // отладочный прогон крутил ровно тот код, что и прод
+  const runtime = await createHostRuntime(room, {
+    hostOptions: {
+      onMapChange: mapName => self.postMessage({ type: 'map_changed', mapName }),
+      handoff,
+    },
   });
 
-  // эстафета Worker'ов (Этап 5.2) несёт уже известные hostId+секрет в room —
-  // новый Worker не должен ждать повторного register_host, чтобы возобновить
-  // атрибуцию rank/state-flush (кодревью №1); при холодном старте они ещё не
-  // назначены мастером, придут позже через 'set_host_id'
-  if (room?.hostId) {
-    host.setHostId(room.hostId, room.hostSecret);
-  }
+  hostPlugin = runtime.hostPlugin;
+  clientCfg = runtime.clientCfg;
+  socketManager = runtime.socketManager;
+  host = runtime.host;
+
+  const seed = runtime.seed;
 
   if (handoff) {
     handoffClients = new Map(handoff.humans.map(h => [h.socketId, h.gameId]));
   }
 
   // мастеру нужна фактическая карта комнаты (после эстафеты — восстановленная)
-  self.postMessage({ type: 'ready', mapName: host.currentMap });
+  self.postMessage({ type: 'ready', mapName: host.currentMap, seed });
 }
 
 // порт-обработчики клиента (замыкание над gameId через state)
@@ -375,6 +343,31 @@ function onDisconnect(socketId) {
   clients.delete(socketId);
 }
 
+// отладочные действия хоста (этап 6): запись живого матча в формат сценария
+// и дамп мира. Сбой не должен ронять Worker — уезжает в ответ строкой
+function onDebug({ requestId, action }) {
+  let result = null;
+  let error = null;
+
+  try {
+    if (!host) {
+      error = 'host is not ready';
+    } else if (action === 'startRecording') {
+      result = host.startRecording();
+    } else if (action === 'stopRecording') {
+      result = host.stopRecording();
+    } else if (action === 'dump') {
+      result = host.debugSnapshot();
+    } else {
+      error = `unknown debug action '${action}'`;
+    }
+  } catch (e) {
+    error = e && e.message ? e.message : String(e);
+  }
+
+  self.postMessage({ type: 'debug_result', requestId, result, error });
+}
+
 self.onmessage = async event => {
   const msg = event.data;
 
@@ -414,6 +407,12 @@ self.onmessage = async event => {
       host?.setHostId(msg.hostId, msg.hostSecret);
       break;
 
+    // отладочный контур (этап 6 плана plan/ai-debug): единственный вход в
+    // авторитетную половину из главного потока — запрос/ответ по requestId
+    case 'debug':
+      onDebug(msg);
+      break;
+
     // эстафета Worker'ов (Этап 5.2)
 
     // запрос переноса: на ближайшей границе раунда игра остановится и

package/src/host/meta/SocketManager.js

@@ -1,3 +1,6 @@
+import GAME_CODES from '../../config/gameCodes.js';
+import clock from '../../lib/clock.js';
+
 const TECH_CODES = {
   fullServer: [0],
   anotherDevice: [1],
@@ -8,12 +11,6 @@ const TECH_CODES = {
   roomFull: [6], // P2P-комната заполнена (отказ без очереди ожидания)
 };
 
-const GAME_CODES = {
-  winnerTeam: [0],
-  roundStart: [1],
-  gameOver: [2],
-};
-
 export default class SocketManager {
   /**
    * @param {Object} ports - карта портов host→client (wsports.server).
@@ -282,7 +279,7 @@ export default class SocketManager {
     this._send(socketId, this._PORT_FIRST_SHOT_DATA, [
       this._game.getPlayersData(), // gameSnapshot
       0, // camera
-      Date.now(), // serverTime
+      clock.now(), // serverTime
       0, // seq
     ]);
     this.sendStat(socketId, this._stat.getFull());
@@ -311,6 +308,17 @@ export default class SocketManager {
     this._sendBinary(socketId, frameBuffer, reliable);
   }
 
+  /**
+   * Отправка отладочного лога хоста в консоль клиента (порт CONSOLE,
+   * этап 6 плана plan/ai-debug). Worker изолирован от DevTools вкладки —
+   * без этого канала его события в браузере не видны вовсе.
+   * @param {string} socketId
+   * @param {*} data
+   */
+  sendConsole(socketId, data) {
+    this._send(socketId, this._PORT_CONSOLE, data);
+  }
+
   /**
    * Отправка данных панели.
    * @param {string} socketId

package/src/host/meta/modules/Panel.js

@@ -178,4 +178,11 @@ class Panel {
   }
 }
 
+// Сброс синглтона. Нужен только тем, кто крутит больше одного матча в
+// процессе — headless-runner (devtools/resetHostSingletons.js) и тесты;
+// в браузерной вкладке матч всегда один, поэтому прод его не зовёт.
+export const resetPanel = () => {
+  panel = null;
+};
+
 export default Panel;

package/src/host/meta/modules/PlayerDataSync.js

@@ -7,7 +7,11 @@ import lobbyConfig from '../../../config/lobby.js';
 // (RoundManager: смена карты, конец раунда). Схему/дефолты state объявляет
 // игра — здесь это чёрный ящик.
 export default class PlayerDataSync {
-  constructor(gameId, { fetchImpl = fetch, defaultState = {} } = {}) {
+  // дефолт fetchImpl обёрнут стрелкой, а не взят как голый `fetch`: из поля
+  // объекта он вызывался бы с `this` экземпляра, а в браузере/воркере у
+  // fetch brand-check на глобальный scope — это синхронный TypeError ещё до
+  // обращения к сети (тесты подставляют обычную функцию и мимо этого ходят)
+  constructor(gameId, { fetchImpl = (...args) => fetch(...args), defaultState = {} } = {}) {
     this._gameId = gameId;
     this._fetch = fetchImpl;
     this._defaultState = defaultState;
@@ -67,23 +71,31 @@ export default class PlayerDataSync {
         this._authedFetch(lobbyConfig.auth.stateUrl, token),
       ]);
 
-      if (rankRes.ok && !entry.rankLoaded) {
+      // неуспешный ответ логируется: rankLoaded/stateLoaded гейтят весь
+      // последующий flush, поэтому молчаливый 401/404 здесь навсегда
+      // выключает синхронизацию и выглядит снаружи как «данных просто нет»
+      if (!rankRes.ok) {
+        console.warn(`[playerData] GET rank ${rankRes.status} for ${participantId}`);
+      } else if (!entry.rankLoaded) {
         // F9: во время await мог накопиться addRank-дельта поверх
         // стартового 0 — прибавляем, а не перетираем серверным значением
         entry.rank += (await rankRes.json()).rank ?? 0;
         entry.rankLoaded = true;
       }
 
-      if (stateRes.ok && !entry.stateLoaded) {
+      if (!stateRes.ok) {
+        console.warn(`[playerData] GET state ${stateRes.status} for ${participantId}`);
+      } else if (!entry.stateLoaded) {
         const { state } = await stateRes.json();
 
         entry.state =
           state && Object.keys(state).length ? state : structuredClone(this._defaultState);
         entry.stateLoaded = true;
       }
-    } catch {
+    } catch (err) {
       // недоступность auth-сервиса — остаёмся на дефолтах, следующий
       // flush повторит load() перед синхронизацией (см. flush)
+      console.warn(`[playerData] load failed for ${participantId}:`, err.message);
     }
 
     return entry;
@@ -152,6 +164,8 @@ export default class PlayerDataSync {
         }).then(res => {
           if (res.ok) {
             entry.pendingRankDelta -= delta;
+          } else {
+            console.warn(`[playerData] PUT rank ${res.status} for ${participantId}`);
           }
         }),
       );
@@ -161,10 +175,20 @@ export default class PlayerDataSync {
       requests.push(this._authedFetch(lobbyConfig.auth.stateUrl, token, {
         method: 'PUT',
         body: { state, hostId: this._hostId, hostSecret: this._hostSecret },
+      }).then(res => {
+        if (!res.ok) {
+          console.warn(`[playerData] PUT state ${res.status} for ${participantId}`);
+        }
       }));
     }
 
-    await Promise.allSettled(requests);
+    // allSettled глушит отказы по замыслу (сбой не должен ронять раунд), но
+    // не должен глушить их след — иначе потеря синхронизации не диагностируема
+    for (const result of await Promise.allSettled(requests)) {
+      if (result.status === 'rejected') {
+        console.warn(`[playerData] flush failed for ${participantId}:`, result.reason?.message);
+      }
+    }
   }
 
   // синхронизирует всех текущих участников (границы раунда/карты)

package/src/host/meta/modules/RTTManager.js

@@ -1,3 +1,5 @@
+import clock from '../../../lib/clock.js';
+
 /**
  * @class RTTManager
  * @description Управляет расчетом Round Trip Time (RTT) для пользователя,
@@ -96,7 +98,7 @@ export default class RTTManager {
 
       // новый пинг
       user.pingIdCounter += 1;
-      const time = Date.now();
+      const time = clock.now();
 
       // удаление старых пингов и запись нового
       // `outstandingPings` содержит только один, последний отправленный пинг
@@ -141,7 +143,7 @@ export default class RTTManager {
     const time = user.outstandingPings.get(pingId);
 
     if (time) {
-      const newRttSample = Date.now() - time;
+      const newRttSample = clock.now() - time;
       const oldRtt = user.rtt;
 
       // сглаживание значения RTT

package/src/host/meta/modules/Stat.js

@@ -291,4 +291,11 @@ class Stat {
   }
 }
 
+// Сброс синглтона. Нужен только тем, кто крутит больше одного матча в
+// процессе — headless-runner (devtools/resetHostSingletons.js) и тесты;
+// в браузерной вкладке матч всегда один, поэтому прод его не зовёт.
+export const resetStat = () => {
+  stat = null;
+};
+
 export default Stat;

package/src/host/meta/modules/TimerManager.js

@@ -1,4 +1,5 @@
 import AbstractTimer from '../../../lib/AbstractTimer.js';
+import clock from '../../../lib/clock.js';
 
 // Singleton TimerManager
 
@@ -66,7 +67,7 @@ class TimerManager extends AbstractTimer {
   // при возобновлении после эстафеты Worker'ов, Этап 5.2)
   startMapTimer(duration = this._mapTime) {
     this.stopMapTimer();
-    this._startMapTime = Date.now();
+    this._startMapTime = clock.now();
     this._currentMapDuration = duration;
     this._startTimer('map', this._callbacks.onMapTimeEnd, duration);
   }
@@ -79,7 +80,7 @@ class TimerManager extends AbstractTimer {
   // возвращает оставшееся время до конца карты в миллисекундах
   getMapTimeLeft() {
     const timeLeft =
-      this._currentMapDuration - (Date.now() - this._startMapTime);
+      this._currentMapDuration - (clock.now() - this._startMapTime);
 
     return Math.max(0, timeLeft);
   }
@@ -95,7 +96,7 @@ class TimerManager extends AbstractTimer {
   // запускает таймер до конца текущего раунда
   startRoundTimer() {
     this.stopRoundTimer();
-    this._startRoundTime = Date.now();
+    this._startRoundTime = clock.now();
     this._startTimer('round', this._callbacks.onRoundTimeEnd, this._roundTime);
   }
 
@@ -106,21 +107,21 @@ class TimerManager extends AbstractTimer {
 
   // возвращает оставшееся время до конца раунда в секундах
   getRoundTimeLeft() {
-    const timeLeft = this._roundTime - (Date.now() - this._startRoundTime);
+    const timeLeft = this._roundTime - (clock.now() - this._startRoundTime);
 
     return Math.max(0, Math.floor(timeLeft / 1000));
   }
 
   // проверяет возможно сменить команду игроку в текущем раунде
   canChangeTeamInCurrentRound() {
-    const roundTime = Date.now() - this._startRoundTime;
+    const roundTime = clock.now() - this._startRoundTime;
 
     return roundTime <= this._teamChangeGracePeriod;
   }
 
   // логика одного "тика" игрового цикла
   _loopTick() {
-    const now = performance.now();
+    const now = clock.monotonic();
     let dt = (now - this._lastShotTime) / 1000;
     this._lastShotTime = now;
 
@@ -146,7 +147,7 @@ class TimerManager extends AbstractTimer {
   _startGameLoop() {
     this._stopGameLoop();
 
-    this._lastShotTime = performance.now();
+    this._lastShotTime = clock.monotonic();
     this._expectedTickTime = this._lastShotTime + this._timeStep;
 
     // запуск первого таймаута, который инициирует цикл
@@ -274,4 +275,11 @@ class TimerManager extends AbstractTimer {
   }
 }
 
+// Сброс синглтона. Нужен только тем, кто крутит больше одного матча в
+// процессе — headless-runner (devtools/resetHostSingletons.js) и тесты;
+// в браузерной вкладке матч всегда один, поэтому прод его не зовёт.
+export const resetTimerManager = () => {
+  timerManager = null;
+};
+
 export default TimerManager;

package/src/host/meta/modules/Vote.js

@@ -1,3 +1,5 @@
+import clock from '../../../lib/clock.js';
+
 // Singleton Vote
 let vote;
 
@@ -171,9 +173,16 @@ class Vote {
     }
 
     // случайный выбор, если победителей несколько
-    const randomIndex = Math.floor(Math.random() * winners.length);
+    const randomIndex = Math.floor(clock.random() * winners.length);
     return winners[randomIndex];
   }
 }
 
+// Сброс синглтона. Нужен только тем, кто крутит больше одного матча в
+// процессе — headless-runner (devtools/resetHostSingletons.js) и тесты;
+// в браузерной вкладке матч всегда один, поэтому прод его не зовёт.
+export const resetVote = () => {
+  vote = null;
+};
+
 export default Vote;

package/src/host/meta/modules/chat/Chat.js

@@ -63,4 +63,11 @@ class Chat {
   }
 }
 
+// Сброс синглтона. Нужен только тем, кто крутит больше одного матча в
+// процессе — headless-runner (devtools/resetHostSingletons.js) и тесты;
+// в браузерной вкладке матч всегда один, поэтому прод его не зовёт.
+export const resetChat = () => {
+  chat = null;
+};
+
 export default Chat;

package/src/host/meta/modules/chat/index.js

@@ -1 +1 @@
-export { default } from './Chat.js';
+export { default, resetChat } from './Chat.js';