tensorgrid-ui 1.6.1 → 2.0.0

package/lib/index.js

@@ -224,22 +224,79 @@ export function apply(ctx) {
     // подключённых моделей для выбора ревизора. Отдельным — потому что
     // объединение с парой выше связало бы настройки обзора со стойкой
     // входа: нет одной — пропала бы и другая, хотя они независимы.
-    const modelServices = { llm: null, generation: null }
-    web.inject(['llm'], (bound) => {
+    const modelServices = { llm: null, credentials: null, generation: null }
+    web.inject(['llm', 'credentials'], (bound) => {
       const generation = {}
       modelServices.llm = bound.llm
+      modelServices.credentials = bound.credentials
       modelServices.generation = generation
       bound.effect(() => () => {
         if (modelServices.generation !== generation) return
         modelServices.llm = null
+        modelServices.credentials = null
         modelServices.generation = null
       })
     })
 
+    // ── ЗАСЛОН ДЛЯ НАШИХ МАРШРУТОВ ──────────────────────────────────────
+    //
+    // Берётся ШТАТНЫЙ, а не пишется свой. Это не перестраховка, а починка
+    // настоящей дыры, найденной обзором и подтверждённой на живом
+    // приложении:
+    //
+    //   /                      401   защищено
+    //   /api/любой-другой      401   защищено
+    //   /api/tensorgrid.auth   200   НАШ, без токена
+    //
+    // Приложение регистрирует на префикс `/api` обработчик с проверкой, а
+    // точное совпадение пути выигрывает у префикса. Наши точные маршруты не
+    // просто «не добавляли токен» — они ВЫРЕЗАЛИ из-под себя весь заслон.
+    //
+    // Штатная проверка делает три вещи, которых моя самодельная не делала:
+    // требует петлевой или явно доверенный Host (это и закрывает подмену
+    // имени), отклоняет запрос с `sec-fetch-site: cross-site` и лишь затем
+    // сверяет Origin. Плюс проверяет токен браузерной сессии.
+    const guard = { connection: null, generation: null }
+    web.inject(['connection'], (bound) => {
+      const generation = {}
+      guard.connection = bound.connection
+      guard.generation = generation
+      bound.effect(() => () => {
+        if (guard.generation !== generation) return
+        guard.connection = null
+        guard.generation = null
+      })
+    })
+
+    /**
+     * Отклонить запрос, если штатный заслон против.
+     *
+     * @returns true, если ответ уже отправлен и обработчику делать нечего.
+     */
+    function rejected(req, res) {
+      const connection = guard.connection
+      if (connection === null) {
+        // Заслона нет — значит браузерная часть не поднята. Открывать
+        // маршрут «пока суд да дело» нельзя: это ровно та дыра, что чиним.
+        res.writeHead(503, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ problem: 'проверка доступа недоступна' }))
+        return true
+      }
+      const rejection = connection.requestRejection(req)
+      if (rejection === undefined) return false
+      res.writeHead(rejection, { 'content-type': 'application/json; charset=utf-8' })
+      res.end(JSON.stringify({ problem: rejection === 401 ? 'требуется вход в приложение' : 'запрос отклонён' }))
+      return true
+    }
+
     // Манифест собирается в горячем модуле: он ЧИТАЕТ поставочный файл и
     // дополняет его нашими полями, а значит зависит от чужой формы, которая
     // может поменяться. Такую логику правильнее держать там, где её можно
     // поправить без перезапуска.
+    //
+    // Заслон сюда НЕ ставится намеренно: манифест и иконку браузер просит до
+    // всякого входа, и в поставке они тоже отдаются открыто. Секретов в них
+    // нет — только имя и цвета.
     web.effect(() =>
       web.webServer.register({
         kind: 'exact',
@@ -262,6 +319,7 @@ export function apply(ctx) {
         path: '/api/tensorgrid.review',
         async handler(req, res) {
           try {
+            if (rejected(req, res)) return
             const runtime = await loadModule('./http-runtime.js')
             await runtime.handleReview(req, res, loadModule, modelServices)
           } catch (error) {
@@ -277,6 +335,7 @@ export function apply(ctx) {
         path: '/api/tensorgrid.auth',
         async handler(req, res) {
           try {
+            if (rejected(req, res)) return
             const runtime = await loadModule('./http-runtime.js')
             await runtime.handleAuth(req, res, authServices, loadModule)
           } catch (error) {
@@ -292,6 +351,7 @@ export function apply(ctx) {
         path: '/api/tensorgrid.update',
         async handler(req, res) {
           try {
+            if (rejected(req, res)) return
             const runtime = await loadModule('./http-runtime.js')
             await runtime.handleUpdate(req, res, updateState, loadModule)
           } catch (error) {

package/lib/review-log.js

@@ -27,9 +27,9 @@
  *
  * Импортируются только встроенные модули Node.
  */
-import { readFile, rename, writeFile } from 'node:fs/promises'
+import { readFile, rename, rm, writeFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { createHash } from 'node:crypto'
+import { createHash, randomBytes } from 'node:crypto'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -44,6 +44,27 @@ const FILE_NAME = 'tensorgrid-review-log.json'
  */
 const MAX_RUNS = 200
 
+/**
+ * Пределы на объём.
+ *
+ * Ограничения числа обзоров недостаточно: в каждой находке до пяти полей, в
+ * обзоре до шестидесяти находок на ревизора, ревизоров трое. Без предела на
+ * ДЛИНУ полей двести обзоров дают сотни мегабайт, а файл читается целиком
+ * при каждом открытии настроек и при каждом нажатии в панели.
+ */
+const FIELD_CHARS = 1200
+const REQUEST_CHARS = 400
+const EVIDENCE_CHARS = 800
+
+/**
+ * Сколько знаков доказательства считается доказательством.
+ *
+ * Порог намеренно низкий: это заслон от ПУСТОГО поля, а не попытка судить
+ * о качестве проверки. Судить о качестве может только человек, читающий
+ * улику, — для того она и показывается в панели рядом с находкой.
+ */
+const MIN_EVIDENCE_CHARS = 12
+
 /** Допустимые приговоры. Четвёртого состояния нет: неразобранное — «ждёт». */
 export const VERDICTS = ['pending', 'confirmed', 'false', 'deferred']
 
@@ -93,26 +114,82 @@ export function empty() {
   return { runs: [], verdicts: {} }
 }
 
-/** Привести прочитанное к ожидаемой форме: файл могли править руками. */
+/** Отрезать текст, не притворяясь, что ничего не отрезали. */
+function clip(value, limit) {
+  if (typeof value !== 'string') return null
+  return value.length <= limit ? value : `${value.slice(0, limit)}… (обрезано)`
+}
+
+/**
+ * Привести прочитанное к ожидаемой форме.
+ *
+ * Внутрь обзора смотрим ТАК ЖЕ придирчиво, как наружу. Раньше проверялось
+ * только наличие `id`, а `findings` и `reviewers` принимались любого типа —
+ * и один криво отредактированный обзор ронял `latest()` на `.map`, то есть
+ * весь раздел настроек целиком: состав, режимы, выбор моделей, запись
+ * приговоров. Починить из интерфейса было нельзя.
+ */
 export function normalise(raw) {
   if (raw === null || typeof raw !== 'object') return empty()
 
+  const text = (value, limit) => (typeof value === 'string' ? clip(value, limit) : null)
+
   const runs = Array.isArray(raw.runs)
-    ? raw.runs.filter((run) => run !== null && typeof run === 'object' && typeof run.id === 'string').slice(-MAX_RUNS)
+    ? raw.runs
+        .filter((run) => run !== null && typeof run === 'object' && typeof run.id === 'string')
+        .map((run) => ({
+          id: run.id,
+          at: text(run.at, 40) ?? null,
+          request: text(run.request, REQUEST_CHARS) ?? '',
+          reviewers: Array.isArray(run.reviewers)
+            ? run.reviewers
+                .filter((r) => r !== null && typeof r === 'object')
+                .map((r) => ({
+                  provider: text(r.provider, 64),
+                  model: text(r.model, 96),
+                  effort: text(r.effort, 32),
+                  failed: text(r.failed, 200),
+                  found: Number.isFinite(r.found) ? r.found : 0,
+                }))
+            : [],
+          findings: Array.isArray(run.findings)
+            ? run.findings
+                .filter((f) => f !== null && typeof f === 'object' && typeof f.id === 'string')
+                .map((f) => ({
+                  id: f.id,
+                  reviewer: text(f.reviewer, 64) ?? '?',
+                  severity: text(f.severity, 32) ?? 'не указана',
+                  title: text(f.title, FIELD_CHARS) ?? '',
+                  where: text(f.where, FIELD_CHARS),
+                  what: text(f.what, FIELD_CHARS),
+                  why: text(f.why, FIELD_CHARS),
+                  howToCheck: text(f.howToCheck, FIELD_CHARS),
+                }))
+            : [],
+        }))
+        .slice(-MAX_RUNS)
     : []
 
-  const verdicts = {}
+  // Признаки находок, которые ещё существуют. По ним отсеиваются
+  // приговоры-сироты: обзор выпал за предел, а приговор по нему остался бы
+  // в файле навсегда и продолжал бы влиять на статистику.
+  const alive = new Set()
+  for (const run of runs) for (const finding of run.findings) alive.add(finding.id)
+
+  // Объект БЕЗ прототипа: иначе ключ `__proto__` из правленого файла не
+  // записывается вовсе, а `recordVerdict` при этом отвечает «применено» —
+  // приговор человека исчезал при успешном ответе.
+  const verdicts = Object.create(null)
   if (raw.verdicts !== null && typeof raw.verdicts === 'object') {
     for (const [id, entry] of Object.entries(raw.verdicts)) {
       if (entry === null || typeof entry !== 'object') continue
       if (!VERDICTS.includes(entry.verdict)) continue
+      if (!alive.has(id)) continue
       verdicts[id] = {
         verdict: entry.verdict,
-        // Доказательство — обязательная часть приговора, но пустое лучше,
-        // чем потерянная запись: по нему как раз видно, что проверки не было.
-        evidence: typeof entry.evidence === 'string' ? entry.evidence : '',
+        evidence: text(entry.evidence, EVIDENCE_CHARS) ?? '',
         by: entry.by === 'human' ? 'human' : 'agent',
-        at: typeof entry.at === 'string' ? entry.at : null,
+        at: text(entry.at, 40),
       }
     }
   }
@@ -120,24 +197,102 @@ export function normalise(raw) {
   return { runs, verdicts }
 }
 
-/** Прочитать журнал. */
+/**
+ * Прочитать журнал.
+ *
+ * Возвращает ещё и признак `intact`: удалось ли разобрать файл. Без него
+ * повреждённый журнал выглядел как пустой, а следующая запись накрывала им
+ * настоящие данные — двести обзоров и все приговоры, включая возражения
+ * человека, исчезали от одной лишней запятой, молча и безвозвратно.
+ */
 export async function read(root = null) {
   const path = logPath(root)
-  if (path === null) return empty()
+  if (path === null) return { ...empty(), intact: true, missing: true }
+  let text
+  try {
+    text = await readFile(path, 'utf8')
+  } catch (error) {
+    // Файла нет — это не повреждение, а «обзоров ещё не было».
+    if (error?.code === 'ENOENT') return { ...empty(), intact: true, missing: true }
+    return { ...empty(), intact: false, problem: String(error?.message ?? error) }
+  }
   try {
-    return normalise(JSON.parse((await readFile(path, 'utf8')).replace(/^\uFEFF/, '')))
-  } catch {
-    return empty()
+    return { ...normalise(JSON.parse(text.replace(/^\uFEFF/, ''))), intact: true, missing: false }
+  } catch (error) {
+    return { ...empty(), intact: false, problem: `журнал не разобран: ${String(error?.message ?? error)}` }
   }
 }
 
-/** Записать журнал через временный файл: чтение не должно увидеть обрезок. */
+/**
+ * Очередь записи на каждый файл.
+ *
+ * Запись идёт по схеме «прочитать целиком → изменить → записать целиком»,
+ * и без очереди одновременные вызовы читают ОДНО состояние, а пишут каждый
+ * своё: побеждает последний, остальные исчезают бесследно. Проверено —
+ * двенадцать одновременных записей давали одну.
+ *
+ * Случай не выдуманный: журнал пишут две стороны — Host в конце обзора и
+ * браузер по нажатию в панели. Человек подтверждает находку ровно в тот
+ * момент, когда завершается второй обзор.
+ *
+ * Очередь внутрипроцессная, и этого достаточно: оба пути проходят через
+ * один Host. От двух ОДНОВРЕМЕННО ЗАПУЩЕННЫХ приложений она не спасает —
+ * такой случай потребовал бы файловой блокировки, а он у нас невозможен:
+ * второй экземпляр не поднимется на занятом порту.
+ */
+const queues = new Map()
+
+function serialise(path, work) {
+  const previous = queues.get(path) ?? Promise.resolve()
+  const next = previous.then(work, work)
+  // В очереди держим ТОЛЬКО факт завершения, без результата и без отказа:
+  // иначе одна неудачная запись уронила бы все следующие.
+  queues.set(path, next.then(() => undefined, () => undefined))
+  return next
+}
+/**
+ * Переименовать с повтором.
+ *
+ * На Windows одновременное переименование двух временных файлов в одну цель
+ * изредка отказывает с EPERM или EBUSY: файл в этот момент держит чужая
+ * операция. Это не ошибка вызывающего и не повод терять запись — достаточно
+ * повторить через несколько миллисекунд.
+ *
+ * Повторяются только эти два кода. Всё прочее — настоящая ошибка (нет прав
+ * на каталог, кончилось место), и глотать её нельзя.
+ */
+async function renameWithRetry(from, to, attempts = 5) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      await rename(from, to)
+      return
+    } catch (error) {
+      const retriable = error?.code === 'EPERM' || error?.code === 'EBUSY' || error?.code === 'EACCES'
+      if (!retriable || attempt >= attempts) throw error
+      await new Promise((resolve) => setTimeout(resolve, attempt * 15))
+    }
+  }
+}
+/**
+ * Записать журнал.
+ *
+ * Запись идёт через временный файл с УНИКАЛЬНЫМ именем и переименованием.
+ * Прежнее имя складывалось из номера процесса и времени в миллисекундах —
+ * у двух одновременных записей оно совпадало, и вторая получала отказ на
+ * переименовании, потому что первая уже унесла общий временный файл.
+ */
 async function write(value, root = null) {
   const path = logPath(root)
   if (path === null) throw new Error('не найден каталог профиля — некуда писать журнал обзоров')
-  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`
-  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
-  await rename(temporary, path)
+  const temporary = `${path}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`
+  try {
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+    await renameWithRetry(temporary, path)
+  } catch (error) {
+    // Неудавшаяся запись не должна оставлять мусор рядом с настройками.
+    await rm(temporary, { force: true }).catch(() => {})
+    throw error
+  }
 }
 
 /**
@@ -147,23 +302,53 @@ async function write(value, root = null) {
  * @returns признак записи и признаки находок — по ним потом выносится приговор.
  */
 export async function recordRun(run, root = null) {
+  return serialise(logPath(root) ?? 'нет-пути', () => recordRunNow(run, root))
+}
+
+async function recordRunNow(run, root) {
   const log = await read(root)
 
-  const findings = (run.findings ?? []).map((finding) => ({
-    id: findingId(finding),
-    reviewer: finding.reviewer,
-    severity: finding.severity,
-    title: finding.title,
-    where: finding.where ?? null,
-    what: finding.what ?? null,
-    why: finding.why ?? null,
-    howToCheck: finding.howToCheck ?? null,
-  }))
+  // Повреждённый журнал НЕ затирается.
+  //
+  // Раньше любая ошибка чтения давала пустой журнал, и следующая же запись
+  // накрывала им настоящие данные: двести обзоров и все приговоры, включая
+  // возражения человека, исчезали от одной лишней запятой — молча, с
+  // обычным ответом об успехе. Файл правит и человек руками, это заявлено
+  // как штатное, так что случай не выдуманный.
+  if (log.intact === false) {
+    throw new Error(`журнал обзоров повреждён, запись отменена, чтобы не потерять прежние: ${log.problem ?? ''}`.trim())
+  }
+
+  const findings = []
+  const seen = new Set()
+  for (const finding of run.findings ?? []) {
+    let id = findingId(finding)
+    // Признак считается по содержанию, и две находки с одинаковыми
+    // ревизором, названием и местом получали ОДИН признак: приговор по
+    // первой молча становился приговором по второй, а вторая исчезала из
+    // разбора. Различаем порядковым номером в пределах обзора.
+    if (seen.has(id)) {
+      let suffix = 2
+      while (seen.has(`${id}-${suffix}`)) suffix += 1
+      id = `${id}-${suffix}`
+    }
+    seen.add(id)
+    findings.push({
+      id,
+      reviewer: finding.reviewer,
+      severity: finding.severity,
+      title: clip(finding.title, FIELD_CHARS) ?? '',
+      where: clip(finding.where, FIELD_CHARS),
+      what: clip(finding.what, FIELD_CHARS),
+      why: clip(finding.why, FIELD_CHARS),
+      howToCheck: clip(finding.howToCheck, FIELD_CHARS),
+    })
+  }
 
   const entry = {
-    id: `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    id: `run-${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`,
     at: new Date().toISOString(),
-    request: typeof run.request === 'string' ? run.request.slice(0, 400) : '',
+    request: clip(run.request, REQUEST_CHARS) ?? '',
     // Модель и усилие сохраняются вместе с находками: без них статистика
     // точности бессмысленна — «codex ошибается» ничего не значит, если
     // неизвестно, на какой модели и с каким усилием.
@@ -180,7 +365,7 @@ export async function recordRun(run, root = null) {
   log.runs.push(entry)
   if (log.runs.length > MAX_RUNS) log.runs = log.runs.slice(-MAX_RUNS)
 
-  await write(log, root)
+  await write({ runs: log.runs, verdicts: log.verdicts }, root)
   return { runId: entry.id, findingIds: findings.map((f) => f.id) }
 }
 
@@ -197,8 +382,45 @@ export async function recordRun(run, root = null) {
  */
 export async function recordVerdict(id, verdict, evidence, by = 'agent', root = null) {
   if (!VERDICTS.includes(verdict)) throw new Error(`неизвестный приговор: ${String(verdict)}`)
+  return serialise(logPath(root) ?? 'нет-пути', () => recordVerdictNow(id, verdict, evidence, by, root))
+}
+
+async function recordVerdictNow(id, verdict, evidence, by, root) {
+
+  // ДОКАЗАТЕЛЬСТВО ТРЕБУЕТСЯ, а не просто объявлено обязательным.
+  //
+  // Весь замысел держится на фразе «приговор без доказательства — это
+  // мнение», и я написал её в комментарии, не применив в коде: пустая
+  // улика превращалась в пустую строку, приговор записывался и входил в
+  // статистику наравне с проверенным. То есть единственной защитой была
+  // просьба к тому, кого этот механизм и должен проверять.
+  //
+  // Отложенное — исключение: «настоящая, но чиним не сейчас» доказывать
+  // нечем, это решение о приоритете, а не о факте.
+  const proof = typeof evidence === 'string' ? evidence.trim() : ''
+  if (verdict !== 'deferred' && proof.length < MIN_EVIDENCE_CHARS) {
+    throw new Error(
+      `приговор «${verdict}» требует доказательства: что именно проверено — ` +
+      `запущенная команда и её результат, прочитанные файл и строка, наблюдённое поведение`,
+    )
+  }
 
   const log = await read(root)
+  if (log.intact === false) {
+    throw new Error(`журнал обзоров повреждён, приговор не записан: ${log.problem ?? ''}`.trim())
+  }
+
+  // Приговор по НЕСУЩЕСТВУЮЩЕЙ находке отклоняется.
+  //
+  // Раньше он принимался, объявлялся применённым и терялся: агент мог дать
+  // признак из прошлого обзора или просто ошибиться, получить «Записано» —
+  // а в панели находка так и оставалась ждущей.
+  const known = new Set()
+  for (const run of log.runs) for (const finding of run.findings) known.add(finding.id)
+  if (!known.has(id)) {
+    return { id, applied: false, problem: 'находки с таким признаком нет ни в одном сохранённом обзоре' }
+  }
+
   const existing = log.verdicts[id]
 
   // Человек перекрывает агента, агент человека — нет. Иначе следующий обзор
@@ -209,12 +431,12 @@ export async function recordVerdict(id, verdict, evidence, by = 'agent', root =
 
   const entry = {
     verdict,
-    evidence: typeof evidence === 'string' ? evidence.slice(0, 800) : '',
+    evidence: clip(proof, EVIDENCE_CHARS) ?? '',
     by: by === 'human' ? 'human' : 'agent',
     at: new Date().toISOString(),
   }
   log.verdicts[id] = entry
-  await write(log, root)
+  await write({ runs: log.runs, verdicts: log.verdicts }, root)
   return { id, kept: entry, applied: true }
 }
 
@@ -232,13 +454,34 @@ export function accuracy(log) {
   const key = (finding, run) => {
     const used = (run.reviewers ?? []).find((r) => r.provider === finding.reviewer)
     const model = used?.model ?? null
-    return model === null ? finding.reviewer : `${finding.reviewer} · ${model}`
+    const effort = used?.effort ?? null
+    // Усилие входит в разрез наравне с моделью: быстрый прогон и глубокий
+    // — разные условия, и складывать их в одну долю значит мерить среднюю
+    // температуру. Без модели остаётся голое имя ревизора — так и пишем,
+    // честнее, чем выдумывать.
+    if (model === null && effort === null) return finding.reviewer
+    return `${finding.reviewer} · ${model ?? 'по умолчанию'}${effort === null ? '' : ` · ${effort}`}`
   }
 
-  for (const run of log.runs) {
+  // КАЖДАЯ находка считается ОДИН раз, сколько бы обзоров её ни повторили.
+  //
+  // Признак считается по содержанию, поэтому та же находка в следующем
+  // обзоре получает тот же признак и ссылается на тот же единственный
+  // приговор. Перебор по всем обзорам засчитывал каждое вхождение отдельно:
+  // пять повторов одной находки и один разбор давали ревизору пять ошибок.
+  // Особенно едко с «ответом не по формату» — у него постоянное название,
+  // и пять сорванных запусков превращались в пять ошибок ревизора.
+  const counted = new Set()
+
+  // Идём с конца: разрез берётся по САМОМУ СВЕЖЕМУ обзору, где находка
+  // встретилась, — там модель и усилие ближе всего к тому, что оценивают.
+  for (let index = log.runs.length - 1; index >= 0; index -= 1) {
+    const run = log.runs[index]
     for (const finding of run.findings ?? []) {
+      if (counted.has(finding.id)) continue
       const verdict = log.verdicts[finding.id]
       if (verdict === undefined || verdict.verdict === 'pending' || verdict.verdict === 'deferred') continue
+      counted.add(finding.id)
       const name = key(finding, run)
       const stat = byReviewer.get(name) ?? { reviewer: name, confirmed: 0, wrong: 0 }
       if (verdict.verdict === 'confirmed') stat.confirmed += 1
@@ -247,10 +490,28 @@ export function accuracy(log) {
     }
   }
 
+  // Сколько находок ревизор ВООБЩЕ выдал — вторая половина честной картины.
+  //
+  // Без неё ревизор, чьи находки никто не разбирал, выглядит наравне с тем,
+  // у кого разобрано всё, а агент, склонный подтверждать своё и откладывать
+  // чужое, сам себе рисует оценку. Пара «рассужено из выданных» этот перекос
+  // и показывает.
+  const produced = new Map()
+  const seenFindings = new Set()
+  for (const run of log.runs) {
+    for (const finding of run.findings ?? []) {
+      if (seenFindings.has(finding.id)) continue
+      seenFindings.add(finding.id)
+      const name = key(finding, run)
+      produced.set(name, (produced.get(name) ?? 0) + 1)
+    }
+  }
+
   return [...byReviewer.values()]
     .map((stat) => ({
       ...stat,
       judged: stat.confirmed + stat.wrong,
+      produced: produced.get(stat.reviewer) ?? stat.confirmed + stat.wrong,
       // Доля не округляется до целых процентов в источнике: пусть показ
       // решает сам, а данные остаются точными.
       rate: stat.confirmed + stat.wrong === 0 ? null : stat.confirmed / (stat.confirmed + stat.wrong),