vimp-engine 0.35.6 → 0.36.0

package/src/host/host.worker.js

@@ -6,14 +6,18 @@
 // сюда приходят уже разобранные пакеты клиентов, обратно уходят wire-кадры
 // (JSON-строки и бинарные ArrayBuffer'ы через Transferable).
 //
-// Сам хендшейк клиента (порты 0–8) живёт в изоморфной ./PortMachine.js —
+// Сам хендшейк клиента (порты 0–10) живёт в изоморфной ./PortMachine.js —
 // этот файл только адаптер: postMessage-транспорт, лобби-стратегия
 // идентичности и свитч сообщений главного потока.
 
 import authClientConfig from '../config/authClient.js';
 import lobbyConfig from '../config/lobby.js';
 import wsports from '../config/wsports.js';
-import { createHostRuntime } from '../lib/createHostRuntime.js';
+import { encodeCheckpoint, decodeCheckpoint } from '../lib/checkpointCodec.js';
+import {
+  createHostRuntime,
+  preloadHostRuntime,
+} from '../lib/createHostRuntime.js';
 import PortMachine from './PortMachine.js';
 import { createTokenIdentity } from './identity.js';
 
@@ -23,6 +27,10 @@ const PS_TECH_INFORM_DATA = wsports.server.TECH_INFORM_DATA;
 let host = null;
 let portMachine = null;
 
+// комната закрывается (shutdown): новых не пускаем — иначе вошедший вылетел
+// бы через секунды вместе с комнатой
+let shuttingDown = false;
+
 // эстафета Worker'ов (Этап 5.2): socketId → gameId участников, восстановленных
 // из handoff-меты — их порт-машины поднимаются минуя хендшейк
 let handoffClients = null;
@@ -68,21 +76,81 @@ function makeWorkerSocket(socketId) {
   };
 }
 
+// участники эстафеты внутри вкладки: v3 — плоский humans, v4 — формат
+// контрольной точки (participants.humans)
+function handoffHumans(handoff) {
+  return handoff.participants?.humans ?? handoff.humans ?? [];
+}
+
+// готовая контрольная точка уходит главному потоку списком переноса — без
+// копии: 2 точки в секунду не должны стоить сборщику мусора лишних буферов.
+// Буфер кодека принадлежит результату целиком (не view на память wasm)
+function postCheckpoint({ meta, core, final }) {
+  encodeCheckpoint(meta, core)
+    .then(bytes => {
+      const owned =
+        bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+          ? bytes
+          : bytes.slice();
+
+      self.postMessage(
+        {
+          type: 'checkpoint',
+          checkpointId: meta.checkpointId,
+          seq: meta.seq,
+          createdAt: meta.createdAt,
+          final,
+          mode: meta.mode,
+          // игра точки — в дескриптор канала standby: бете не нужно
+          // распаковывать точку ради версии игры (ревью F15)
+          game: meta.room?.game
+            ? { id: meta.room.game.id, version: meta.room.game.version }
+            : null,
+          bytes: owned,
+        },
+        [owned.buffer],
+      );
+    })
+    .catch(e => {
+      self.postMessage({
+        type: 'diagnostic',
+        kind: 'checkpoint',
+        message: e && e.message ? e.message : String(e),
+        stack: e && typeof e.stack === 'string' ? e.stack : null,
+      });
+    });
+}
+
 // инициализация хоста: HostPlugin игры (динамический import по
 // GameManifest, Этап 6.4), ядро, мета, игровой цикл. handoff — состояние
 // эстафеты Worker'ов (Этап 5.2): комната восстанавливается вместо
-// холодного старта, порт-машины клиентов поднимутся минуя хендшейк
-async function onInit(room, handoff = null) {
+// холодного старта, порт-машины клиентов поднимутся минуя хендшейк.
+// checkpoint — сжатая контрольная точка (host-migration этап 5): матч
+// поднимается на паузе, люди ждут RESUME, старт — start_after_restore
+async function onInit(room, handoff = null, checkpointBytes = null, seqFloor) {
+  const checkpoint = checkpointBytes
+    ? await decodeCheckpoint(checkpointBytes)
+    : null;
+
   // общая с headless-runner'ом сборка (lib/createHostRuntime.js) — чтобы
   // отладочный прогон крутил ровно тот код, что и прод
   const runtime = await createHostRuntime(room, {
     hostOptions: {
-      onMapChange: mapName => self.postMessage({ type: 'map_changed', mapName }),
-      handoff,
+      // map_changed остаётся для главного потока до host-migration этапа 2
+      onMapChange: mapName =>
+        self.postMessage({ type: 'map_changed', mapName }),
+      onLobbyInfoChange: info => self.postMessage({ type: 'lobby_info', info }),
+      handoff: checkpoint ? null : handoff,
+      checkpoint,
+      seqFloor: Number(seqFloor) || 0,
     },
   });
 
   host = runtime.host;
+  host.setCheckpointSink(postCheckpoint);
+  // здоровье хоста (host-migration этап 9a): главный поток решает, не пора
+  // ли отдать роль
+  host.setHealthSink(health => self.postMessage({ type: 'health', health }));
 
   // в лобби личность игрока — claim identity-токена, проверенного по JWKS
   // мастера (Этап B3); свободного ввода имени в форме игры нет
@@ -96,25 +164,44 @@ async function onInit(room, handoff = null) {
       jwksUrl: lobbyConfig.auth.jwksUrl,
       issuer: authClientConfig.issuer,
     }),
+    // возобновление сессии (host-migration этап 4) — только в лобби:
+    // оборвавшийся гость держит место resumeGraceMs и возвращается в него
+    resumeGraceMs: runtime.game.resumeGraceMs,
+    resumeRequestTimeoutMs: runtime.game.resumeRequestTimeoutMs,
   });
 
   const seed = runtime.seed;
 
-  if (handoff) {
-    handoffClients = new Map(handoff.humans.map(h => [h.socketId, h.gameId]));
+  if (handoff && !checkpoint) {
+    handoffClients = new Map(
+      handoffHumans(handoff).map(h => [h.socketId, h.gameId]),
+    );
   }
 
   // мастеру нужна фактическая карта комнаты (после эстафеты — восстановленная)
-  self.postMessage({ type: 'ready', mapName: host.currentMap, seed });
+  self.postMessage({
+    type: 'ready',
+    mapName: host.currentMap,
+    lobbyInfo: host.lobbyInfo,
+    seed,
+  });
 }
 
 // новое подключение клиента: участник из handoff-меты уже восстановлен в
 // HostGame — его порт-машина поднимается сразу в игровом состоянии
-function onConnect(socketId) {
+// resume — переподключение гостя (host-migration этап 4): порт-машина ждёт
+// RESUME_REQUEST вместо хендшейка
+function onConnect(socketId, resume = false) {
   if (!portMachine) {
     return;
   }
 
+  // закрытие без кода: в лобби-режиме гость уходит искать другую комнату
+  if (shuttingDown) {
+    self.postMessage({ type: 'close_client', socketId });
+    return;
+  }
+
   const restoredGameId = handoffClients?.get(socketId);
 
   if (restoredGameId !== undefined) {
@@ -123,7 +210,7 @@ function onConnect(socketId) {
     return;
   }
 
-  portMachine.connect(socketId);
+  portMachine.connect(socketId, { resume });
 }
 
 // отладочные действия хоста (этап 6): запись живого матча в формат сценария
@@ -171,7 +258,7 @@ self.onmessage = async event => {
   switch (msg.type) {
     case 'init':
       try {
-        await onInit(msg.room, msg.handoff);
+        await onInit(msg.room, msg.handoff, msg.checkpoint, msg.seqFloor);
       } catch (e) {
         // сбой загрузки WASM/конфига/handoff-меты — сообщить главному
         // потоку, не виснуть (при эстафете тот возобновит старый Worker)
@@ -185,8 +272,29 @@ self.onmessage = async event => {
       }
       break;
 
+    // прогрев Worker'а преемника (host-migration этап 6): плагин и wasm
+    // готовы, матча нет — его поднимет init с контрольной точкой (этап 7)
+    case 'preload':
+      try {
+        const { wasmCompiled } = await preloadHostRuntime(msg.room);
+
+        self.postMessage({
+          type: 'preloaded',
+          gameId: msg.room?.game?.id ?? null,
+          gameVersion: msg.room?.game?.version ?? null,
+          wasmCompiled,
+        });
+      } catch (e) {
+        self.postMessage({
+          type: 'error',
+          message: e && e.message ? e.message : String(e),
+          stack: e && typeof e.stack === 'string' ? e.stack : null,
+        });
+      }
+      break;
+
     case 'connect':
-      onConnect(msg.socketId);
+      onConnect(msg.socketId, msg.resume === true);
       break;
 
     case 'message':
@@ -201,10 +309,20 @@ self.onmessage = async event => {
       host?.updateMaps(msg.maps);
       break;
 
-    // мастер подтвердил регистрацию комнаты (кодревью №1) — hostId+секрет
-    // нужны PlayerDataSync для атрибуции последующих rank/state-flush
+    // мастер подтвердил регистрацию комнаты — roomId+секрет эпохи нужны
+    // PlayerDataSync для атрибуции последующих rank/state-flush
+    case 'set_room':
+      host?.setRoom({
+        roomId: msg.roomId,
+        roomSecret: msg.roomSecret,
+        epoch: msg.epoch,
+      });
+      break;
+
+    // имя того же сообщения у главного потока до host-migration этапа 2:
+    // страница, загруженная до деплоя, поднимает Worker по свежему манифесту
     case 'set_host_id':
-      host?.setHostId(msg.hostId, msg.hostSecret);
+      host?.setRoom({ roomId: msg.hostId, roomSecret: msg.hostSecret });
       break;
 
     // отладочный контур (этап 6 плана plan/done/ai-debug): единственный вход в
@@ -223,6 +341,11 @@ self.onmessage = async event => {
       );
       break;
 
+    // плановая передача хоста вытесняет эстафету, ещё ждущую границы раунда
+    case 'cancel_handoff':
+      host?.cancelHandoff();
+      break;
+
     // новый Worker не поднялся — продолжаем жить на этой версии
     case 'resume':
       host?.resumeAfterHandoff();
@@ -233,5 +356,88 @@ self.onmessage = async event => {
       handoffClients = null;
       host?.completeHandoff(new Set(portMachine ? portMachine.socketIds : []));
       break;
+
+    // контрольные точки (host-migration этап 5)
+
+    // периодические точки: снимаются на границе кадра не чаще intervalMs
+    case 'checkpoint_start':
+      host?.startCheckpoints(msg.intervalMs);
+      break;
+
+    case 'checkpoint_stop':
+      host?.stopCheckpoints();
+      break;
+
+    // одна точка на ближайшей границе кадра (final — финальная перед
+    // плановой передачей)
+    case 'checkpoint_request':
+      host?.requestCheckpoint({ final: msg.final === true });
+      break;
+
+    // матч поднят из точки: запустить цикл и таймеры. waitForResume —
+    // промоушен преемника (этап 7.4): старт, когда вернулись все люди точки
+    // или истёк resumeWaitMs; не вернувшимся — ожидание resumeGraceMs.
+    // reason (этап 9) — причина передачи для сообщения игрокам; старый
+    // главный поток её не шлёт
+    case 'start_after_restore':
+      if (msg.waitForResume === true) {
+        host?.startAfterResume(ids => portMachine?.startGraceFor(ids), {
+          reason: typeof msg.reason === 'string' ? msg.reason : null,
+        });
+      } else {
+        host?.startAfterRestore();
+      }
+      break;
+
+    // плановая передача хоста (этап 8d): дождаться границы раунда (у игры
+    // с migration.midRound — ответ сразу)
+    case 'round_boundary_wait':
+      host?.awaitRoundBoundary(() =>
+        self.postMessage({ type: 'round_boundary' }),
+      );
+      break;
+
+    case 'round_boundary_cancel':
+      host?.cancelRoundBoundary();
+      break;
+
+    case 'freeze':
+      host?.freeze();
+      break;
+
+    case 'unfreeze':
+      host?.unfreeze();
+      break;
+
+    // хост закрывает комнату («Leave server» последнего человека): закрыть
+    // игры участников и дождаться записи профилей — не дольше timeoutMs
+    case 'shutdown': {
+      const timeoutMs =
+        Number(msg.timeoutMs) > 0 ? Number(msg.timeoutMs) : 3000;
+      let timer = null;
+
+      shuttingDown = true;
+
+      try {
+        await Promise.race([
+          host?.destroy(),
+          new Promise(resolve => {
+            timer = setTimeout(resolve, timeoutMs);
+          }),
+        ]);
+      } catch (e) {
+        self.postMessage({
+          type: 'diagnostic',
+          kind: 'shutdown',
+          message: e && e.message ? e.message : String(e),
+          stack: e && typeof e.stack === 'string' ? e.stack : null,
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+
+      self.postMessage({ type: 'shutdown_done' });
+      break;
+    }
   }
 };

package/src/host/meta/SocketManager.js

@@ -40,6 +40,8 @@ export default class SocketManager {
     this._PORT_VOTE_DATA = ports.VOTE_DATA;
     this._PORT_KEYSET_DATA = ports.KEYSET_DATA;
     this._PORT_ACCOLADES_DATA = ports.ACCOLADES_DATA;
+    this._PORT_SESSION_DATA = ports.SESSION_DATA;
+    this._PORT_RESUME_RESULT = ports.RESUME_RESULT;
 
     this._soundCues = soundCues;
     this._initialVote = initialVote;
@@ -436,6 +438,24 @@ export default class SocketManager {
     }
   }
 
+  /**
+   * Отправка секрета возобновления сессии (host-migration этап 4).
+   * @param {string} socketId
+   * @param {Object} data - { resumeKey, gameId }.
+   */
+  sendSessionData(socketId, data) {
+    this._send(socketId, this._PORT_SESSION_DATA, data);
+  }
+
+  /**
+   * Ответ на RESUME_REQUEST (host-migration этап 4).
+   * @param {string} socketId
+   * @param {Object} data - { ok: true, gameId, epoch } | { ok: false, reason }.
+   */
+  sendResumeResult(socketId, data) {
+    this._send(socketId, this._PORT_RESUME_RESULT, data);
+  }
+
   /**
    * Отправка команды смены имени.
    * @param {string} socketId

package/src/host/meta/core/RoundManager.js

@@ -79,9 +79,15 @@ class RoundManager {
     // идёт дальше, и второй раз `deaths` той же команде не пишется
     this._wipedTeamIds = new Set();
     this._removedPlayersList = []; // gameId игроков для удаления с полотна
+    // карта, подменённая игрой (overrideMapData) в клиентском виде, или null —
+    // контрольной точке она нужна отдельно от карты каталога
+    this._mapOverride = null;
+    this._baseMapData = null;
 
     // эстафета Worker'ов (Этап 5.2): колбэк переноса на границе раунда
     this._handoffCallback = null;
+    // плановая передача хоста ждёт границы раунда (host-migration этап 8d)
+    this._boundaryCallback = null;
   }
 
   get currentMap() {
@@ -92,6 +98,12 @@ class RoundManager {
     return this._currentMapData;
   }
 
+  // JSON текущей карты в виде каталога (до масштабирования и подмены игрой)
+  // — контрольная точка везёт его с собой: каталог преемника мог измениться
+  get baseMapData() {
+    return this._baseMapData;
+  }
+
   get removedPlayersList() {
     return this._removedPlayersList;
   }
@@ -113,11 +125,15 @@ class RoundManager {
   }
 
   // подготавливает данные текущей карты (масштабирование) без пересоздания
-  // мира — общий шаг createMap и восстановления эстафеты (Этап 5.2)
-  _prepareMapData() {
+  // мира — общий шаг createMap и восстановления эстафеты (Этап 5.2).
+  // source — JSON карты из контрольной точки (host-migration этап 5): та
+  // самая карта, что лежит в дампе ядра, даже если каталог уже другой
+  _prepareMapData(source = this._maps[this._currentMap]) {
+    this._mapOverride = null;
+    this._baseMapData = source;
     this._currentMapData = {
       scale: this._mapScale,
-      ...this._maps[this._currentMap],
+      ...source,
     };
 
     // если нет индивидуального конструктора для создания карты
@@ -130,13 +146,58 @@ class RoundManager {
 
   // восстанавливает карту после эстафеты Worker'ов (Этап 5.2): без
   // пересоздания мира и рассылки клиентам — мир соберёт первый
-  // initiateNewRound после переноса
-  restoreMap(mapName) {
+  // initiateNewRound после переноса, а при восстановлении посреди раунда
+  // (host-migration этап 5) он уже внутри дампа ядра: здесь только
+  // JS-сторона, ни createMap, ни load_map. scripted.createMap запоминает
+  // точки респауна и ботов в ядре не создаёт
+  restoreMap(mapName, { mapData = null, override = null } = {}) {
     this._currentMap = mapName;
-    this._prepareMapData();
+    this._prepareMapData(mapData ?? this._maps[mapName]);
+
+    if (override) {
+      this.overrideMapData(override);
+    }
+
     this._scripted.createMap(this._scaledMapData);
   }
 
+  // состояние раунда для контрольной точки (host-migration этап 5)
+  serialize() {
+    return {
+      currentMap: this._currentMap,
+      override: this._mapOverride,
+      isRoundEnding: this._isRoundEnding,
+      wipedTeamIds: [...this._wipedTeamIds],
+      removedPlayers: [...this._removedPlayersList],
+      startMapNumber: this._startMapNumber,
+    };
+  }
+
+  // флаги раунда из контрольной точки (карту поднимает restoreMap)
+  restoreRound({
+    isRoundEnding = false,
+    wipedTeamIds = [],
+    removedPlayers = [],
+    startMapNumber = 0,
+  } = {}) {
+    this._isRoundEnding = isRoundEnding === true;
+    this._wipedTeamIds = new Set(wipedTeamIds);
+    this._removedPlayersList = [...removedPlayers];
+    this._startMapNumber = startMapNumber;
+  }
+
+  // отложенная смена карты: цель объявлена таймеру, чтобы контрольная точка
+  // могла её перенести (duration — остаток при восстановлении)
+  scheduleMapChange(mapName, duration) {
+    this._timerManager.startMapChangeDelay(
+      () => {
+        this._currentMap = mapName;
+        this.createMap();
+      },
+      { targetMap: mapName, duration },
+    );
+  }
+
   // создает карту
   createMap() {
     this._prepareMapData();
@@ -245,6 +306,7 @@ class RoundManager {
     if (mapData) {
       this._currentMapData = mapData;
       this._scaledMapData = scaleMapData(mapData);
+      this._mapOverride = mapData;
     }
   }
 
@@ -265,6 +327,18 @@ class RoundManager {
     this._handoffCallback = null;
   }
 
+  // плановая передача хоста в игре без migration.midRound (host-migration
+  // этап 8d): колбэк сработает один раз, когда стартует следующий раунд.
+  // Раунд не придерживается — бета всё равно начнёт его заново из мягкой
+  // точки, а сорвавшаяся передача не должна оставить комнату без раунда
+  onRoundBoundary(cb) {
+    this._boundaryCallback = cb;
+  }
+
+  cancelRoundBoundary() {
+    this._boundaryCallback = null;
+  }
+
   // запуск нового раунда
   initiateNewRound() {
     this._timerManager.stopRoundTimer();
@@ -282,6 +356,13 @@ class RoundManager {
 
     this._startRound();
     this._timerManager.startRoundTimer();
+
+    if (this._boundaryCallback) {
+      const cb = this._boundaryCallback;
+
+      this._boundaryCallback = null;
+      cb();
+    }
   }
 
   // начало раунда
@@ -862,10 +943,7 @@ class RoundManager {
           if (result === 'Yes' && this._maps[mapName]) {
             this._chat.pushSystem('VOTE_PASSED');
             this._chat.pushSystem('MAP_NEXT', [mapName]);
-            this._timerManager.startMapChangeDelay(() => {
-              this._currentMap = mapName;
-              this.createMap();
-            });
+            this.scheduleMapChange(mapName);
           } else {
             this._chat.pushSystem('VOTE_FAILED');
           }
@@ -890,10 +968,7 @@ class RoundManager {
           if (resultingMapName && this._maps[resultingMapName]) {
             this._chat.pushSystem('VOTE_PASSED');
             this._chat.pushSystem('MAP_NEXT', [resultingMapName]);
-            this._timerManager.startMapChangeDelay(() => {
-              this._currentMap = resultingMapName;
-              this.createMap();
-            });
+            this.scheduleMapChange(resultingMapName);
           } else {
             // если никто не проголосовал, продлеваем время текущей карты
             this._timerManager.stopMapTimer();

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

@@ -104,7 +104,10 @@ export default class Accolades {
       return;
     }
 
-    if (this._lastRefreshAt !== null && now - this._lastRefreshAt < this._interval) {
+    if (
+      this._lastRefreshAt !== null &&
+      now - this._lastRefreshAt < this._interval
+    ) {
       return;
     }
 

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

@@ -172,6 +172,36 @@ class Panel {
     return panelData;
   }
 
+  // значения панели участников для контрольной точки (host-migration
+  // этап 5): { [gameId]: values }. Несостоявшиеся изменения не переносятся —
+  // возобновлённый клиент получает панель целиком
+  serialize() {
+    return Object.fromEntries(
+      Object.entries(this._data).map(([gameId, user]) => [
+        gameId,
+        { ...user.values },
+      ]),
+    );
+  }
+
+  // применяет значения из точки к уже заведённым (addUser) участникам;
+  // поля вне схемы панели отбрасываются
+  restore(state = {}) {
+    for (const [gameId, values] of Object.entries(state)) {
+      const user = this._data[gameId];
+
+      if (!user) {
+        continue;
+      }
+
+      for (const [param, value] of Object.entries(values ?? {})) {
+        if (Object.hasOwn(this._fields, param)) {
+          user.values[param] = value;
+        }
+      }
+    }
+  }
+
   // возвращает пустые данные (ключи без значений)
   getEmptyPanel() {
     return [`t:${this._lastSentRoundTime}`].concat(this._emptyPanel);