vimp-engine 0.14.4 → 0.16.0

package/src/client/lib/formBuilder.js

@@ -1,12 +1,23 @@
+import { anchorPattern } from '../../lib/formPattern.js';
+import { normalizeOptions } from '../../lib/formOptions.js';
+
 // Общий билдер полей форм (room-форма и auth-форма используют один
 // контракт дескрипторов — docs/en/plugin-api.md, раздел "Form schema").
 // control: 'select'|'text'|'checkbox'|'radio'; все контролы — нативные
-// элементы формы, без визуальной кастомизации.
-
-function normalizeOptions(list) {
-  return (list || []).map(opt =>
-    opt !== null && typeof opt === 'object' ? opt : { value: opt, label: String(opt) },
-  );
+// элементы формы, без визуальной кастомизации. Валидация — не нативная
+// (никаких браузерных попапов): collectFormErrors/renderFormErrors ниже
+// собирают и рисуют ошибки в разметку (#lobby-error/#auth-error).
+// Проверяются только поля, у которых есть строка в DOM: ошибка на скрытом
+// поле игроку не видна и исправить её нечем — она просто запирает форму.
+
+// контролы, у которых есть список вариантов: держим одним списком, чтобы
+// resolveForcedValue не расходился с builders при добавлении нового
+const OPTION_CONTROLS = ['select', 'radio'];
+
+// числовое text-поле: unit задан или numeric:true. Правило одно на билдер и
+// на валидацию, поэтому живёт в одном месте
+function isNumeric(descriptor) {
+  return descriptor.numeric === true || descriptor.unit !== undefined;
 }
 
 // 'source' — спец-источник вариантов из каталога движка (например карты),
@@ -19,6 +30,32 @@ function resolveOptions(descriptor, ctx) {
   return normalizeOptions(descriptor.options);
 }
 
+// ровно один резолвнутый вариант — единственно возможное значение поля:
+// строка формы для него не рендерится (игроку нечего выбирать и нечем
+// поправить рассинхрон), поэтому ничто извне (устаревший localStorage,
+// default из схемы, серверное PS_AUTH_DATA) не должно иметь возможности
+// его переопределить — native <select>.value на несуществующем option
+// молча схлопывается в '' без единой ошибки (vimp-snakes/model)
+function forcedValue(options) {
+  return options.length === 1 ? options[0].value : undefined;
+}
+
+// то же правило вне формы: solo-путь (boot.autoAuth) отвечает хосту без
+// всякой формы и должен прийти ровно к тому же значению, что и она
+export function resolveForcedValue(descriptor, ctx = {}) {
+  if (!OPTION_CONTROLS.includes(descriptor.control)) {
+    return undefined;
+  }
+
+  const forced = forcedValue(resolveOptions(descriptor, ctx));
+
+  // форма отдала бы строку: и <option>.value, и <input type=radio>.value —
+  // DOM-свойства, они всегда строки. Нестроковое значение (options: [1, 2])
+  // validateAuth отбивает «Property must be a string» (lib/validators.js), а
+  // строки поля в DOM нет — игроку нечем это поправить
+  return forced === undefined ? undefined : String(forced);
+}
+
 // unit:'s' — значение хранится в мс, показывается/редактируется в секундах
 function toDisplay(descriptor, value) {
   return descriptor.unit === 's' ? value / 1000 : value;
@@ -30,10 +67,12 @@ function toStored(descriptor, value) {
 
 function buildSelect(descriptor, ctx) {
   const el = document.createElement('select');
+  const options = resolveOptions(descriptor, ctx);
+  const forced = forcedValue(options);
 
   el.name = descriptor.name;
 
-  resolveOptions(descriptor, ctx).forEach(({ value, label }) => {
+  options.forEach(({ value, label }) => {
     const option = document.createElement('option');
 
     option.value = value;
@@ -41,10 +80,20 @@ function buildSelect(descriptor, ctx) {
     el.appendChild(option);
   });
 
+  if (forced !== undefined) {
+    el.value = forced;
+  }
+
   return {
     el,
+    singleOption: forced !== undefined,
+    noOptions: options.length === 0,
     getValue: () => el.value,
     setValue(value) {
+      if (forced !== undefined) {
+        return;
+      }
+
       el.value = value;
     },
     onChange(cb) {
@@ -58,11 +107,15 @@ function buildSelect(descriptor, ctx) {
 // вместо превращения его в 0 на сабмите
 function buildText(descriptor) {
   const el = document.createElement('input');
-  const numeric = descriptor.numeric || descriptor.unit !== undefined;
+  const numeric = isNumeric(descriptor);
 
   el.type = 'text';
   el.name = descriptor.name;
 
+  // pattern/required — семантика контрола (a11y, автозаполнение), НЕ
+  // валидация: обе формы — обычные div, не <form>, и reportValidity()
+  // движок не зовёт (см. collectFormErrors). maxLength — единственный из
+  // трёх с реальным эффектом: он ограничивает сам ввод
   if (descriptor.regExp) {
     el.pattern = descriptor.regExp;
   }
@@ -79,7 +132,11 @@ function buildText(descriptor) {
 
   const getValue = () => {
     if (!numeric) {
-      return el.value;
+      // то же, что лобби уже делает с именем комнаты (main.js: name.trim()):
+      // незначащие пробелы — опечатка ввода, а не значение. Валидация
+      // смотрит на ту же строку (validateField), иначе она разрешала бы то,
+      // что потом отбивает хост (isValidName не терпит крайних пробелов)
+      return el.value.trim();
     }
 
     const n = Number(el.value);
@@ -91,6 +148,11 @@ function buildText(descriptor) {
   return {
     el,
     getValue,
+    // «сырая» строка поля, до конвертации единицы и отката к default:
+    // единственный способ отличить пустой ввод от валидного значения (у
+    // числового поля getValue() подменяет пустоту дефолтом). Часть контракта
+    // поля — валидации незачем знать, из какого элемента оно построено
+    getRaw: () => el.value,
     setValue(value) {
       el.value = numeric ? toDisplay(descriptor, value) : (value ?? '');
     },
@@ -131,8 +193,12 @@ function buildRadio(descriptor, ctx) {
   const el = document.createElement('div');
   const groupName = `field-radio-${descriptor.name}-${++idSeq}`;
   const inputs = [];
+  const options = resolveOptions(descriptor, ctx);
+  // см. forcedValue: ровно один вариант — принудительное и неизменяемое
+  // значение, строка скрыта и поправить рассинхрон нечем
+  const forced = forcedValue(options);
 
-  resolveOptions(descriptor, ctx).forEach(({ value, label }) => {
+  options.forEach(({ value, label }) => {
     const wrap = document.createElement('span');
     const input = document.createElement('input');
 
@@ -151,12 +217,22 @@ function buildRadio(descriptor, ctx) {
     inputs.push(input);
   });
 
+  if (forced !== undefined) {
+    inputs[0].checked = true;
+  }
+
   const getValue = () => inputs.find(input => input.checked)?.value;
 
   return {
     el,
+    singleOption: forced !== undefined,
+    noOptions: options.length === 0,
     getValue,
     setValue(value) {
+      if (forced !== undefined) {
+        return;
+      }
+
       inputs.forEach(input => {
         input.checked = input.value === String(value);
       });
@@ -205,30 +281,268 @@ export function mergeRoomDefaults(descriptors, roomDefaults) {
   }));
 }
 
-// нативная валидация (pattern/required/maxlength) перед сабмитом room- и
-// auth-формы: обе — обычные div (lobby.pug/auth.pug), не <form>, поэтому
-// reportValidity вызывается на каждом контроле напрямую (Constraint
-// Validation API работает и вне <form>). Останавливается на первом
-// невалидном контроле — иначе браузер фокусирует/подсвечивает последний
-// вызванный reportValidity, а не первый по порядку поля
-export function reportFormValidity(container) {
+// суффикс подписи поля: диапазон (min/max, если задан хотя бы один из них),
+// иначе просто единица (unit:'s') — та же строка, что и раньше, "(s)".
+// Полноценные HTML5 min/max тут не годятся: числовые поля — type=text
+// (unit-конвертация мс<->с сама по себе не native-совместима), поэтому
+// диапазон — только подсказка + вход в collectFormErrors ниже
+function buildLabelSuffix(descriptor) {
+  const { min, max, unit } = descriptor;
+
+  if (min === undefined && max === undefined) {
+    return unit === 's' ? ' (s)' : '';
+  }
+
+  const range = `${min ?? '…'}–${max ?? '…'}`;
+
+  return unit === 's' ? ` (s, ${range})` : ` (${range})`;
+}
+
+// скомпилированные паттерны полей: строка regExp -> RegExp, либо null, если
+// она не компилируется. Кэш на модуль — дескрипторы приезжают из манифеста и
+// живут всю сессию, а сабмит иначе пересобирал бы RegExp на каждое поле
+const patterns = new Map();
+
+// regExp приезжает из манифеста игры строкой: невалидный паттерн — дефект
+// схемы, а не повод убить сабмит. Без перехвата SyntaxError уходит из
+// collectFormErrors в обработчик клика, кнопка перестаёт делать что-либо и
+// игрок не видит ни строки (нативный `pattern` вёл себя ровно наоборот:
+// нечитаемый паттерн браузер игнорирует). Контракт-чекер ловит это раньше —
+// правило B5, roomForm; якорение общее с ним (lib/formPattern.js)
+function fieldPattern(regExp) {
+  if (!patterns.has(regExp)) {
+    let pattern = null;
+
+    try {
+      pattern = anchorPattern(regExp);
+    } catch (e) {
+      console.error(`formBuilder: invalid regExp "${regExp}" — ${e.message}`);
+    }
+
+    patterns.set(regExp, pattern);
+  }
+
+  return patterns.get(regExp);
+}
+
+// ошибка одного поля, либо null — required/regExp/maxlength (не-numeric
+// text)/min/max (numeric text); сообщения не зависят от локали браузера, в
+// отличие от бывшего reportValidity(). regExp сверяется с "сырой" строкой
+// поля (field.getRaw()) — тем же значением, которое раньше матчил нативный
+// pattern: у числового text-поля getValue() отдаёт число в единице
+// хранения (мс для unit:'s'), а не отображаемую строку, так что regExp
+// (сгенерированный build-game-manifest.js диапазон вроде "^([1-8])$" для
+// maxPlayers — единственная граница у манифестов без min/max) проверяется
+// отдельно от min/max, а не вместо них
+function validateField(descriptor, field) {
+  // резолв вариантов дал пустой список: допустимого значения у поля нет
+  // вовсе — дефект схемы или каталога (buildForm уже написал console.error).
+  // Отдельным сообщением, а не через required: заполнить такое поле нечем, и
+  // «required» повело бы игрока туда, где ничего нет. Проверяется первой —
+  // required у поля может и не стоять (ни одна игра не ставит его на `map`),
+  // а пустая строка не должна уезжать на хост молча
+  if (field.noOptions) {
+    return 'no options available';
+  }
+
+  const value = field.getValue();
+  const isText = descriptor.control === 'text';
+  // у числового поля getValue() уже откатился к default (чтобы пустая
+  // строка не уехала нулём), поэтому пустоту видно только по сырой строке.
+  // trim: Number(' ') === 0, то есть без него пробел прошёл бы нулём — и
+  // наоборот, ' 8 ' игрок считает валидной восьмёркой. У нечислового поля
+  // это ровно то же, что вернёт getValue(): обе стороны обязаны смотреть на
+  // одну строку, иначе клиент разрешает то, что отбивает хост
+  const raw = isText ? (field.getRaw?.() ?? '').trim() : undefined;
+  const isEmpty = isText
+    ? raw === ''
+    : value === undefined || value === null || value === '';
+  const numeric = isText && isNumeric(descriptor);
+
+  // числовое поле всегда несёт число и «необязательным» быть не может:
+  // пустой ввод getValue() подменяет default'ом (чтобы не уехал нолём), и
+  // без этой ветки пустой Max players молча создавал бы комнату с дефолтом
+  if ((descriptor.required || numeric) && isEmpty) {
+    return 'required';
+  }
+
+  if (isEmpty) {
+    return null;
+  }
+
+  if (numeric) {
+    // без этой проверки нечисловой ввод молча подменялся бы default'ом
+    // из getValue() и уезжал на хост как «валидный»
+    if (!Number.isFinite(Number(raw))) {
+      return 'must be a number';
+    }
+
+    const displayValue = toDisplay(descriptor, value);
+
+    // min/max раньше regExp: тот же диапазон regExp кодирует точным
+    // паттерном (rangeToPattern), но «must be ≤ 32» говорит игроку то же,
+    // что подсказка в подписи поля, а «invalid format» — ничего
+    if (descriptor.min !== undefined && displayValue < descriptor.min) {
+      return `must be ≥ ${descriptor.min}`;
+    }
+
+    if (descriptor.max !== undefined && displayValue > descriptor.max) {
+      return `must be ≤ ${descriptor.max}`;
+    }
+  } else if (
+    isText &&
+    descriptor.maxlength !== undefined &&
+    String(value).length > descriptor.maxlength
+  ) {
+    return `must be at most ${descriptor.maxlength} characters`;
+  }
+
+  // Проверяется последним: ловит то, что диапазон пропускает (дробное,
+  // ведущий ноль). Нечитаемый паттерн — не ограничение (fieldPattern уже
+  // назвал дефект в консоли), поле проходит
+  if (isText && descriptor.regExp) {
+    const pattern = fieldPattern(descriptor.regExp);
+
+    if (pattern && !pattern.test(raw)) {
+      return 'invalid format';
+    }
+  }
+
+  return null;
+}
+
+// валидирует всю форму перед сабмитом (замена бывшего reportFormValidity/
+// native reportValidity): порядок ошибок — порядок дескрипторов.
+// Поля без строки в DOM (hidden, единственный вариант) пропускаются: их
+// ошибку игрок не видит и исправить не может — она бы заперла форму
+// навсегда (нативный reportValidity обходил только контролы в DOM и до них
+// тоже не добирался). label — подпись из формы, чтобы имя в ошибке
+// совпадало с тем, что игрок видит рядом с полем
+export function collectFormErrors(descriptors, fields) {
+  const errors = [];
+
+  descriptors.forEach(descriptor => {
+    const field = fields.get(descriptor.name);
+
+    if (!field || field.rendered === false) {
+      return;
+    }
+
+    const error = validateField(descriptor, field);
+
+    if (error) {
+      errors.push({
+        name: descriptor.name,
+        label: descriptor.label || descriptor.name,
+        error,
+      });
+    }
+  });
+
+  return errors;
+}
+
+// рисует ошибки формы в разметку — общий рендер для #lobby-error и
+// #auth-error (и для клиентской collectFormErrors, и для серверных ошибок
+// PS_AUTH_DATA/validators, чей формат уже {name, error})
+export function renderFormErrors(container, errors) {
   if (!container) {
-    return true;
+    return;
   }
 
-  for (const el of container.querySelectorAll('input, select')) {
-    if (!el.reportValidity()) {
-      return false;
+  container.textContent = '';
+
+  (errors || []).forEach(({ name, label, error }) => {
+    const line = document.createElement('div');
+    // серверные ошибки (PS_AUTH_DATA/validators) приезжают без label —
+    // для них, как и раньше, остаётся имя поля
+    const title = String(label || name).toUpperCase();
+
+    line.textContent = error ? `${title}: ${error}` : `${title} is not correctly!`;
+
+    container.appendChild(line);
+  });
+}
+
+// какому полю принадлежит событие ввода: у radio-группы field.el — обёртка
+// вокруг нескольких input'ов, а их собственный name сгенерирован и с именем
+// поля не совпадает, поэтому ищем по вхождению узла, а не по name
+function fieldNameOf(fields, target) {
+  for (const [name, field] of fields) {
+    if (field.el === target || field.el.contains?.(target)) {
+      return name;
     }
   }
 
-  return true;
+  return undefined;
+}
+
+// перевалидация формы по ходу правки — вместо «одна ошибка на клик».
+//
+// Показывается не всё подряд: до сабмита — только поля, которых игрок уже
+// касался. Неверное значение он видит сразу, как ввёл (а не после клика по
+// кнопке), но «required» на поле, которое ещё не заполняли, не шумит.
+// Сабмит (arm) снимает фильтр: клик — это ответ за всю форму целиком.
+//
+// Строка уходит из блока, когда починено именно её поле, а не всё разом по
+// первому нажатию клавиши — иначе игрок с тремя ошибками теряет список,
+// начав править первую.
+//
+// 'input' — единственное событие по ходу ввода ('change' у text-инпута
+// приходит на blur, то есть уже после клика по кнопке); слушатель
+// делегированный и вешается один раз: контейнер постоянен, пересобираются
+// только поля. Пустой список тоже рендерится — так из блока уходят и
+// не-формные строки (отказ загрузки плагина в лобби).
+export function bindLiveErrors(container, errorContainer, getForm) {
+  let touched = new Set();
+  let all = false;
+
+  const render = () => {
+    const { descriptors, fields } = getForm();
+    const errors = collectFormErrors(descriptors, fields).filter(
+      error => all || touched.has(error.name),
+    );
+
+    renderFormErrors(errorContainer, errors);
+
+    return errors;
+  };
+
+  container?.addEventListener('input', event => {
+    const name = fieldNameOf(getForm().fields, event.target);
+
+    if (name !== undefined) {
+      touched.add(name);
+    }
+
+    render();
+  });
+
+  return {
+    // сабмит: показываем и то, чего игрок не трогал. Возвращает отрисованные
+    // ошибки, чтобы вызывающему не пришлось собирать их вторым проходом
+    arm: () => {
+      all = true;
+
+      return render();
+    },
+    // форма пересобрана (смена игры) — она снова ничья: ни одного тронутого
+    // поля, ни одного сабмита
+    disarm: () => {
+      all = false;
+      touched = new Set();
+
+      return render();
+    },
+  };
 }
 
 // собирает форму (упорядоченный массив дескрипторов = порядок полей) в
 // контейнер: одна .form-row на дескриптор (.form-label + контрол); onChange,
-// если передан, подписывается на все поля разом. hidden:true — поле строится
-// и участвует в сабмите (fields Map), но строка не попадает в DOM
+// если передан, подписывается на все поля разом. hidden:true, а также
+// select/radio с единственным резолвнутым вариантом (singleOption) — поле
+// строится и участвует в сабмите (fields Map), но строка не попадает в DOM
+// и помечается field.rendered = false (collectFormErrors такие пропускает)
 export function buildForm(descriptors, container, ctx = {}, onChange) {
   const fields = new Map();
 
@@ -252,10 +566,32 @@ export function buildForm(descriptors, container, ctx = {}, onChange) {
 
     fields.set(descriptor.name, field);
 
-    if (descriptor.hidden) {
+    // пустой список вариантов — дефект схемы или каталога, а не «нечего
+    // выбирать»: значения у поля нет вовсе. Такое поле остаётся видимым, а
+    // валидация даёт ему собственное 'no options available' (см.
+    // validateField) — молча спрятать его значит отправить на хост пустую
+    // строку и получить отказ уже от игровых validators
+    if (field.noOptions) {
+      console.error(
+        `formBuilder: field "${descriptor.name}" resolved to no options`,
+      );
+    }
+
+    if (descriptor.hidden || field.singleOption) {
+      field.rendered = false;
+
+      // строки нет — ошибку показать некому (её не видно и не исправить), но
+      // и пустая строка не значение: пусть ключ вообще не попадёт в сабмит,
+      // на хосте останется roomDefaults/значение схемы
+      if (field.noOptions) {
+        fields.delete(descriptor.name);
+      }
+
       return;
     }
 
+    field.rendered = true;
+
     const row = document.createElement('div');
 
     row.className = 'form-row';
@@ -266,7 +602,7 @@ export function buildForm(descriptors, container, ctx = {}, onChange) {
     const label = document.createElement(field.labelFor ? 'label' : 'span');
 
     label.className = 'form-label';
-    label.textContent = (descriptor.label || descriptor.name) + (descriptor.unit === 's' ? ' (s)' : '');
+    label.textContent = (descriptor.label || descriptor.name) + buildLabelSuffix(descriptor);
 
     if (field.labelFor) {
       label.htmlFor = field.labelFor;

package/src/client/main.js

@@ -26,11 +26,8 @@ import StatCtrl from './components/controller/Stat.js';
 import VoteModel from './components/model/Vote.js';
 import VoteView from './components/view/Vote.js';
 import VoteCtrl from './components/controller/Vote.js';
-import {
-  buildForm,
-  mergeRoomDefaults,
-  reportFormValidity,
-} from './lib/formBuilder.js';
+import { buildForm, mergeRoomDefaults, bindLiveErrors } from './lib/formBuilder.js';
+import { normalizeAuthParams } from './lib/authParams.js';
 import { createGameActivator } from './lib/gameActivator.js';
 import createAutostart from './lib/autostart.js';
 import { getBootConfig, resolveBootConfig } from './boot.js';
@@ -425,13 +422,22 @@ socketMethods[PS_AUTH_DATA] = data => {
 
   document.getElementById('logo').textContent = texts?.title || 'VIMP';
 
-  params.forEach(param => {
-    const { storage } = param.options;
+  // версия пакета игры в футере формы входа. Здесь, а не в AuthView: его
+  // elems приходят из authSchema.elems игрового плагина, и футер каркаса —
+  // не его забота. Игра, собранная до появления packageVersion, оставляет
+  // строку пустой (#auth-link держит раскладку через space-between)
+  const authVersion = document.getElementById('auth-version');
 
-    if (storage) {
-      param.value = localStorage[storage] || param.value || '';
-    }
-  });
+  if (authVersion) {
+    const packageVersion = activeGameManifest?.packageVersion;
+
+    authVersion.textContent = packageVersion ? `v${packageVersion}` : '';
+  }
+
+  // память клиента (localStorage) + принудительное значение поля с
+  // единственным вариантом. Здесь, а не в AuthView: solo-путь ниже отвечает
+  // хосту вообще без формы и обязан прийти к тем же значениям
+  normalizeAuthParams(params);
 
   // solo: формы нет — отвечаем дефолтами схемы, перекрытыми boot.autoAuth
   if (boot.autoAuth) {
@@ -1822,6 +1828,9 @@ let leaderboardReqId = 0;
 
 // поля формы комнаты, сгенерированные по manifest.roomForm: key -> field
 let roomFormFields = new Map();
+// дескрипторы той же формы (после mergeRoomDefaults) — нужны отдельно для
+// валидации (bindLiveErrors по ходу правки и при сабмите)
+let roomFormDescriptors = [];
 
 // генерирует форму создания комнаты по явной схеме манифеста (roomForm,
 // docs/en/plugin-api.md "Form schema") — движок не выводит контролы из типа
@@ -1834,12 +1843,12 @@ function populateRoomForm(manifest) {
   }
 
   if (Array.isArray(manifest.roomForm)) {
-    const descriptors = mergeRoomDefaults(
+    roomFormDescriptors = mergeRoomDefaults(
       manifest.roomForm,
       manifest.roomDefaults,
     );
 
-    roomFormFields = buildForm(descriptors, container, {
+    roomFormFields = buildForm(roomFormDescriptors, container, {
       sources: { maps: manifest.maps?.list },
     });
   } else {
@@ -1850,6 +1859,7 @@ function populateRoomForm(manifest) {
     );
     container.textContent = '';
     roomFormFields = new Map();
+    roomFormDescriptors = [];
   }
 }
 
@@ -1870,7 +1880,6 @@ function showLobbyError(text) {
 
   if (elem) {
     elem.textContent = text;
-    elem.style.display = '';
   }
 }
 
@@ -1879,7 +1888,6 @@ function clearLobbyError() {
 
   if (elem) {
     elem.textContent = '';
-    elem.style.display = 'none';
   }
 }
 
@@ -2005,6 +2013,14 @@ function initLobby() {
   // первого gameChanged/рендера Leaderboard
   lobbyView.setSelfNick(lobbyAuthModel.getNick());
 
+  // ошибки формы видны по ходу правки (formBuilder.bindLiveErrors): до
+  // первого клика по Create server — по тронутым полям, после — по всей форме
+  const liveErrors = bindLiveErrors(
+    document.getElementById(lobbyConfig.elems.fieldsId),
+    document.getElementById(lobbyConfig.elems.errorId),
+    () => ({ descriptors: roomFormDescriptors, fields: roomFormFields }),
+  );
+
   // создание комнаты в этой же вкладке (хост-игрок через loopback)
   populateGameSelect();
   populateRoomForm(activeGameManifest);
@@ -2025,21 +2041,23 @@ function initLobby() {
 
     populateRoomForm(manifest);
     lobby.gameChanged(manifest.id, manifest.title);
-    clearLobbyError();
+    // форма пересобрана: она снова ничья, а блок ошибок чистит сам disarm
+    liveErrors.disarm();
   });
 
   const nameInput = document.getElementById(lobbyConfig.elems.nameId);
 
   hostBtn?.addEventListener('click', async () => {
-    // нативная валидация (pattern/required) — единственная граница
+    // валидация (pattern/required/min/max) — единственная граница
     // room-формы: она едет клиенту как JSON манифеста, JS-валидаторы
     // (как в auth-форме) туда не сериализуются (docs/en/plugin-api.md
     // "Form schema"); авторитетный клампинг всё равно в applyRoomOverrides.js
     // (вызывается из host.worker.js при создании комнаты). Проверяем до
-    // активации игры: неверная форма не должна стоить загрузки плагина
-    if (
-      !reportFormValidity(document.getElementById(lobbyConfig.elems.fieldsId))
-    ) {
+    // активации игры: неверная форма не должна стоить загрузки плагина.
+    // arm() и рисует ошибки, и снимает фильтр «только тронутые поля»: клик —
+    // это ответ за форму целиком, включая поля, которых игрок не касался.
+    // Он же чистит блок, когда ошибок нет
+    if (liveErrors.arm().length) {
       return;
     }