vimp-engine 0.14.4 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vimp-engine",
-  "version": "0.14.4",
+  "version": "0.15.0",
   "description": "VIMP — движок-приложение (мастер, P2P-транспорт, Worker-хост, мета, MVC-каркас клиента)",
   "license": "MIT",
   "repository": {

package/src/client/components/model/Auth.js

@@ -31,21 +31,14 @@ export default class AuthModel {
   }
 
   // обновление данных
-  // если value невалиден, возвращается текущий value
+  // формат поля проверяет formBuilder.collectFormErrors перед сабмитом —
+  // единственный контур валидации формы (раньше здесь была вторая,
+  // параллельная проверка по options.regExp, которая молча зануляла
+  // значение и падала на строке из JSON: у неё нет .test)
   update(data) {
-    const { name } = data;
-    const { regExp } = this._options[name] ?? {};
-    let { value } = data;
-
-    if (regExp) {
-      if (regExp.test(value)) {
-        this._data[name] = value;
-      } else {
-        this._data[name] = value = '';
-      }
-    } else {
-      this._data[name] = value;
-    }
+    const { name, value } = data;
+
+    this._data[name] = value;
 
     this.publisher.emit('form', { name, value });
   }

package/src/client/components/view/Auth.js

@@ -1,5 +1,5 @@
 import Publisher from '../../../lib/Publisher.js';
-import { buildForm, reportFormValidity } from '../../lib/formBuilder.js';
+import { bindLiveErrors, buildForm, renderFormErrors } from '../../lib/formBuilder.js';
 
 // Singleton AuthView
 
@@ -24,19 +24,29 @@ export default class AuthView {
     this._enter = document.getElementById(elems.enterId);
     this._fieldsContainer = document.getElementById(elems.fieldsId);
     this._fields = new Map();
+    this._descriptors = [];
 
     this.publisher = new Publisher();
 
     this._renderTexts(elems, texts);
     this._renderFields(elems, params);
 
-    // форма заполнена; нативная проверка (pattern/required) — сервер всё
-    // равно валидирует своими validators (renderError), это лишь UX-фильтр
-    // до отправки
+    // ошибки видны по ходу правки (см. bindLiveErrors), а не по клику:
+    // до сабмита — по тронутым полям, после — по всей форме
+    this._liveErrors = bindLiveErrors(this._fieldsContainer, this._error, () => ({
+      descriptors: this._descriptors,
+      fields: this._fields,
+    }));
+
+    // форма заполнена; клиентская проверка (required/regExp/min/max) —
+    // сервер всё равно валидирует своими validators (renderError), это лишь
+    // UX-фильтр до отправки
     this._enter.onclick = () => {
-      if (reportFormValidity(this._fieldsContainer)) {
-        authView.publisher.emit('enter');
+      if (this._liveErrors.arm().length) {
+        return;
       }
+
+      authView.publisher.emit('enter');
     };
 
     this._mPublic.on('form', 'renderData', this);
@@ -65,6 +75,11 @@ export default class AuthView {
       ...descriptorRest,
     }));
 
+    this._descriptors = descriptors;
+    // params сюда приходят чужие (PS_AUTH_DATA, тот же массив main.js
+    // отдаёт следом в AuthCtrl.init) и остаются нетронутыми: значение поля
+    // с единственным вариантом закрепляет main.js (resolveForcedValue) до
+    // разветвления на solo-путь, а не эта форма
     this._fields = buildForm(descriptors, container, {}, ({ name, value }) => {
       this.publisher.emit('input', { name, value });
     });
@@ -146,22 +161,17 @@ export default class AuthView {
   renderData(data) {
     const { name, value } = data;
 
-    this._error.textContent = '';
+    // блок ошибок ведёт bindLiveErrors — он перевалидирует форму по 'input',
+    // то есть по ходу правки. Чистка, стоявшая здесь, висела на событии
+    // модели, а оно приходит из 'change' (у text-инпута — blur): игрок,
+    // перейдя из починенного поля в следующее, терял ошибки полей, которых
+    // ещё не касался
     this._fields.get(name)?.setValue(value);
   }
 
-  // отображает ошибки
+  // отображает серверные ошибки (PS_AUTH_DATA/validators) — тот же рендер,
+  // что и у клиентской collectFormErrors (formBuilder.renderFormErrors)
   renderError(data) {
-    this._error.textContent = '';
-
-    data.forEach(item => {
-      const name = item.name.toUpperCase();
-      const err = item.error;
-      const line = document.createElement('div');
-
-      line.textContent = err ? `${name}: ${err}` : `${name} is not correctly!`;
-
-      this._error.appendChild(line);
-    });
+    renderFormErrors(this._error, data);
   }
 }

package/src/client/lib/authParams.js

@@ -0,0 +1,41 @@
+import { resolveForcedValue } from './formBuilder.js';
+
+// Значения полей auth-формы до её постройки (PS_AUTH_DATA.params).
+// Вынесено из socketMethods[PS_AUTH_DATA] (main.js), чтобы этот код был
+// накрыт тестом: solo-путь (boot.autoAuth) отвечает хосту вообще без формы и
+// берёт значения ровно отсюда, то есть ошибка здесь не видна ни в одном
+// тесте формы.
+
+/**
+ * Правит `param.value` на месте: сначала память клиента
+ * (`localStorage[storage]`), затем схема. Порядок важен — поле с
+ * единственным вариантом форма не показывает и править не даёт, поэтому
+ * устаревший `localStorage` от версии игры, где вариантов было больше,
+ * обязан быть перекрыт: иначе он уедет на хост и получит отказ от
+ * игровых validators, а поправить его игроку нечем.
+ *
+ * Мутация, а не копия: тот же массив main.js отдаёт следом в
+ * `AuthCtrl.init` (оттуда он попадает в `AuthModel._data`) и в
+ * `defaultsFrom(params)` на solo-пути.
+ *
+ * @param {Array<Object>} params - PS_AUTH_DATA.params.
+ * @param {Object} [storage] - Хранилище значений, по умолчанию localStorage.
+ * @returns {Array<Object>} Тот же массив.
+ */
+export function normalizeAuthParams(params, storage = localStorage) {
+  params.forEach(param => {
+    const descriptor = param.options ?? {};
+
+    if (descriptor.storage) {
+      param.value = storage[descriptor.storage] || param.value || '';
+    }
+
+    const forced = resolveForcedValue(descriptor);
+
+    if (forced !== undefined) {
+      param.value = forced;
+    }
+  });
+
+  return params;
+}

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;