vimp-engine 0.40.0 → 0.42.0

package/src/client/network/HostHealthPolicy.js

@@ -2,27 +2,21 @@
 // здоровья Worker'а (HostController.onHealth, сэмпл раз в ~1 с), видимости
 // вкладки и наличия беты решает, когда отдать роль бете.
 //
-// - Мягкая перегрузка (среднее tickRate последних сэмплов окна
-//   overloadWindowMs ниже overloadTickRate) — передача, отложенная до
-//   границы раунда (PlannedHandoff defer).
-// - Жёсткая (среднее окна criticalWindowMs ниже criticalTickRate или lostMs
-//   > 0 у lostWindows сэмплов подряд) и скрытая вкладка дольше
-//   hiddenHandoffMs — передача сразу; ждущую границы раунда — ускорить.
-// - Пока своя отложенная передача ждёт границы, а все сэмплы окна
-//   recoverWindowMs выше recoverTickRate (гистерезис над порогом входа) —
-//   отменить её: иначе передача сработала бы вхолостую на границе раунда.
+// Передача (плановая, стартует сразу) — при любом из условий:
+// - мягкая перегрузка: среднее tickRate последних сэмплов окна
+//   overloadWindowMs ниже overloadTickRate;
+// - жёсткая: среднее окна criticalWindowMs ниже criticalTickRate или
+//   lostMs > 0 у lostWindows сэмплов подряд;
+// - скрытая вкладка дольше hiddenHandoffMs.
 //
 // Новая передача — только при бете, после minHostTenureMs в роли хоста и
 // autoHandoffCooldownMs с прошлой авто-передачи этой вкладки (с её запуска,
-// при любом исходе). Отмена по нормализации кулдаун возвращает: от мигания
-// защищают гистерезис и окна. Политика живёт дольше роли хоста — кулдаун
-// переживает смену ролей.
+// при любом исходе). Политика живёт дольше роли хоста — кулдаун переживает
+// смену ролей.
 //
 // Без DOM: передачу, часы и таймеры инъектирует владелец
 // (client/session/HandoffFlow.js).
 
-export const AUTO_HANDOFF_REASONS = ['overload', 'hidden'];
-
 // сэмпла нет дольше этого (в интервалах здоровья) — матч стоял, окна заново
 const SAMPLE_GAP_INTERVALS = 2;
 
@@ -32,9 +26,8 @@ export default class HostHealthPolicy {
   /**
    * @param {Object} options
    * @param {Object} options.config - lobby.migration.auto.
-   * @param {Object} options.handoff - передача: { start({ reason, defer })
-   *   → boolean, hurry(reason) → boolean, cancelDeferred() → boolean,
-   *   deferredReason() → string|null (причина передачи, ждущей границы) }.
+   * @param {Object} options.handoff - передача: { start({ reason }) →
+   *   boolean (false — передача уже идёт или вкладка не хост) }.
    * @param {number} [options.healthIntervalMs] - период сэмплов Worker'а.
    * @param {Function} [options.now] - монотонные часы, мс.
    * @param {Object} [options.timers] - { setTimeout, clearTimeout } (тесты).
@@ -58,7 +51,6 @@ export default class HostHealthPolicy {
     this._hiddenTimer = null;
     this._hiddenOutcome = null;
     this._lastAutoAt = null;
-    this._cooldownBefore = null;
     this._samples = [];
     this._lastSampleAt = null;
   }
@@ -147,7 +139,6 @@ export default class HostHealthPolicy {
     const keep = Math.max(
       this._count(this._config.overloadWindowMs),
       this._count(this._config.criticalWindowMs),
-      this._count(this._config.recoverWindowMs),
       this._config.lostWindows,
     );
 
@@ -168,25 +159,8 @@ export default class HostHealthPolicy {
       return;
     }
 
-    if (this._critical()) {
+    if (this._critical() || this._overloaded()) {
       this._handOverNow('overload');
-      return;
-    }
-
-    const ownDeferred = AUTO_HANDOFF_REASONS.includes(
-      this._handoff.deferredReason(),
-    );
-
-    if (ownDeferred) {
-      if (this._recovered() && this._handoff.cancelDeferred()) {
-        this._lastAutoAt = this._cooldownBefore;
-      }
-
-      return;
-    }
-
-    if (this._overloaded() && this._mayStart()) {
-      this._start('overload', true);
     }
   }
 
@@ -235,25 +209,15 @@ export default class HostHealthPolicy {
     return waitMs > 0 ? 'blocked' : 'unexplained';
   }
 
-  // немедленная передача: ждущую границы — ускорить, иначе начать
   _handOverNow(reason) {
-    if (!this._enabled() || !this._successor) {
-      return false;
-    }
-
-    if (this._handoff.deferredReason() !== null) {
-      return this._handoff.hurry(reason);
-    }
-
-    return this._mayStart() && this._start(reason, false);
+    return this._mayStart() && this._start(reason);
   }
 
-  _start(reason, defer) {
-    if (!this._handoff.start({ reason, defer })) {
+  _start(reason) {
+    if (!this._handoff.start({ reason })) {
       return false;
     }
 
-    this._cooldownBefore = this._lastAutoAt;
     this._lastAutoAt = this._now();
 
     return true;
@@ -312,15 +276,6 @@ export default class HostHealthPolicy {
     );
   }
 
-  _recovered() {
-    const window = this._last(this._count(this._config.recoverWindowMs));
-
-    return (
-      window !== null &&
-      window.every(s => s.tickRate > this._config.recoverTickRate)
-    );
-  }
-
   _resetSamples() {
     this._samples = [];
     this._lastSampleAt = null;

package/src/client/network/PlannedHandoff.js

@@ -6,9 +6,9 @@
 // возвращается гостем RESUME'ом к новому хосту, иначе — уход в лобби.
 //
 // Исход у передачи один, и объявляется он один раз. Дедлайн deadlineMs
-// отсчитывается от handoff_begin и перекрывает handoffTimeoutMs мастера с
-// запасом на дорогу ответа: обычно отмену объявляет мастер
-// (handoff_aborted), дедлайн — страховка. Медленный ответ (нет handoff_go за
+// отсчитывается от handoff_begin и перекрывает ожидание мастером первой
+// точки беты и его handoffTimeoutMs с запасом на дорогу ответа: обычно
+// отмену объявляет мастер (handoff_aborted), дедлайн — страховка. Медленный ответ (нет handoff_go за
 // slowAfterMs) — не отказ, а повод показать «медленная связь» (onSlow):
 // поздний handoff_go до дедлайна штатно замораживает матч и шлёт финальную
 // точку — иначе бета откатила бы всех к периодической.
@@ -19,13 +19,8 @@
 // host_leaving мастеру — аварийная миграция с последней периодической
 // точкой (при обрыве сигналинга без него: обрыв WS мастер видит сам).
 //
-// Отложенная передача (defer, этап 8d): handoff_begin уходит на границе
-// раунда (HostController.awaitRoundBoundary — игра без migration.midRound
-// иначе отняла бы раунд у всех; у игры с midRound Worker отвечает сразу),
-// но не позже deferMaxMs. Пока ожидание идёт, передача уже начата: повтор
-// игнорируется, а дедлайн и onSlow отсчитываются от handoff_begin.
-// Автотриггеры (этап 9b) ожидание сокращают (hurry — жёсткая перегрузка,
-// скрытая вкладка) или снимают (cancelDeferred — нагрузка нормализовалась).
+// handoff_begin уходит сразу, посреди раунда: финальная точка несёт дамп
+// ядра, и бета продолжает раунд с того же тика.
 //
 // Без DOM: сигналинг, Worker хоста и таймеры инъектируются.
 
@@ -63,9 +58,7 @@ export default class PlannedHandoff {
    * @param {number} [options.slowAfterMs] - нет handoff_go за это время —
    *   onSlow (передача продолжается).
    * @param {number} [options.deadlineMs] - общий дедлайн передачи от
-   *   handoff_begin (больше handoffTimeoutMs мастера).
-   * @param {number} [options.deferMaxMs] - потолок ожидания границы раунда
-   *   отложенной передачи.
+   *   handoff_begin (больше handoffBetaWaitMs + handoffTimeoutMs мастера).
    * @param {Function} [options.onSlow] - () мастер отвечает медленно.
    * @param {Function} [options.onFrozen] - ({ epoch }) матч заморожен,
    *   финальная точка запрошена; epoch — эпоха преемника.
@@ -81,8 +74,7 @@ export default class PlannedHandoff {
     getRoom,
     getController,
     slowAfterMs = 3000,
-    deadlineMs = 10000,
-    deferMaxMs = 30000,
+    deadlineMs = 12000,
     onSlow = () => {},
     onFrozen = () => {},
     onReleased = () => {},
@@ -95,7 +87,6 @@ export default class PlannedHandoff {
     this._getController = getController;
     this._slowAfterMs = slowAfterMs;
     this._deadlineMs = deadlineMs;
-    this._deferMaxMs = deferMaxMs;
     this._onSlow = onSlow;
     this._onFrozen = onFrozen;
     this._onReleasedCb = onReleased;
@@ -103,15 +94,13 @@ export default class PlannedHandoff {
     this._onLeave = onLeave;
     this._timers = timers;
 
-    // null | 'deferred' (ждём границы раунда) | 'requested' (ждём
-    // handoff_go) | 'frozen' (ждём host_released)
+    // null | 'requested' (ждём handoff_go) | 'frozen' (ждём host_released)
     this._phase = null;
     this._room = null;
     this._reason = null;
     this._stay = true;
     this._slowTimer = null;
     this._deadlineTimer = null;
-    this._deferTimer = null;
   }
 
   // передача идёт: повторный start игнорируется
@@ -119,14 +108,9 @@ export default class PlannedHandoff {
     return this._phase !== null;
   }
 
-  // передача ждёт границы раунда: матч ещё идёт, мастер ещё не спрошен
-  get deferred() {
-    return this._phase === 'deferred';
-  }
-
-  // причина идущей передачи (null — передачи нет)
-  get reason() {
-    return this._reason;
+  // матч заморожен в ожидании нового хоста
+  get frozen() {
+    return this._phase === 'frozen';
   }
 
   // идёт передача уходящего хоста (stay: false)
@@ -140,14 +124,12 @@ export default class PlannedHandoff {
    * @param {string} options.reason - 'leave' | 'handover' | 'overload' |
    *   'hidden' | 'network' (этап 9) | 'vote' (этап 10).
    * @param {boolean} [options.stay] - остаться в комнате гостем.
-   * @param {boolean} [options.defer] - дождаться границы раунда.
    * @returns {boolean} false — передача уже идёт или вкладка не хост.
    */
-  start({ reason, stay = true, defer = false }) {
+  start({ reason, stay = true }) {
     const room = this._getRoom();
-    const controller = this._getController();
 
-    if (this.active || !room || !controller) {
+    if (this.active || !room || !this._getController()) {
       return false;
     }
 
@@ -159,65 +141,11 @@ export default class PlannedHandoff {
       this._signaling.publisher.on(type, handler, this);
     }
 
-    if (!defer) {
-      this._begin();
-      return true;
-    }
-
-    this._phase = 'deferred';
-    this._deferTimer = this._timers.setTimeout(() => {
-      this._deferTimer = null;
-      this._getController()?.cancelRoundBoundary();
-      this._begin();
-    }, this._deferMaxMs);
-    controller.awaitRoundBoundary(() => this._onBoundary());
-
-    return true;
-  }
-
-  /**
-   * Не ждать границы раунда: вопрос мастеру сразу, с новой причиной.
-   * @param {string} [reason] - причина вместо исходной.
-   * @returns {boolean} false — передача не в ожидании границы.
-   */
-  hurry(reason = this._reason) {
-    if (this._phase !== 'deferred') {
-      return false;
-    }
-
-    this._clearDeferTimer();
-    this._getController()?.cancelRoundBoundary();
-    this._reason = reason;
     this._begin();
 
     return true;
   }
 
-  /**
-   * Снять передачу, ждущую границы раунда, — тихо, без колбэков (мастер
-   * ещё не спрашивался, матч не замораживался).
-   * @returns {boolean} false — передача не в ожидании границы.
-   */
-  cancelDeferred() {
-    if (this._phase !== 'deferred') {
-      return false;
-    }
-
-    this._finish();
-
-    return true;
-  }
-
-  // граница раунда наступила (у игры с midRound — сразу)
-  _onBoundary() {
-    if (this._phase !== 'deferred') {
-      return;
-    }
-
-    this._clearDeferTimer();
-    this._begin();
-  }
-
   // вопрос мастеру: с этого момента идут onSlow и дедлайн
   _begin() {
     const room = this._room;
@@ -274,10 +202,9 @@ export default class PlannedHandoff {
     }
   }
 
-  // бета не заняла комнату: эпоха прежняя, матч продолжается здесь.
-  // Отложенная передача мастера ещё не спрашивала — отмена не про неё
+  // бета не заняла комнату: эпоха прежняя, матч продолжается здесь
   _onAborted(msg) {
-    if (this._ownRoom(msg) && this._phase !== 'deferred') {
+    if (this._ownRoom(msg)) {
       this._cancel('aborted');
     }
   }
@@ -329,11 +256,6 @@ export default class PlannedHandoff {
   _finish() {
     this._clearSlowTimer();
 
-    if (this._phase === 'deferred') {
-      this._clearDeferTimer();
-      this._getController()?.cancelRoundBoundary();
-    }
-
     if (this._deadlineTimer !== null) {
       this._timers.clearTimeout(this._deadlineTimer);
       this._deadlineTimer = null;
@@ -350,13 +272,6 @@ export default class PlannedHandoff {
     this._reason = null;
   }
 
-  _clearDeferTimer() {
-    if (this._deferTimer !== null) {
-      this._timers.clearTimeout(this._deferTimer);
-      this._deferTimer = null;
-    }
-  }
-
   _clearSlowTimer() {
     if (this._slowTimer !== null) {
       this._timers.clearTimeout(this._slowTimer);

package/src/client/network/SessionSupervisor.js

@@ -12,7 +12,8 @@ import wsports from '../../config/wsports.js';
 // принимает владелец (client/main.js) по колбэкам.
 //
 // Состояния: connecting → handshake → inGame → reconnecting → inGame | closed;
-// любое живое → migrating → reconnecting (новый хост) | closed.
+// любое живое → migrating → reconnecting (новый хост) | closed. Вход, каналы
+// которого не открылись, повторяется в connecting (joinRetries).
 
 const PC_RESUME_REQUEST = wsports.client.RESUME_REQUEST;
 
@@ -68,10 +69,13 @@ export default class SessionSupervisor {
    * @param {Object|null} [opts.reconnect] - null — переподключения нет
    *   (solo, вкладка-хост на loopback). Иначе:
    *   { createTransport() → новый транспорт с resume (уже connect'нутый),
-   *     getToken() → identity-токен для RESUME_REQUEST }.
+   *     getToken() → identity-токен для RESUME_REQUEST,
+   *     createJoinTransport() → новый транспорт обычного входа (повтор
+   *     входа, каналы которого не открылись; без него такой сбой
+   *     терминален) }.
    * @param {Object} [opts.timing] - { reconnectWindowMs, reconnectBaseDelayMs,
    *   reconnectMaxDelayMs, hostSilenceMs, migrationWaitMs,
-   *   resumeSilenceGraceMs }
+   *   resumeSilenceGraceMs, joinRetries }
    *   (config/lobby.js → session).
    * @param {Object} [opts.clock] - часы и таймеры (тесты).
    */
@@ -108,8 +112,11 @@ export default class SessionSupervisor {
     this._silenceMs = timing.hostSilenceMs ?? 3000;
     this._migrationWaitMs = timing.migrationWaitMs ?? 20000;
     this._resumeSilenceGraceMs = timing.resumeSilenceGraceMs ?? 3000;
+    this._joinRetries = timing.joinRetries ?? 2;
 
     this._state = S.connecting;
+    // каналы хоть одного транспорта открывались (P2P поднималось)
+    this._everOpened = false;
     this._transport = null;
     this._handlers = null;
 
@@ -126,6 +133,8 @@ export default class SessionSupervisor {
     this._awaitingFrame = false;
 
     this._attempt = 0;
+    // повторы первого входа (каналы ещё ни разу не открывались)
+    this._joinAttempt = 0;
     this._attemptTimer = null;
     this._windowTimer = null;
     this._migrationTimer = null;
@@ -139,6 +148,12 @@ export default class SessionSupervisor {
     return this._state;
   }
 
+  // каналы транспорта открывались хоть раз: false у закрытой сессии —
+  // P2P так и не поднялось (несостоявшийся вход)
+  get everOpened() {
+    return this._everOpened;
+  }
+
   get transport() {
     return this._transport;
   }
@@ -552,6 +567,8 @@ export default class SessionSupervisor {
       return;
     }
 
+    this._everOpened = true;
+
     if (this._state === S.connecting) {
       this._setState(S.handshake);
       return;
@@ -605,9 +622,40 @@ export default class SessionSupervisor {
       return;
     }
 
+    if (this._canRetryJoin()) {
+      this._scheduleJoinRetry();
+      return;
+    }
+
     this._terminate();
   }
 
+  // вход, каналы которого ни разу не открылись (сбой WebRTC-согласования,
+  // ICE не сошёлся), повторяется свежим транспортом: такие сбои часто
+  // разовые. Закрытие входа после открытия каналов терминально
+  _canRetryJoin() {
+    return (
+      this._state === S.connecting &&
+      !this._everOpened &&
+      !this._userLeft &&
+      typeof this._reconnect?.createJoinTransport === 'function' &&
+      this._joinAttempt < this._joinRetries &&
+      !this._isTerminalClose()
+    );
+  }
+
+  _scheduleJoinRetry() {
+    this._joinAttempt += 1;
+
+    this._attemptTimer = this._clock.setTimeout(() => {
+      this._attemptTimer = null;
+
+      if (this._state === S.connecting && !this._userLeft) {
+        this._setTransport(this._reconnect.createJoinTransport());
+      }
+    }, this._backoffDelay(this._joinAttempt));
+  }
+
   // нетерминальным бывает только обрыв посреди матча, у которого есть место
   // для возврата и кому возвращаться
   _canResume() {
@@ -666,17 +714,18 @@ export default class SessionSupervisor {
   }
 
   _scheduleAttempt() {
-    const delay = Math.min(
-      this._maxDelayMs,
-      this._baseDelayMs * 2 ** (this._attempt - 1),
-    );
-
     this._attemptTimer = this._clock.setTimeout(
       () => this._runAttempt(),
-      delay,
+      this._backoffDelay(this._attempt),
     );
   }
 
+  // пауза перед попыткой номер attempt (с 1): экспонента от
+  // reconnectBaseDelayMs, не выше reconnectMaxDelayMs
+  _backoffDelay(attempt) {
+    return Math.min(this._maxDelayMs, this._baseDelayMs * 2 ** (attempt - 1));
+  }
+
   _clearReconnectTimers() {
     if (this._attemptTimer !== null) {
       this._clock.clearTimeout(this._attemptTimer);

package/src/client/network/SignalingClient.js

@@ -217,7 +217,7 @@ export default class SignalingClient {
     });
   }
 
-  // хост → вкладка уходит (pagehide, «Leave server» без передачи): мастер
+  // хост → вкладка уходит (beforeunload/pagehide, Exit без передачи): мастер
   // начинает аварийную миграцию сразу, не дожидаясь обрыва WS
   hostLeaving(roomId, epoch) {
     this._send({ type: 'host_leaving', roomId, epoch });

package/src/client/network/WebRtcManager.js

@@ -120,6 +120,8 @@ export default class WebRtcManager {
     this._offerRetryMs = offerRetryMs;
     this._retryTimer = null;
     this._offerSent = false;
+    // ответ хоста принят в работу: следующие ответы на этот оффер — дубли
+    this._answerApplying = false;
     // свои ICE-кандидаты: повтор оффера отправляет их заново — прежние
     // ушли хосту, который оффер не принял
     this._sentCandidates = [];
@@ -149,8 +151,19 @@ export default class WebRtcManager {
     return this._iceType;
   }
 
-  // инициирует установку соединения с текущим хостом комнаты
+  // инициирует установку соединения с текущим хостом комнаты. Не
+  // отклоняется: любой сбой установки (pc, каналы, оффер) = обрыв
+  // транспорта, повторы — у супервизора; уже закрытый менеджер _emitClose
+  // не тронет
   async connect(roomId) {
+    try {
+      await this._negotiate(roomId);
+    } catch (e) {
+      this._emitClose();
+    }
+  }
+
+  async _negotiate(roomId) {
     this._roomId = roomId;
 
     const pc = this._peerFactory({ iceServers: this._iceServers });
@@ -245,10 +258,13 @@ export default class WebRtcManager {
       return;
     }
 
+    // ответ хоста уже применяется (_answerApplying): эпоха ставится лишь
+    // после setRemoteDescription, но повторять оффер уже поздно
     if (
       msg?.code !== 'migrating' ||
       this._closed ||
       !this._offerSent ||
+      this._answerApplying ||
       this._epoch !== null ||
       this._retryTimer !== null
     ) {
@@ -299,11 +315,30 @@ export default class WebRtcManager {
       return;
     }
 
+    // дубль или опоздавший ответ: соединение уже согласовано. Флаг ловит
+    // дубль, пришедший, пока первый ответ ещё применяется (signalingState
+    // меняется лишь по завершении setRemoteDescription)
+    if (
+      this._answerApplying ||
+      this._pc.signalingState !== 'have-local-offer'
+    ) {
+      return;
+    }
+
+    this._answerApplying = true;
+
+    try {
+      await this._pc.setRemoteDescription(msg.sdp);
+    } catch (e) {
+      // сбой согласования = обрыв транспорта: переподключение решает
+      // супервизор
+      this._emitClose();
+      return;
+    }
+
     if (msg.epoch !== undefined && msg.epoch !== null) {
       this._epoch = msg.epoch;
     }
-
-    await this._pc.setRemoteDescription(msg.sdp);
   }
 
   // приём удалённого ICE-кандидата (от хоста)

package/src/client/session/GuestSession.js

@@ -43,8 +43,10 @@ export default class GuestSession {
    *   startSession(transport, reconnect), closeLobby(),
    *   leaveRoomWith(text), chat(message), getVote() → модуль голосования }.
    * @param {Object} [deps.factories] - конструкторы (тесты).
-   * @param {Object} [deps.timers] - { setTimeout }.
+   * @param {Object} [deps.timers] - { setTimeout, clearTimeout }.
    * @param {Function} [deps.now]
+   * @param {EventTarget|null} [deps.network] - источник события 'online'
+   *   (window).
    */
   constructor({
     signaling,
@@ -62,6 +64,7 @@ export default class GuestSession {
     factories = {},
     timers = globalThis,
     now = () => Date.now(),
+    network = globalThis.window ?? null,
   }) {
     this._signaling = signaling;
     this._ctx = ctx;
@@ -81,6 +84,7 @@ export default class GuestSession {
     };
     this._timers = timers;
     this._now = now;
+    this._network = network;
 
     // WebRTC-транспорты к хосту комнаты, созданные этой сессией
     this._roomTransports = new WeakSet();
@@ -112,11 +116,13 @@ export default class GuestSession {
     this._ui.closeLobby();
   }
 
-  // попытки переподключения гостя: resume к текущему хосту комнаты
+  // попытки переподключения гостя: resume к текущему хосту комнаты; повтор
+  // несостоявшегося входа — обычным рукопожатием
   reconnect() {
     return {
       createTransport: () =>
         this.openTransport(this._ctx.roomId, { resume: true }),
+      createJoinTransport: () => this.openTransport(this._ctx.roomId),
       getToken: () => this._getToken(),
     };
   }
@@ -143,15 +149,24 @@ export default class GuestSession {
     );
     // канал standby открывает хост только назначенной бете
     transport.publisher.on('standby', channel => this._standby.attach(channel));
-    transport.connect(roomId).catch(() => transport.close());
+    // сбой установки connect сам превращает в 'close' транспорта
+    transport.connect(roomId);
 
     return transport;
   }
 
-  // оффер ушёл, каналы ещё не открыты: unknownRoom в этот момент —
-  // комнаты нет
+  // оффер ушёл, каналы ещё не открыты (или вход ждёт повтора после
+  // несостоявшейся попытки): unknownRoom в этот момент — комнаты нет
   offerPending() {
-    const transport = this._getSupervisor()?.transport;
+    const supervisor = this._getSupervisor();
+    const transport = supervisor?.transport ?? null;
+
+    if (transport === null) {
+      return (
+        supervisor?.state === SESSION_STATES.connecting &&
+        !supervisor.everOpened
+      );
+    }
 
     return this._roomTransports.has(transport) && !transport.isOpen;
   }
@@ -176,6 +191,8 @@ export default class GuestSession {
   bind() {
     const publisher = this._signaling.publisher;
     let reconnectAttempt = 0;
+    // отложенная попытка бэкоффа (null — сигналинг жив или уже подключается)
+    let reconnectTimer = null;
 
     publisher.on('close', () => {
       const {
@@ -196,7 +213,25 @@ export default class GuestSession {
             );
 
       reconnectAttempt += 1;
-      this._timers.setTimeout(() => this._signaling.connect(), delay);
+      // повторный close до срабатывания: попытка остаётся одна
+      this._timers.clearTimeout(reconnectTimer);
+      reconnectTimer = this._timers.setTimeout(() => {
+        reconnectTimer = null;
+        this._signaling.connect();
+      }, delay);
+    });
+
+    // сеть вернулась: ступень бэкоффа (до reconnect.maxDelay) ждать нельзя —
+    // место бывшего хоста у преемника держится меньше
+    this._network?.addEventListener('online', () => {
+      if (reconnectTimer === null) {
+        return;
+      }
+
+      this._timers.clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+      reconnectAttempt = 0;
+      this._signaling.connect();
     });
 
     publisher.on('welcome', () => {