vimp-engine 0.35.6 → 0.36.0

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

@@ -1,6 +1,10 @@
 import AbstractTimer from '../../../lib/AbstractTimer.js';
 import clock from '../../../lib/clock.js';
 
+// окно метрик здоровья цикла (host-migration этап 9a): раз в столько мс
+// цикл отдаёт onLoopStats — хост решает по ним, не пора ли отдать роль
+const LOOP_STATS_WINDOW_MS = 1000;
+
 // Singleton TimerManager
 
 let timerManager;
@@ -43,6 +47,23 @@ class TimerManager extends AbstractTimer {
     // максимально допустимая дельта времени в секундах,
     // для предотвращения "прыжков" в симуляции после долгих пауз
     this._maxDeltaTime = 0.1;
+
+    // окно метрик цикла: живёт только пока цикл крутится — на паузе метрик
+    // нет (иначе заморозка выглядела бы перегрузкой)
+    this._loopStats = null;
+
+    // заморозка (host-migration этап 5): момент паузы — пока он задан,
+    // остатки карты/раунда не убывают
+    this._pausedAt = null;
+
+    // цель отложенной смены карты: колбэк — замыкание, а контрольной точке
+    // нужна декларация (её колбэк строится заново при восстановлении)
+    this._pendingMapChange = null;
+  }
+
+  // «сейчас» для остатков: на паузе время карты и раунда стоит
+  _now() {
+    return this._pausedAt ?? clock.now();
   }
 
   // запускает все основные игровые таймеры (карта, игровой цикл, раунд)
@@ -80,7 +101,7 @@ class TimerManager extends AbstractTimer {
   // возвращает оставшееся время до конца карты в миллисекундах
   getMapTimeLeft() {
     const timeLeft =
-      this._currentMapDuration - (clock.now() - this._startMapTime);
+      this._currentMapDuration - (this._now() - this._startMapTime);
 
     return Math.max(0, timeLeft);
   }
@@ -93,11 +114,14 @@ class TimerManager extends AbstractTimer {
     this._startRttPingTimer();
   }
 
-  // запускает таймер до конца текущего раунда
-  startRoundTimer() {
+  // запускает таймер до конца текущего раунда. duration — остаток при
+  // восстановлении из контрольной точки: старт раунда тогда «виртуальный»
+  // (в прошлом), чтобы прошедшее время раунда и грейс смены команды
+  // считались от настоящего начала
+  startRoundTimer(duration = this._roundTime) {
     this.stopRoundTimer();
-    this._startRoundTime = clock.now();
-    this._startTimer('round', this._callbacks.onRoundTimeEnd, this._roundTime);
+    this._startRoundTime = clock.now() - (this._roundTime - duration);
+    this._startTimer('round', this._callbacks.onRoundTimeEnd, duration);
   }
 
   // останавливает таймер раунда
@@ -107,14 +131,17 @@ class TimerManager extends AbstractTimer {
 
   // возвращает оставшееся время до конца раунда в секундах
   getRoundTimeLeft() {
-    const timeLeft = this._roundTime - (clock.now() - this._startRoundTime);
+    return Math.floor(this.getRoundTimeLeftMs() / 1000);
+  }
 
-    return Math.max(0, Math.floor(timeLeft / 1000));
+  // то же в миллисекундах (контрольная точка не теряет долей секунды)
+  getRoundTimeLeftMs() {
+    return Math.max(0, this._roundTime - (this._now() - this._startRoundTime));
   }
 
   // проверяет возможно сменить команду игроку в текущем раунде
   canChangeTeamInCurrentRound() {
-    const roundTime = clock.now() - this._startRoundTime;
+    const roundTime = this._now() - this._startRoundTime;
 
     return roundTime <= this._teamChangeGracePeriod;
   }
@@ -125,6 +152,8 @@ class TimerManager extends AbstractTimer {
     let dt = (now - this._lastShotTime) / 1000;
     this._lastShotTime = now;
 
+    this._countLoopTick(dt);
+
     // если dt аномально большой (система "спала"), ограничить его
     // и сбросить ожидаемое время, чтобы цикл не пытался "наверстать".
     if (dt > this._maxDeltaTime) {
@@ -133,6 +162,7 @@ class TimerManager extends AbstractTimer {
     }
 
     this._callbacks.onShotTick(dt);
+    this._flushLoopStats(now);
 
     const drift = now - this._expectedTickTime;
     const nextTimeout = Math.max(0, this._timeStep - drift);
@@ -143,11 +173,47 @@ class TimerManager extends AbstractTimer {
     this._startTimer('gameLoop', () => this._loopTick(), nextTimeout);
   }
 
+  // итерация цикла в окно метрик: срезанное капом dt — время, которое
+  // симуляция не прожила (отстаёт от реального)
+  _countLoopTick(dt) {
+    const stats = this._loopStats;
+
+    stats.ticks += 1;
+    stats.maxGapMs = Math.max(stats.maxGapMs, dt * 1000);
+
+    if (dt > this._maxDeltaTime) {
+      stats.lostMs += (dt - this._maxDeltaTime) * 1000;
+    }
+  }
+
+  // окно метрик закрыто — отдать и начать новое
+  _flushLoopStats(now) {
+    const stats = this._loopStats;
+    const windowMs = now - stats.startedAt;
+
+    if (windowMs < LOOP_STATS_WINDOW_MS) {
+      return;
+    }
+
+    this._loopStats = this._newLoopStats(now);
+    this._callbacks.onLoopStats?.({
+      tickRate: Math.round((stats.ticks * 10000) / windowMs) / 10,
+      maxGapMs: Math.round(stats.maxGapMs),
+      lostMs: Math.round(stats.lostMs),
+      windowMs: Math.round(windowMs),
+    });
+  }
+
+  _newLoopStats(now) {
+    return { startedAt: now, ticks: 0, maxGapMs: 0, lostMs: 0 };
+  }
+
   // инициализирует и запускает игровой цикл (обновление кадров)
   _startGameLoop() {
     this._stopGameLoop();
 
     this._lastShotTime = clock.monotonic();
+    this._loopStats = this._newLoopStats(this._lastShotTime);
     this._expectedTickTime = this._lastShotTime + this._timeStep;
 
     // запуск первого таймаута, который инициирует цикл
@@ -174,13 +240,24 @@ class TimerManager extends AbstractTimer {
   }
 
   // запускает таймер, блокирующий возможность инициировать
-  // новое голосование в заданной категории
-  startVoteBlockTimer(voteCategory, onEndCallback) {
-    this._startTimer(
-      `voteBlock:${voteCategory}`,
-      onEndCallback,
-      this._timeBlockedVote,
-    );
+  // новое голосование в заданной категории (duration — остаток кулдауна
+  // из контрольной точки)
+  startVoteBlockTimer(
+    voteCategory,
+    onEndCallback,
+    duration = this._timeBlockedVote,
+  ) {
+    this._startTimer(`voteBlock:${voteCategory}`, onEndCallback, duration);
+  }
+
+  // кулдауны голосований с остатками: [{ name, leftMs }]
+  getVoteCooldowns() {
+    return [...this._timers.keys()]
+      .filter(key => key.startsWith('voteBlock:'))
+      .map(key => ({
+        name: key.slice('voteBlock:'.length),
+        leftMs: this._timeLeft(key),
+      }));
   }
 
   // останавливает все таймеры блокировки
@@ -211,9 +288,15 @@ class TimerManager extends AbstractTimer {
     this._stopTimer('roundRestartDelay');
   }
 
-  // запускает отложенную смену карты (после голосования)
-  startMapChangeDelay(onEndCallback) {
-    this._startTimer('mapChangeDelay', onEndCallback, this._mapChangeDelay);
+  // запускает отложенную смену карты (после голосования). targetMap —
+  // декларация цели для контрольной точки; duration — остаток при
+  // восстановлении
+  startMapChangeDelay(
+    onEndCallback,
+    { targetMap = null, duration = this._mapChangeDelay } = {},
+  ) {
+    this._pendingMapChange = targetMap;
+    this._startTimer('mapChangeDelay', onEndCallback, duration);
   }
 
   // останавливает отложенную смену карты
@@ -221,6 +304,120 @@ class TimerManager extends AbstractTimer {
     this._stopTimer('mapChangeDelay');
   }
 
+  // ***** контрольная точка (host-migration этап 5) ***** //
+
+  /**
+   * Остатки по всем дедлайнам. Активные голосования (vote:*) не
+   * переносятся: их resultFunc — замыкания.
+   * @returns {Object} { mapTimeLeft, roundTimeLeft, roundElapsed,
+   *   teamChangeGraceLeft, pending, voteCooldowns }. mapTimeLeft считается
+   *   и у остановленного таймера (эстафета снимает таймеры до сбора меты);
+   *   roundTimeLeft null — раунд не идёт (завершается).
+   */
+  serialize() {
+    const roundElapsed = Math.max(0, this._now() - this._startRoundTime);
+    const pending = [];
+
+    if (this._hasTimer('roundRestartDelay')) {
+      pending.push({
+        kind: 'roundRestart',
+        leftMs: this._timeLeft('roundRestartDelay'),
+      });
+    }
+
+    if (this._hasTimer('mapChangeDelay') && this._pendingMapChange !== null) {
+      pending.push({
+        kind: 'mapChange',
+        leftMs: this._timeLeft('mapChangeDelay'),
+        targetMap: this._pendingMapChange,
+      });
+    }
+
+    return {
+      mapTimeLeft: this.getMapTimeLeft(),
+      roundTimeLeft: this._hasTimer('round') ? this.getRoundTimeLeftMs() : null,
+      roundElapsed,
+      teamChangeGraceLeft: Math.max(
+        0,
+        this._teamChangeGracePeriod - roundElapsed,
+      ),
+      pending,
+      voteCooldowns: this.getVoteCooldowns(),
+    };
+  }
+
+  /**
+   * Запускает игровые таймеры с остатками из serialize(): карта, раунд,
+   * цикл, пинги, отложенный перезапуск раунда, кулдауны голосований.
+   * Отложенную смену карты (pending mapChange) поднимает RoundManager —
+   * колбэк его.
+   * @param {Object} state - результат serialize().
+   */
+  resumeFromState(state) {
+    this.startMapTimer(state.mapTimeLeft ?? this._mapTime);
+
+    if (state.roundTimeLeft !== null && state.roundTimeLeft !== undefined) {
+      this.startRoundTimer(state.roundTimeLeft);
+    } else {
+      // раунд завершается (таймер снят) — прошедшее время всё равно нужно
+      // грейсу смены команды
+      this._startRoundTime = clock.now() - (state.roundElapsed ?? 0);
+    }
+
+    for (const item of state.pending ?? []) {
+      if (item.kind === 'roundRestart') {
+        this._startTimer(
+          'roundRestartDelay',
+          this._callbacks.onRoundTimeEnd,
+          item.leftMs,
+        );
+      }
+    }
+
+    for (const { name, leftMs } of state.voteCooldowns ?? []) {
+      this.startVoteBlockTimer(name, () => {}, leftMs);
+    }
+
+    this._startGameLoop();
+    this._startRttPingTimer();
+  }
+
+  get isPaused() {
+    return this._pausedAt !== null;
+  }
+
+  // заморозка: все отсчёты (цикл, карта, раунд, отложенные вызовы,
+  // голосования, пинги, проверка бездействия) встают с остатками
+  pause() {
+    if (this._pausedAt !== null) {
+      return;
+    }
+
+    this._pausedAt = clock.now();
+    this._pauseTimers();
+  }
+
+  // разморозка: остатки дотикивают, цикл стартует заново (без «прыжка» dt)
+  resume() {
+    if (this._pausedAt === null) {
+      return;
+    }
+
+    const pausedFor = clock.now() - this._pausedAt;
+
+    this._pausedAt = null;
+    this._startMapTime += pausedFor;
+    this._startRoundTime += pausedFor;
+
+    const loopPaused = this._timeLeft('gameLoop') !== null;
+
+    this._resumeTimers(key => key !== 'gameLoop');
+
+    if (loopPaused) {
+      this._startGameLoop();
+    }
+  }
+
   // логика одного "тика" для проверки на бездействие
   _idleCheckTick() {
     this._callbacks.onIdleCheck();

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

@@ -10,6 +10,15 @@ const MESSAGE_CODES = {
   REPORT_KILL: 's:4', // ⚔️  {0} killed {1}!
   USER_JOINED: 's:5', // ⚡ {0} joined the game
   USER_LEFT: 's:6', // 👋  {0} left the game
+  HOST_CHANGED: 's:7', // Host changed (host-migration: матч у преемника)
+  // You are no longer the host (connection lost) — добавляет сам клиент
+  // бывшего хоста (host_revoked), по проводу не ходит
+  HOST_REVOKED: 's:8',
+  // вместо HOST_CHANGED, когда хост отдал роль автоматически (этап 9)
+  HOST_CHANGED_OVERLOAD: 's:9', // Host changed: the previous host was lagging
+  HOST_CHANGED_HIDDEN: 's:10', // Host changed: the previous host went inactive
+  // Host changed: the previous host had a poor connection
+  HOST_CHANGED_NETWORK: 's:11',
 
   VOTE_CREATED: 'v:0', // A vote has been created
   VOTE_STARTED: 'v:1', // Voting has started
@@ -17,6 +26,19 @@ const MESSAGE_CODES = {
   VOTE_UNAVAILABLE: 'v:3', // Voting is temporarily unavailable
   VOTE_PASSED: 'v:4', // Vote passed
   VOTE_FAILED: 'v:5', // Vote failed
+  // голосование «Change host» (host-migration этап 10): ведёт мастер,
+  // сообщения добавляет сам клиент, по проводу они не ходят
+  HOST_VOTE_USAGE: 'v:6', // Usage: /changehost
+  // You are the host — use “Hand over host” in the room menu
+  HOST_VOTE_IS_HOST: 'v:7',
+  HOST_VOTE_OFFLINE: 'v:8', // No connection to the master server
+  HOST_VOTE_RECENT: 'v:9', // A host vote was held recently
+  HOST_VOTE_NO_SUCCESSOR: 'v:10', // No other player can host
+  HOST_VOTE_ACTIVE: 'v:11', // A host vote is already in progress
+  HOST_VOTE_UNAVAILABLE: 'v:12', // A host vote is not possible right now
+  HOST_VOTE_PASSED: 'v:13', // Vote to change host passed ({0}/{1})
+  HOST_VOTE_FAILED: 'v:14', // Vote to change host failed ({0}/{1})
+  HOST_VOTE_CANCELLED: 'v:15', // Host vote cancelled
 
   MAP_CURRENT: 'm:0', // Current map: {0}
   MAP_NEXT: 'm:1', // Next map: {0}

package/src/host/meta/player/HumanParticipant.js

@@ -12,6 +12,7 @@ class HumanParticipant extends Participant {
     socketId,
     watchedGameId,
     token = null,
+    identityName = null,
   }) {
     super({ gameId, name, model, team, teamId });
 
@@ -27,6 +28,15 @@ class HumanParticipant extends Participant {
     this.pendingShake = null;
     this.lastActionTime = clock.now();
     this.lastInputSeq = 0; // номер последнего обработанного ввода (предикшен)
+
+    // возобновление сессии (host-migration этап 4). identityName — ник от
+    // стратегии идентичности до разведения дублей (#2): с ним сверяется
+    // токен RESUME_REQUEST. resumeKey — секрет места (выдаётся на входе в
+    // матч, не логируется). detachedAt — транспорт оборвался, место ждёт
+    // возврата (null — подключён)
+    this.identityName = identityName ?? name;
+    this.resumeKey = null;
+    this.detachedAt = null;
   }
 
   get isNetworked() {

package/src/host/meta/player/ParticipantManager.js

@@ -64,6 +64,7 @@ class ParticipantManager {
       socketId,
       watchedGameId: this._activePlayersList[0] || null,
       token: params.token,
+      identityName: params.name,
     });
 
     this._participants.set(gameId, participant);
@@ -93,8 +94,14 @@ class ParticipantManager {
   }
 
   // восстанавливает человека с исходным gameId (эстафета Worker'ов, Этап 5.2);
-  // занятый id или неизвестная команда — null (запись пропускается)
-  restoreHuman({ gameId, socketId, name, model, team, teamId }) {
+  // занятый id или неизвестная команда — null (запись пропускается).
+  // Поля личности (ник входа, секрет места, цвет ника, токен) переносятся
+  // всегда; игровое состояние (статус, камера, слот респауна, номер ввода) —
+  // только при full: восстановлении посреди раунда (host-migration этап 5),
+  // иначе раунд всё равно начнётся заново
+  restoreHuman(record, { full = false } = {}) {
+    const { gameId, socketId, name, model, team, teamId } = record;
+
     if (this._participants.has(gameId) || !this._teamSizes[team]) {
       return null;
     }
@@ -107,8 +114,20 @@ class ParticipantManager {
       teamId,
       socketId,
       watchedGameId: this._activePlayersList[0] || null,
+      token: record.token ?? null,
+      identityName: record.identityName ?? null,
     });
 
+    participant.chatColor = record.chatColor ?? null;
+    participant.resumeKey = record.resumeKey ?? null;
+
+    if (full) {
+      this._applyPlayState(participant, record);
+      participant.isWatching = record.isWatching !== false;
+      participant.watchedGameId = record.watchedGameId ?? null;
+      participant.lastInputSeq = record.lastInputSeq >>> 0;
+    }
+
     this._participants.set(gameId, participant);
     this._teamSizes[team].add(gameId);
 
@@ -117,7 +136,9 @@ class ParticipantManager {
 
   // восстанавливает scripted-участника с исходным gameId
   // (эстафета Worker'ов, Этап 5.2)
-  restoreScripted({ gameId, name, model, team, teamId }) {
+  restoreScripted(record, { full = false } = {}) {
+    const { gameId, name, model, team, teamId } = record;
+
     if (this._participants.has(gameId) || !this._teamSizes[team]) {
       return null;
     }
@@ -130,12 +151,83 @@ class ParticipantManager {
       teamId,
     });
 
+    participant.chatColor = record.chatColor ?? null;
+
+    if (full) {
+      this._applyPlayState(participant, record);
+    }
+
     this._participants.set(gameId, participant);
     this._teamSizes[team].add(gameId);
 
     return participant;
   }
 
+  _applyPlayState(participant, record) {
+    if (typeof record.status === 'string') {
+      participant.status = record.status;
+    }
+
+    participant.respawnIndex = Number.isInteger(record.respawnIndex)
+      ? record.respawnIndex
+      : null;
+  }
+
+  // ***** контрольная точка (host-migration этап 5) ***** //
+
+  // участники и топология команд. Токенов здесь нет: точка уезжает по сети
+  // к другому игроку, токен — личный секрет участника
+  serialize() {
+    return {
+      humans: this.getHumans().map(p => ({
+        gameId: p.gameId,
+        name: p.name,
+        model: p.model,
+        team: p.team,
+        teamId: p.teamId,
+        status: p.status,
+        isReady: p.isReady,
+        isWatching: p.isWatching,
+        watchedGameId: p.watchedGameId,
+        respawnIndex: p.respawnIndex,
+        lastInputSeq: p.lastInputSeq,
+        chatColor: p.chatColor,
+        resumeKey: p.resumeKey,
+        identityName: p.identityName,
+      })),
+      scripted: this.getScripted().map(p => ({
+        gameId: p.gameId,
+        name: p.name,
+        model: p.model,
+        team: p.team,
+        teamId: p.teamId,
+        status: p.status,
+        respawnIndex: p.respawnIndex,
+        chatColor: p.chatColor,
+      })),
+      teamSizes: Object.fromEntries(
+        Object.entries(this._teamSizes).map(([team, ids]) => [team, [...ids]]),
+      ),
+      activePlayers: [...this._activePlayersList],
+    };
+  }
+
+  // состав команд и список активных из точки — после restoreHuman/
+  // restoreScripted; id, не пережившие восстановление, отбрасываются
+  restoreTopology({ teamSizes = {}, activePlayers = [] } = {}) {
+    for (const [team, ids] of Object.entries(teamSizes)) {
+      if (this._teamSizes[team]) {
+        this._teamSizes[team] = new Set(
+          ids.filter(id => this._participants.has(id)),
+        );
+      }
+    }
+
+    this._activePlayersList = activePlayers.filter(id =>
+      this._participants.has(id),
+    );
+  }
+
   // полностью удаляет участника из реестра (команда + список активных)
   remove(gameId) {
     const participant = this._participants.get(gameId);
@@ -181,9 +273,10 @@ class ParticipantManager {
     return this.getAll().filter(p => p.isScripted);
   }
 
-  // люди, готовые к игре (получатели сетевого кадра)
+  // люди, готовые к игре (получатели сетевого кадра); отсоединённые
+  // (ждут возобновления, host-migration этап 4) кадров не получают
   getNetworkedReady() {
-    return this.getHumans().filter(p => p.isReady);
+    return this.getHumans().filter(p => p.isReady && p.detachedAt === null);
   }
 
   // проверяет уникальность имени по всему реестру (люди + scripted)

package/src/lib/AbstractTimer.js

@@ -37,7 +37,69 @@ class AbstractTimer {
       };
 
       const timerId = clock.setTimeout(wrappedCallback, duration);
-      this._timers.set(key, { timerId, isInterval });
+
+      // срок и исходный колбэк — для остатка времени и паузы (контрольная
+      // точка хоста, host-migration этап 5)
+      this._timers.set(key, {
+        timerId,
+        isInterval,
+        callback,
+        endsAt: clock.now() + duration,
+        leftMs: null,
+      });
+    }
+  }
+
+  /**
+   * Остаток времени setTimeout-таймера (у стоящего на паузе — замороженный).
+   * @protected
+   * @param {string} key - ключ таймера
+   * @returns {number|null} - миллисекунды; null — таймера нет или интервал
+   */
+  _timeLeft(key) {
+    const entry = this._timers.get(key);
+
+    if (!entry || entry.isInterval) {
+      return null;
+    }
+
+    if (entry.leftMs !== null) {
+      return entry.leftMs;
+    }
+
+    return Math.max(0, entry.endsAt - clock.now());
+  }
+
+  /**
+   * Ставит setTimeout-таймеры на паузу: срабатывание снимается, остаток
+   * запоминается, ключ остаётся (_hasTimer по-прежнему true).
+   * @protected
+   * @param {function} [filter] - (key) => boolean; без него — все
+   */
+  _pauseTimers(filter = () => true) {
+    for (const [key, entry] of this._timers) {
+      if (entry.isInterval || entry.leftMs !== null || !filter(key)) {
+        continue;
+      }
+
+      clock.clearTimeout(entry.timerId);
+      entry.leftMs = Math.max(0, entry.endsAt - clock.now());
+    }
+  }
+
+  /**
+   * Снимает с паузы таймеры, поставленные _pauseTimers: каждый дожидается
+   * своего остатка.
+   * @protected
+   * @param {function} [filter] - (key) => boolean; без него — все
+   */
+  _resumeTimers(filter = () => true) {
+    const paused = [...this._timers].filter(
+      ([key, entry]) => entry.leftMs !== null && filter(key),
+    );
+
+    for (const [key, entry] of paused) {
+      this._startTimer(key, entry.callback, entry.leftMs);
     }
   }
 

package/src/lib/Publisher.js

@@ -1,6 +1,7 @@
 /**
  * Observer pattern (Publisher)
  * on: добавляет слушателя (подписчика)
+ * off: снимает слушателя
  * emit: рассылает событие подписчикам
  */
 class Publisher {
@@ -29,6 +30,31 @@ class Publisher {
     });
   }
 
+  /**
+   * Снимает подписчика, добавленного on() с теми же аргументами.
+   * @param {string} type - Тип события.
+   * @param {Function|string} fn - Функция-обработчик или имя метода.
+   * @param {Object} [context] - Контекст, переданный в on().
+   */
+  off(type, fn, context) {
+    const subscribers = this.subs[type];
+
+    if (!subscribers) {
+      return;
+    }
+
+    if (typeof fn !== 'function') {
+      fn = context[fn];
+    }
+
+    // новый массив, а не splice: отписка из обработчика посреди emit не
+    // должна сдвинуть обход и пропустить соседа
+    this.subs[type] = subscribers.filter(
+      sub =>
+        sub.fn !== fn || (context !== undefined && sub.context !== context),
+    );
+  }
+
   /**
    * Рассылает событие указанного типа всем подписчикам.
    * @param {string} type - Тип события.

package/src/lib/capabilities.js

@@ -46,6 +46,11 @@ export const ENGINE_CAPABILITIES = createRegistry('engine-capabilities', [
   // сервис пула `diagnostics` (журнал клиентских ошибок, plan/client-reports);
   // опционален — игра не пишет его в `requires`
   { value: 'diagnostics', since: '0.35.0' },
+  // контрольная точка хоста посреди раунда (host-migration этап 5):
+  // gameConfig.migration.midRound, хуки модулей serializeState/restoreState.
+  // Писать в `requires` не нужно: старый движок флаг просто игнорирует, и
+  // игра на нём мигрирует мягко
+  { value: 'host.migration', since: '0.36.0' },
 ]);
 
 // плоский список имён — то, чем правило контракта B2 проверяет `requires`