validate.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Линтер батчей перевода: ловит поломки ДО вливания в игру.

Запуск:
    python validate.py                 # проверить все батчи crowdsource/*/*.csv
    python validate.py new/new_001.csv # конкретный файл/папку
    python validate.py --warnings      # показать и предупреждения (по умолчанию только ошибки)

Проверяет только НЕпустые переводы. Коды выхода: 0 — ошибок нет, 1 — есть ошибки.

ОШИБКИ (блокируют релиз):
  - набор плейсхолдеров/тегов (%str1%, <c=…>, [lbracket]/[rbracket]/[null]) не совпадает с оригиналом;
  - число %% не совпадает (одиночный % движок примет за начало спецификатора);
  - в переводе остался маркер оригинала [s], [pl:"…"], [f:"…"], [pf:]/[pm:]
    (не преобразован в группу форм: [форма1|форма2|форма3] для числа, [м|ж] для рода);
  - несбалансированные скобки [ ] или теги <c>…</c>;
  - символ U+FFFD (битая кодировка);
  - потерян структурный префикс «Recipe[s]: », «Chest[s]: » и т.п. (в переводе нет двоеточия);
  - две формы в плюрал-группе, когда в оригинале [s]/[pl:…] — русскому нужно три (1 / 2-4 / 5+);
  - четыре формы и больше: движок берёт из группы ровно три, лишняя уедет мусором;
  - пробел вместо формы («Пол[ |а|ов]») или пустая форма в середине группы
    («зон[ы||]» напечатает «1 зоны») — окончание потеряно; пустые по краям
    законны: «Ящик[|а|ов]», «секунд[а|ы|]», «раз[|а|]»;
  - скобочная группа вообще без | при [s]/[pl:…] в оригинале («Ящик[и]» вместо
    «[Ящик|Ящика|Ящиков]») — в игре отрендерится литералом вместе со скобками;
  - потерян родовой маркер [M]/[F] в начале строки;
  - запрещённая GLOSSARY.md форма имени, когда оригинал именно про этот термин
    («Crystal Oasis» -> ~~Хрустальный Оазис~~); «хрустальная банка» не трогается;
  - «висячий» знак ударения (U+0301) не на гласной — след опечатки;
  - латинская буква-двойник внутри русского слова («Лом Пактa»);
  - потерян перенос строки: игра рисует строку так, как её разбил оригинал,
    и без переноса фразы склеиваются («…площадке.Примечание:»);
  - потеряна подпись письма («—Rytlock» после пустой строки);
  - краевые пробелы не совпали с оригиналом — ломается склейка «Рецепт: » + название;
  - невидимый символ, которого нет в оригинале (zero-width, мягкий перенос):
    принесён копипастой, ломает поиск по строке и подстановку имён;
  - ПРЕДУПРЕЖДЕНИЕ «название дублирует слой `pn_*`»: перевод строки дословно
    равен записи слоя. Название живёт в двух местах, и любой из двух
    выключателей по отдельности бесполезен — чтобы увидеть английское, надо
    погасить и категорию, и слой. Лечится тем же приёмом, что названия карты:
    в категории оставить английский оригинал, русскую форму держит слой;
  - название из слоя pn_* есть в оригинале, но пропало из перевода — переведено
    («Легион Пламени напал» вместо «Flame Legion напал») или выброшено. И то и
    другое необратимо: выключатель имён подставляет русское НА английское, а
    когда английского в строке нет, подставлять уже некуда. Внутри фразы имя
    обязано остаться латиницей — слой сам покажет его по-русски.
    Считается только во ФРАЗЕ: строку, которая сама является названием, гасит
    своя категория целиком, и русская форма в ней законна. Признак фразы — три
    и более строчных слова вне самого названия. Класс заведён 2026-08-30 и
    сразу ловит 6,55% корпуса, потому что до сих пор правило не стереглось:
    `--warn-names` опускает его до предупреждения на время расчистки.

ПРЕДУПРЕЖДЕНИЯ (не блокируют):
  - лишний перенос строки в переводе (чаще хвостовой);
  - потерян неразрывный пробел или маркер списка • — страдает вид, не смысл;
  - скобочная группа без | там, где в оригинале нет [s]/[pl:…];
  - группа форм, а в оригинале ни [s]/[pl:…], ни числа рядом («[Сундук|Сундука|
    Сундуков] Амнитаса») — выбирать форму движку не по чему;
  - все формы в группе одинаковые («[Мини|Мини]»);
  - пустая форма 5+ при основе на стечение согласных: «секунд[а|ы|]» законно
    («5 секунд»), а «краск[а|и|]» даст «5 краск» вместо «красок» — беглая гласная;
  - плюрал-разметка потеряна совсем: в оригинале [s]/[pl:…] и рядом %num%, а в
    переводе скобок нет («Осмотрите %num1%/%num2% виды») — одна форма на все числа;
  - английский Title Case, перенесённый в русский («Знамя Поиска Магии»), — только
    одиночная заглавная в прозе: слово из слоя имён pn_*/GLOSSARY и слово рядом
    с другим заглавным («Дух Медведя») считаются частью названия и не метятся;
  - zero-width символы;
  - перевод дословно равен английскому предложению (возможно, не переведено);
  - у оригинала потеряна разметка: на сервере строка несёт %num2%/[s], а наша
    копия пришла без них («Complete  event.» вместо «Complete %num2% event[s].»).
    Сверка с sync/server_strings.csv; без этого файла проверка выключена;
  - похоже, потеряно число: точной реконструкции нет, но рядом стоит серверная
    строка с числом, а у нашей на его месте остался след — заглушка «x%»
    («Ascalonians remaining: x%» вместо «%num1%%%»), оборванное двоеточие
    («Waves defeated:»), голая косая. Ищется по расстоянию Левенштейна;
  - «ты» и «вы» в одной строке (разнобой обращения);
  - оригинал кончается на .!? — перевод нет (потерянная точка);
  - пробел перед знаком препинания.

ПРЕДУПРЕЖДЕНИЯ по русской типографике (свод правил, README → «Русская типографика»):
  - потеряна буква ё в слове, где написания через «е» не существует («еще», «придет»);
  - сочетание знаков, которого в русском нет: «!?», «...?», «???», «??!»;
    допустимы только ?! ?!! !! !!! ?.. !.. ?!. ...;
  - точка внутри кавычек («…клинка.» вместо «…клинка».);
  - рисунок кавычек: прямые вместо «ёлочек», разнобой в одной строке,
    непарные кавычки, вложенные кавычки того же рисунка (внутренние — „…“);
  - звукоподражание без дефиса («Ааа!» вместо «А-а-а!»);
  - «Вы» с прописной (это из деловой переписки, а не из игрового текста);
  - падежное окончание при цифре («5-ый» вместо «5-й», «5-ого» вместо «5-го»);
  - слова вне стандарта интерфейса: «кликнуть», «юнит», «хиты», «левый щелчок»,
    «опции» при Options, «назначение клавиш» при Controls;
  - переведённое название языка в меню выбора языка;
  - «Бог» с прописной в устойчивом обороте («не дай Бог», «Боже мой»).
"""
import csv, glob, os, re, sys

try:
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
except Exception:
    pass

TOK = re.compile(r'%\w+%|<[^>]+>|\[lbracket\]|\[rbracket\]|\[null\]')
CYR = re.compile(r'[а-яёА-ЯЁ]')
# Маркеры оригинала, которые обязаны раствориться в группе форм. [f:] — род,
# [pf:]/[pm:] — род с числом (французский клиент). В переводе любой из них
# отрендерится литералом вместе со скобками, как и забытый [pl:].
LEFTOVER = re.compile(r'\[s\]|\[pl:|\[f:|\[p[fm]:')
ZW = re.compile(r'[​‌‍]')
ZW_CHARS = "​‌‍⁠­"
# Пробельные символы, которые держат склейку. Перенос строки сюда НЕ входит:
# он про вёрстку и проверяется отдельно.
EDGE_WS = " \t             　"
NOSPACE = re.compile(r'\s+')
# Подпись письма: последняя строка вида «—Rytlock», «— Warmaster Jofast».
SIGNATURE = re.compile(r'\n[ \t]*[—–][ \t]*([^\n]{2,40})[ \t]*$')
# ["s"] — тот же плюрал-маркер, только кавычки уехали внутрь скобки (ArenaNet,
# «Recollection["s"] of the Bearkin's Hunts»). Без этого варианта правило считает,
# что склонять не по чему, и ругается на верную группу форм.
# Родовой маркер оригинала. Если он есть, двухформенная группа в переводе —
# это род («Бог[|иня]»), а не потерянная третья форма числа, даже когда рядом [s].
GENDER_SRC = re.compile(r'\[f:|\[p[fm]:')
PLURAL_EN = re.compile(r'\[s\]|\[pl:|\["s"\]')
NUM_PH = re.compile(r'%num\d*%')
# Скобка с текстом внутри в САМОМ оригинале: пояснение игры, а не группа форм.
BRACKET_SRC = re.compile(r'\[[^\[\]]*\]')
# Число замыкает фразу: после него в переводе русских букв уже нет. Так выглядит
# счётчик («Разобрано предметов: %num1%»), где склонять по числу нечего.
NUM_TAIL = re.compile(r'%num\d*%[^А-Яа-яЁё]*$')
# «Recipe[s]: », «Trophy: » — структурный префикс имени предмета. Если в переводе
# нет двоеточия, слово-префикс просто потеряли (так new_023 лишился всех «Рецепт»).
PREFIX_EN = re.compile(r'^[A-Z][A-Za-z\' -]{2,30}(?:\[s\]|\[pl:"[^"]*"\]):\s')
# Знак ударения ставится на гласную; на согласной/кавычке — мусор от набора.
STRESS_OK = re.compile(r'[аеёиоуыэюяАЕЁИОУЫЭЮЯ]́')
STRESS_ANY = re.compile(r'[̀-ͯ]')
TY = re.compile(r'\b(ты|тебя|тебе|тобой|твой|твоя|твоё|твои|твоего|твоей|твоих|твою|твоим|твоём)\b', re.I)
# Латинская буква-двойник внутри русского слова («Лом Пактa» — последняя 'a' латинская).
# Глазом не видно, а слово уже не русское: ломается поиск и подстановка имён.
# Ошибкой считаем только два случая — буква зажата кириллицей («кастoранской») или
# строчная буква в конце русского слова («Пактa»). Заглавная латиница после кириллицы
# обычно склеенное сокращение («ДеббиP.S.»), а латиница рядом с латиницей — имя («Kye»).
HOMO = set('aceopxyABCEHKMOPTX')

def homoglyph(s):
    def cyr(ch):
        return bool(ch) and ('а' <= ch.lower() <= 'я' or ch.lower() == 'ё')
    for i, ch in enumerate(s):
        if ch not in HOMO or not cyr(s[i-1] if i else ''):
            continue
        nxt = s[i+1] if i + 1 < len(s) else ''
        if cyr(nxt) or (ch.islower() and not (nxt.isascii() and nxt.isalpha())):
            return s[max(0, i-8):i+8]
    return None
VY = re.compile(r'\b(вы|вас|вам|вами|ваш|ваша|ваше|ваши|вашего|вашей|ваших|вашу|вашим|вашем)\b', re.I)

def tokens(s):
    return sorted(TOK.findall(s))

# Служебные токены движка в квадратных скобках — это НЕ плюрал-группы [a|b|c],
# поэтому перед проверкой скобок их убираем (иначе ложное «скобка без |»).
# [M]/[F] — родовой маркер в начале строки, корпус его всегда сохраняет.
KNOWN_TOKENS = re.compile(r'\[(?:lbracket|rbracket|null|plur|nosep|topic-[fm]|f|an|the|[MF])\]|\[pl:"[^"]*"\]')
GENDER_MARK = re.compile(r'^\[([MF])\]')
# Основа перед группой форм — нужна, чтобы судить о пустой форме 5+.
GROUP_STEM = re.compile(r'([А-Яа-яЁё-]*)(\[[^\]]*\])')
# Пустая форма 5+ законна, когда голая основа и есть родительный множественного:
# «секунд[а|ы|]» -> «5 секунд», «руин[у|ы|]» -> «5 руин». Но если основа кончается
# стечением согласных, родительному нужна беглая гласная, и пустая форма врёт:
# «краск[а|и|]» -> «5 краск» вместо «красок», «башн[ю|и|]» -> «башн» вместо «башен».
FLEETING = re.compile(r'(?:[бвгджзйклмнпрстфхцчшщь]к|[бвгджзклмпрстфхшщр]н|[льнй]ц|сл)$')

def empty_forms(stem, grp, forms, warns):
    """Пустые формы внутри группы: где законны, где брак."""
    errs = []
    # Пробел — не форма: «Пол[ |а|ов]» напечатает «Пол » с висячим пробелом.
    if any(f and not f.strip() for f in forms):
        errs.append(f"пробел вместо формы в группе: {grp}")
        return errs
    empty = [i for i, f in enumerate(forms) if not f]
    # Край группы пустым быть вправе: первая форма — режим окончаний («Ящик[|а|ов]»),
    # последняя — основа и есть родительный множественного. Пустыми могут быть и обе
    # сразу: «раз[|а|]» -> «1 раз / 2 раза / 5 раз». А вот пустая в середине — это
    # потерянное окончание («зон[ы||]» напечатает «1 зоны»).
    if empty and len(empty) < len(forms):
        mid = [i for i in empty if i not in (0, len(forms) - 1)]
        if mid:
            errs.append(f"пустая форма в середине группы: {grp}")
    if (not errs and empty and empty[-1] == len(forms) - 1
            and len(forms) == 3 and FLEETING.search(stem.lower())):
        warns.append(f"пустая форма 5+ при основе на стечение согласных — "
                     f"нужна беглая гласная: {stem}{grp} -> «{stem}»")
    return errs

# Слово перед группой, которое в группе же и повторено (см. проверку ниже).
DUP_WORD = re.compile(r'([А-Яа-яЁё-]{4,})\[([^\]\[]*\|[^\]\[]*)\]')

def strip_known(s):
    s = re.sub(r'%\w+%', '', s)
    s = re.sub(r'<[^>]+>', '', s)
    return KNOWN_TOKENS.sub('', s)

# Запрещённые формы имён берём прямо из GLOSSARY.md — из колонки «НЕ так» (~~форма~~).
# Правило привязано к оригиналу: ругаемся на «Хрустальный оазис» только когда в EN
# действительно Crystal Oasis, иначе поймали бы честную хрустальную банку.
# Запрещённая форма записана в глоссарии в именительном падеже, а в тексте она
# стоит в любом. Сравнение по точной строке пропускало «Криты», «ледорождённых»,
# «Древних драконов» — то есть почти всё, кроме словарной формы. Собираем из слова
# основу и допускаем за ней русское окончание; основа короче четырёх букв не
# склоняется, чтобы не ловить однокоренной мусор.
RU_END = ('ый|ий|ой|ая|яя|ое|ее|ые|ие|ого|его|ому|ему|ым|им|ом|ем|ых|их|ыми|ими|ую|юю'
          '|ов|ев|ей|ам|ям|ами|ями|ах|ях|ия|ию|ии|ием|иям|иями|иях'
          '|а|я|о|е|ы|и|у|ю|й|ь')
# «ей» — родительный множественного («сигилов» есть, а «печатей» не было) и
# творительный женского («стражей»). Без него правила глоссария молча пропускали
# целый падеж: замер по корпусу дал 19 находок и ни одного ложного срабатывания.
# «ия|ию|ии|ием|иям|иями|иях» — та же дыра у среднего рода на «-ие». STRIP срезает
# «ие» и оставляет основу «отделен», а склоняется такое слово через «и»:
# «отделения», «отделению», «отделением», «отделении». Без этих окончаний запрет
# ловил только словарную форму — «Астральное отделение» ловилось, «Астрального
# отделения» проходило. Замер по корпусу: три находки, ложных нет.
STRIP = re.compile(r'(?:ый|ий|ой|ая|яя|ое|ее|ые|ие|а|я|о|е|ы|и|й|ь)$')

def ban_pattern(ban):
    """Запрещённая форма во всех падежах: «Крита» -> Крит + окончание."""
    parts = []
    for word in ban.split():
        if re.fullmatch(r'[А-Яа-яЁё-]{5,}', word):
            stem = STRIP.sub('', word)
            if len(stem) >= 4:
                parts.append(re.escape(stem) + '(?:' + RU_END + ')?')
                continue
        parts.append(re.escape(word))
    return r'(?<![А-Яа-яЁё])' + r'\s+'.join(parts) + r'(?![А-Яа-яЁё])'

# Пробел внутри составного EN-термина: в оригинале то же имя встречается и через
# дефис — «Ley Line Nexus» и «Ley-Line Nexus» лежат в корпусе рядом. re.escape
# пробел экранирует, поэтому правило видело только вариант с пробелом, а дефисные
# оригиналы проходили мимо (по корпусу на 21.08.2026 так пряталось 15 строк).
ESC_SPACE = re.escape(' ')
# И ровно то же с дефисом: ключ глоссария может быть записан через него
# («Ley-Line Scavenger»), а в корпусе рядом лежит вариант с пробелом.
ESC_DASH = re.escape('-')

def load_glossary_bans(path=None):
    path = path or os.path.join(os.path.dirname(os.path.abspath(__file__)), 'GLOSSARY.md')
    rules = []
    try:
        lines = open(path, encoding='utf-8').read().splitlines()
    except OSError:
        return rules
    for line in lines:
        cells = [c.strip() for c in line.strip().strip('|').split('|')]
        if len(cells) < 3 or cells[0] in ('EN', '---'):
            continue
        ens = [re.sub(r'\(.*?\)', '', x).strip() for x in cells[0].split('/')]
        # Дефис в ключе разрешён: без него «Ley-Line Scavenger» отсеивался прямо
        # здесь, и правило по такому термину не собиралось вовсе.
        ens = [e for e in ens if re.fullmatch(r"[A-Za-z'\- ]{3,}", e)]
        bans = []
        for m in re.finditer(r'~~([^~]+)~~', cells[2]):
            bans += [x.strip() for x in m.group(1).split('/') if len(x.strip()) > 3]
        if ens and bans:
            # Апостроф в имени бывает и типографским: «Divinity's Reach» в одних
            # строках игры, «Divinity’s Reach» в других. Правило, собранное по
            # ASCII-апострофу, вторые молча пропускало.
            en_re = re.compile('|'.join(r'\b' + re.escape(e).replace("'", "['’ʼ]")
                                                .replace(ESC_SPACE, '[ -]')
                                                .replace(ESC_DASH, '[ -]') + r'\w{0,3}\b'
                                        for e in ens), re.I)
            # Если «НЕ так» отличается от канона только регистром («Дозор Духов» /
            # «Дозор духов») — правило про регистр, ищем точно. Иначе регистр не важен.
            ban_re = [(b, re.compile(ban_pattern(b),
                                     0 if b.lower() == cells[1].lower() else re.I))
                      for b in bans]
            # Запрет бывает куском самого канона: «Огненное Сердце» лежит внутри
            # «Возвышенности Огненного Сердца», «Гендарран» — внутри «Гендарранских
            # полей». Без оговорки правило ругается на верный перевод.
            canon_re = re.compile(ban_pattern(cells[1].split(' / ')[0]), re.I)
            rules.append((en_re, cells[1], ban_re, canon_re))
    return rules

# Слово, при котором запрет снимается: оно само законно переводится запрещённой
# формой, и правило иначе даёт ложное срабатывание.
GLOSS_ALSO_OK = {'Скайскейл': 'griffon'}
# Правило иногда цепляет однокоренной оригинал, к которому канон не относится:
# «Sovereign» в глоссарии — про сет оружия, а Sovereign of Nayos — глава сюжета,
# Sovereign Eye of Zhaitan — босс. Их канон не касается.
GLOSS_SKIP_EN = {'«Властелин»': r"Sovereign(?:'s|\s+(?:of|Eye))|(?:Mother|High)\s+Sovereign"
                                r'|(?<![A-Za-z])sovereign(?![A-Za-z])',
                 # Minor/Major/Superior — префикс рун и сигилов, и канон только про
                 # него. Со строчной буквы это обычные слова: «grand majority»,
                 # «major destinations», «Pact superiors». Заглавная отделяет одно
                 # от другого без исключений — проверено по всему корпусу.
                 'малая-малый / большая-большой / высшая-высший':
                     r"(?s)\A(?!.*(?-i:\b(?:Minor|Major|Superior)\b))",
                 # Inscription — не только компонент крафта: «An inscription on this
                 # memorial says…», «The inscription inside the ring is too worn». Там
                 # «надпись» и есть правильный перевод. Признак компонента — крафтовый
                 # контекст (recipe, crafting, стат, ремесленник) или имя предмета с
                 # заглавной («Orichalcum Imbued Inscription», «Inscription[s]»); если
                 # ни одного нет, а рядом стоит слово про чтение/камень/страницу —
                 # запрет снимаем.
                 'инсигния / гравировка':
                     r"(?s)\A"
                     r"(?!.*(?:\brecipe|\bcraft|\bexotic\b|\bascended\b|\bstats?\b|\battribute"
                     r"|insignia|smith\b|artificer|huntsman|leatherworker|tailor|jeweler"
                     r"|\+Power|\+Vitality|\+Toughness|\+Precision|\+Healing|\+Condition"
                     r"|(?-i:Inscription\[s\]|[A-Z][a-z]+(?:'s)?\s+(?:[A-Z][a-z]+\s+)*Inscription)))"
                     r".*(?:(?-i:(?<![A-Za-z])inscription)|reads|\bread\b|says|\bsay\b|inscribed"
                     r"|engraved|etched|carved|memorial|gravestone|headstone|tombstone|plaque"
                     r"|monument|statue|obelisk|shrine|\bgrave\b|illegible|legible|discernable"
                     r"|epitaph|\bpages?\b|scroll)"}

GLOSSARY_BANS = load_glossary_bans()

# Слой имён — источник правды о том, какие слова в русском законно с заглавной.
# Берём КАЖДОЕ заглавное слово перевода, а не имя целиком: в корпусе имя стоит в
# падеже и по частям («Расплавленный Альянс» -> «Расплавленного Альянса»), целиком
# оно не найдётся никогда.
def layer_files(root=None):
    """Батчи слоя имён.

    Слой живёт в `pn/`, а не в корне: `pn_additions.csv`, `pn_harvest.csv` и
    прочие `pn_*.csv` в корне — это черновики выгрузок, а не слой. Пока сюда
    подставлялся корень, защита имён строилась по 2 955 словам из черновиков
    вместо 24 тысяч записей настоящего слоя.
    """
    root = root or os.path.dirname(os.path.abspath(__file__))
    return sorted(glob.glob(os.path.join(root, 'pn', 'pn_*.csv')))


def load_name_words(root=None):
    root = root or os.path.dirname(os.path.abspath(__file__))
    words = set()
    for path in layer_files(root):
        try:
            rows = csv.reader(open(path, encoding='utf-8-sig', newline=''))
        except OSError:
            continue
        for i, r in enumerate(rows):
            if i and len(r) > 1:
                words |= {w.lower() for w in re.findall(r'[А-ЯЁ][а-яё]{2,}', r[1])}
    # Канон глоссария — третья колонка таблицы, там же имена регионов и фракций.
    try:
        lines = open(os.path.join(root, 'GLOSSARY.md'), encoding='utf-8').read().splitlines()
    except OSError:
        lines = []
    for line in lines:
        cells = [c.strip() for c in line.strip().strip('|').split('|')]
        if len(cells) > 2:
            words |= {w.lower() for w in re.findall(r'[А-ЯЁ][а-яё]{2,}', cells[2])}
    return words

NAME_WORDS = load_name_words()

# ---- название из слоя переведено прямо в тексте вместо латиницы -------------
# Выключатель имён работает только если общий словарь оставил название латиницей:
# игрок гасит `pn_*`, а слой подставляет обратно английское. Если же перевод уже
# написал название кириллицей, вернуть английский нечем — обратимость потеряна.
EN_CAP = re.compile(r"[A-Z][A-Za-z'’\-]{2,}")
LOWER_WORD = re.compile(r'(?<![A-Za-z])[a-z]{2,}(?![A-Za-z])')

# Ошибка или предупреждение. Класс заведён 2026-08-30 и сразу поймал 30 544
# строки (6,55%) в 934 файлах из 996 — то есть блокирует сдачу почти всего
# корпуса, потому что до сих пор правила никто не стерёг. Держим ошибкой
# сознательно: так дефект не размножается дальше. Опустить до предупреждения на
# время расчистки — поставить False здесь или запустить с `--warn-names`.
NAME_LOST_IS_ERROR = True


def load_name_pairs(root=None):
    """Названия из батчей слоя, разложенные по первому слову.

    Берём только те, у которых в слое есть русская форма: если её нет, слою
    нечего подставлять и латиница в переводе останется латиницей сама собой.
    Одиночные слова не берём — в слое их полно по ошибке («Boots», «Champion»,
    «Keep»), и кириллица на их месте обычный перевод, а не потеря имени.
    """
    by_first = {}
    for path in layer_files(root):
        try:
            rows = csv.reader(open(path, encoding='utf-8-sig', newline=''))
        except OSError:
            continue
        for i, r in enumerate(rows):
            if not i or len(r) < 2:
                continue
            en, ru = r[0].strip(), r[1].strip()
            if len(en.split()) < 2 or not CYR.search(ru):
                continue
            w = EN_CAP.findall(en)
            if not w:
                continue
            rx_en = re.compile(r'(?<![A-Za-z])' + re.escape(en) + r'(?![A-Za-z])')
            by_first.setdefault(w[0], []).append((en, rx_en))
    return by_first


NAME_PAIRS = load_name_pairs()


def load_layer_ru(root=None):
    """{английское название: русская форма} — ВЕСЬ слой, без отбора.

    Нужен не для канона, а для поиска дублей: если общая категория повторяет
    ровно то, что отдаёт слой, выключатель имён на этой строке бесполезен.
    """
    out = {}
    for path in layer_files(root):
        try:
            rows = csv.reader(open(path, encoding='utf-8-sig', newline=''))
        except OSError:
            continue
        for i, r in enumerate(rows):
            if i and len(r) >= 2 and r[0].strip() and r[1].strip():
                out.setdefault(r[0].strip(), r[1].strip())
    return out


LAYER_RU = load_layer_ru()


def layer_duplicate(path, en, ru):
    """Категория держит английский оригинал, а русскую форму — только слой.

    Так раскладывал названия `layerdedup.py` (2026-09-03): расчёт был, что
    мод при включённом `translate_proper_nouns` подставит форму из слоя. В игре
    это неверно (проверено 2026-09-28 на Хранилище Волшебника): если у строки
    есть своя запись в категории — пусть английская, — мод показывает её, и
    слой её не перекрывает. Игрок видит английский при любых настройках.

    Целое название переводится в своей категории; вернуть английское можно,
    отключив категорию в «Файлах перевода». Слой сам не проверяем.

    Раньше здесь было обратное правило — «оставь в категории английский»; оно и
    наплодило 78 624 таких строки.
    """
    if not LAYER_RU or "pn" in path.replace("\\", "/").split("/")[:-1]:
        return None
    form = LAYER_RU.get(en.strip())
    if form and ru.strip() == en.strip() and re.search(r"[А-Яа-яЁё]", form):
        return ("в категории оригинал, а перевод только в слое `pn_*` — мод "
                "покажет английский даже с translate_proper_nouns; поставь "
                "форму слоя: %s" % form[:60])
    return None


# Приказ игроку: строка начинается с глагола в повелительном наклонении. Так
# устроены задания и события («Defeat Cardinal Adina.»), и названием такая
# строка не бывает — значит имя внутри неё должно стоять латиницей.
IMPERATIVE = re.compile(
    r'^(?:\([^)]*\)\s*)?(Defeat|Complete|Kill|Find|Collect|Escort|Help|Assist|'
    r'Speak|Talk|Use|Enter|Reach|Destroy|Defend|Gather|Deliver|Return|Visit|'
    r'Explore|Unlock|Obtain|Earn|Win|Survive|Protect|Capture|Investigate|Slay|'
    r'Discover|Rescue|Escape|Activate|Interact|Bring|Give|Take|Follow|Stop|'
    r'Clear|Repair|Retrieve|Search|Free|Save|Guard|Recover)\b')


def layer_name_lost(en, ru):
    """Названия из слоя, которые есть в оригинале и пропали из перевода.

    Правило простое намеренно: искать русскую форму по основе (как делалось
    сперва) — значит ловить только те переводы, что совпали со слоем дословно.
    Мимо проходило «Eye of the North» → «Ока Севера», «Bjora Marches» →
    «Топях Бьоры»: переводчик взял свою форму, и стемминг её не догонял. Отсюда
    +11 364 строки находок при той же точности. Отсутствие имени в переводе —
    достаточная улика: неважно, переведено оно или выброшено, вернуть его к
    английскому выключателем уже нельзя.

    Считаем только во ФРАЗЕ. Строка, которая сама является названием, гасится
    своей категорией целиком, и русская форма в ней законна. Признак фразы —
    три и более строчных слова вне самого названия: «(Annual) A Royal Tradition»
    и «Soft Wood Short Bow» так отсеиваются, а «Combine this weapon in the
    Mystic Forge with…» остаётся.

    Второй признак фразы — приказ игроку. «Defeat Cardinal Adina.» и «Help
    Sergeant Rane» строчных слов почти не имеют и по счёту слов отсеивались
    вместе с названиями, хотя это не названия, а задания, и имя в них обязано
    стоять латиницей. Глагол в повелительном наклонении в начале строки
    отличает приказ от названия надёжнее, чем длина: названия достижений с
    него не начинаются.
    """
    if not NAME_PAIRS:
        return []
    # Строка, которая САМА целиком лежит в слое, — название, а не фраза:
    # «Return to A Kindness Repaid», «Lost Lore of the Domain of Vabbi». Имя
    # внутри названия переводится вместе с ним, требовать там латиницу — ложная
    # тревога (144 названия достижений на 2026-09-28).
    if en.strip() in LAYER_RU:
        return []
    order = bool(IMPERATIVE.search(en))
    if len(en.split()) < 4 and not order:
        return []
    lc_all = len(LOWER_WORD.findall(en))
    out = []
    for w in set(EN_CAP.findall(en)):
        for name, rx_en in NAME_PAIRS.get(w, ()):
            if name == en.strip() or name in ru:
                continue
            if not order and lc_all - len(LOWER_WORD.findall(name)) < 3:
                continue
            if rx_en.search(en):
                out.append(name)
    return out

# Русский текст не пишут английским Title Case («Знамя Поиска Магии»). Отличить
# перенесённую капитализацию от имени собственного по одной строке нельзя, поэтому
# спрашиваем у самого корпуса: если слово в середине фразы 160k строк почти всегда
# строчное — заглавная в нём подозрительна; имена собственные так защищены сами.
TITLE_CASE = re.compile(r'(?<=[а-яё] )[А-ЯЁ][а-яё]{2,}')
MID_WORD = re.compile(r'(?<=[а-яё] )[А-Яа-яЁё]{3,}')
RU_WORD = re.compile(r'[А-Яа-яЁё]+')
# Заглавная в начале предложения ничего не говорит о слове — как признак имени
# она не считается.
SENT_START = re.compile(r'(?:^|[.!?:;•]|\n|\[|<[^>]*>)\s*$')

def title_case_suspects(ru):
    """Заглавные в середине фразы, которые не объясняются именем собственным.

    Пословная модель корпуса не видит составных названий: в «Дух Медведя», «Мир
    против Мира», «Старший дракон Воды» с заглавной стоит нарицательное, и по
    отдельности каждое из этих слов в корпусе почти всегда строчное. Поэтому слово
    снимается с подозрения, если оно есть в слое имён либо если вплотную к нему
    стоит другое заглавное — признак того, что это часть названия.
    """
    toks = list(RU_WORD.finditer(ru))
    starts = {t.start(): i for i, t in enumerate(toks)}

    def is_name_cap(i):
        """Заглавное слово, которое стоит не в начале предложения."""
        t = toks[i]
        return t.group()[0].isupper() and not SENT_START.search(ru[:t.start()])

    out = []
    for m in TITLE_CASE.finditer(ru):
        if m.group().lower() in NAME_WORDS:
            continue
        i = starts.get(m.start())
        if i is None:
            continue
        near = False
        for j in (i - 1, i + 1):
            if 0 <= j < len(toks) and is_name_cap(j):
                a, b = (i, j) if i < j else (j, i)
                # Соседним считаем только вплотную: через пробел или дефис.
                if re.fullmatch(r'[  -]+', ru[toks[a].end():toks[b].start()]):
                    near = True
        if not near:
            out.append(m.group())
    return out

# Часть строк пришла в батчи с потерянной разметкой: «Complete  event.» вместо
# «Complete %num2% event[s].». Двойной пробел — след того места, где стоял
# плейсхолдер. Заметить это по самой строке нельзя: она выглядит целой, и линтер
# спокойно принимает перевод без числа, потому что числа нет и в оригинале.
#
# Поэтому сверяемся с выгрузкой строк игры (sync/server_strings.csv, только те,
# что несут плейсхолдер или плюрал-разметку). Файла может не быть — тогда проверка
# просто выключена, линтер остаётся рабочим на голом клоне.
SRV_MARKUP = re.compile(r'%\w+%|\[s\]|\[pl:"|\[nosep\]|\[null\]')

def load_server_strings(path=None):
    path = path or os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                'sync', 'server_strings.csv')
    by_skel = {}
    try:
        rows = csv.reader(open(path, encoding='utf-8', newline=''))
    except OSError:
        return by_skel
    for i, r in enumerate(rows):
        # Вторая колонка помечает строки, у которых в игре есть голый двойник без
        # числа: «Gold» существует рядом с «%num1% Gold», «Tier: » рядом с
        # «Tier: %num1%». Для них совпадение «наша строка = серверная минус
        # плейсхолдер» не доказывает ничего — наша копия скорее подпись, чем
        # обрезок. Такие в индекс не берём вовсе.
        if i and r and r[0] and not (len(r) > 1 and r[1].strip()):
            by_skel.setdefault(server_skel(r[0]), set()).add(r[0])
    return by_skel

def server_skel(s):
    """Строка без разметки и без пробелов вовсе.

    Пробелы убираются целиком, а не схлопываются: «achievement[s].» после снятия
    разметки даёт «achievement .» — с пробелом перед точкой, — и схлопывание не
    свело бы его с «achievement.» из батча.
    """
    return re.sub(r'\s+', '', KNOWN_TOKENS.sub(' ', re.sub(r'%\w+%|\[s\]', ' ', s))).lower()

SERVER_STRINGS = load_server_strings()

def edit_distance(a, b, cap=12):
    """Расстояние Левенштейна, оборванное на cap: точное значение дальше не нужно."""
    if abs(len(a) - len(b)) > cap:
        return cap + 1
    prev = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        cur = [i]
        for j, cb in enumerate(b, 1):
            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
        if min(cur) > cap:
            return cap + 1
        prev = cur
    return prev[-1]

# Точная реконструкция ловит только тот случай, когда из строки аккуратно вынули
# плейсхолдер и больше ничего не тронули. Но порча бывает и другой: на месте числа
# оставили заглушку («Ascalonians remaining: x%» вместо «%num1%%%»), вписали
# конкретное значение («Golem cannons remaining: 3/3»), обрубили весь хвост
# («Bombs Remaining» вместо «Bombs Remaining: %num1%»). Такие ищем по расстоянию.
#
# Полный перебор не нужен: цель — только строки с числом, кандидаты берутся по
# краям. Выпавшее из середины сохраняет оба края, выпавшее с краю — второй край.
SERVER_NUM = re.compile(r'%num\d*%')
SRV_PRE, SRV_SUF = {}, {}

def _index_numbered():
    for skels in SERVER_STRINGS.values():
        for s in skels:
            if SERVER_NUM.search(s):
                k = server_skel(s)
                SRV_PRE.setdefault(k[:10], []).append(s)
                SRV_SUF.setdefault(k[-10:], []).append(s)

_index_numbered()
_LETTERS = re.compile(r'[^a-z]')
# След изъятия. Без него эвристика метит и законные подписи интерфейса: рядом с
# «Motes Collected» в игре просто существует счётчик «%num1%/%num2% Motes
# Collected», и это две разные строки, а не порча. Ловим только то, где на месте
# числа что-то осталось: зазор, голая косая, оборванное двоеточие, заглушка «x».
SEAM = re.compile(r'[A-Za-z0-9]  +[A-Za-z0-9]|\s/\s|[:—-]\s*$|:\s*[xX]\b|\bx\s*%|'
                  r'\(\s*\)|\[\s*\]|^\s|\s$')
_near_cache = {}

def _bare(s):
    return re.sub(r'\s+', ' ', SERVER_NUM.sub('', s)).strip()

def server_near(en):
    """Похожая серверная строка, у которой число есть, а у нашей копии нет.

    Решает не расстояние само по себе, а ЧТО разошлось. У настоящей потери
    различие только в разметке и пунктуации; если разошлись буквы — это просто
    соседняя строка: «Unlock all  Fused weapon skins» подтягивался к «Unlock all
    %num2% Auric weapon skins», хотя наборы обликов разные. Поэтому решающая
    проверка — расстояние по одним буквам, без цифр и знаков.
    """
    if en in _near_cache:
        return _near_cache[en]
    if not SEAM.search(en):
        _near_cache[en] = None
        return None
    res = None
    k = server_skel(en)
    cand = set(SRV_PRE.get(k[:10], ())) | set(SRV_SUF.get(k[-10:], ()))
    if cand:
        flat = re.sub(r'\s+', ' ', en).strip()
        best, bd = None, 99
        for c in cand:
            d = edit_distance(flat, _bare(c), cap=8)
            if d < bd:
                best, bd = c, d
        if best is not None and 0 < bd <= 6:
            ld = edit_distance(_LETTERS.sub('', flat.lower()),
                               _LETTERS.sub('', _bare(best).lower()), cap=4)
            if ld <= 2:
                res = f"похоже, потеряно число, на сервере: «{best[:60]}»"
    _near_cache[en] = res
    return res

def server_check(en):
    """Предупреждение, если у строки на сервере есть разметка, а у нашей копии нет."""
    if not SERVER_STRINGS or SRV_MARKUP.search(en):
        return None
    cand = SERVER_STRINGS.get(server_skel(en))
    if not cand:
        return None
    # Совпадение по скелету значит «та же строка без разметки». Берём ближайший
    # по Левенштейну вариант: скелет мог свести несколько родственных строк.
    best = min(cand, key=lambda c: edit_distance(en, c))
    if edit_distance(en, best) == 0:
        return None
    # Считаем только числовые плейсхолдеры. Обёртка %str1%%str2%…%str3%%str4% —
    # это отдельная строка игры (шаблон подстановки имени), а не наша испорченная
    # копия: «Corrupted Hero Greatsword» и «%str1%%str2%Corrupted Hero Greatsword%str3%%str4%»
    # существуют обе. По скелету они неразличимы, и на них проверка давала 6 246
    # ложных срабатываний из 6 311.
    lost = sorted(set(re.findall(r'%num\d*%', best)) - set(re.findall(r'%num\d*%', en)))
    if not lost:
        return None
    # Плейсхолдер, приклеенный к слову вплотную («M%num1%», «brood%num1%»), при
    # удалении не оставляет следа, и наша строка — не обрезок, а отдельное имя.
    # След оставляет только отдельно стоящий токен.
    if not any(re.search(r'(?:^|[^A-Za-z0-9])' + re.escape(p) + r'(?:[^A-Za-z0-9]|$)', best)
               for p in lost):
        return None
    # Решающая проверка: снимаем с серверной строки разметку и требуем СОВПАДЕНИЯ
    # с нашей буква в букву. Скелет игнорирует пробелы, поэтому сам по себе он
    # сводит и неродственные строки; точная реконструкция — не сводит.
    if re.sub(r'\s+', ' ', re.sub(r'%num\d*%|\[s\]|\[pl:"[^"]*"\]', '', best)).strip() \
            != re.sub(r'\s+', ' ', en).strip():
        return None
    return f"потеряна разметка оригинала ({' '.join(lost)}), на сервере: «{best[:60]}»"

# Число — единственная часть строки, которую перевод обязан повторить дословно, и
# единственный смысловой сдвиг, который вообще ловится машиной: «Contains 200» ->
# «Содержит 300» игрок видит как враньё. Разделитель тысяч нормализуем (1,400 =
# 1400), внутрь плейсхолдеров (%num1%) не лезем — там цифра часть имени.
# Цифра, приклеенная к букве, — часть имени, а не величина: FRU1TPUNCH, IIX0.
_NB = r'(?<![A-Za-z0-9])'
NUMBER = re.compile(_NB + r'\d{1,3}(?:[, ]\d{3})+(?![A-Za-z0-9])|'
                    + _NB + r'\d+(?![A-Za-z0-9])')

def numbers(s):
    """Числа строки. Плейсхолдеры и теги выкидываем: цифра в %num1% и <c=@a1> —
    часть имени токена, а не величина."""
    s = re.sub(r'%\w+%|<[^>]+>|\[pl:"[^"]*"\]', ' ', s)
    # «0330 hours» по-русски пишут «03:30» — это то же число, а не потеря.
    s = re.sub(r'(?<=\d):(?=\d)', '', s)
    # «120 x 240» и «120x240» — одно и то же, знак умножения не часть числа.
    s = re.sub(r'(?<=\d)\s*[xх×]\s*(?=\d)', ';', s)
    return {re.sub(r'[, ]', '', m.group()) for m in NUMBER.finditer(s)}

# По-русски число часто пишут словом — «season 1» -> «первого сезона», «1 chance» ->
# «один шанс». Это не потеря числа, поэтому слово засчитываем наравне с цифрой.
# Храним основы, а не полные формы: падежей и родов слишком много, основа однозначна.
WORD_NUM = {
    'один': '1', 'одна': '1', 'одно': '1', 'одну': '1', 'единствен': '1', 'перв': '1', 'раз-': '1', 'однажды': '1',
    'два': '2', 'две': '2', 'двух': '2', 'двум': '2', 'втор': '2', 'дважды': '2', 'оба': '2', 'обе': '2',
    'три': '3', 'трёх': '3', 'трех': '3', 'трём': '3', 'трет': '3', 'трижды': '3',
    'четыре': '4', 'четырёх': '4', 'четырех': '4', 'четверт': '4', 'четвёрт': '4', 'четырьмя': '4',
    'пять': '5', 'пяти': '5', 'пят': '5',
    'шесть': '6', 'шести': '6', 'шест': '6',
    'семь': '7', 'семи': '7', 'седьм': '7',
    'восемь': '8', 'восьми': '8', 'восьм': '8',
    'девять': '9', 'девяти': '9', 'девят': '9',
    'десять': '10', 'десяти': '10', 'десят': '10',
    'двадцат': '20', 'тридцат': '30', 'сорок': '40', 'пятьдесят': '50',
    'сто': '100', 'ста': '100', 'сот': '100', 'двест': '200', 'трист': '300',
    'тысяч': '1000', 'сотн': '100', 'полов': '2', 'дюжин': '12',
    'шестёр': '6', 'шестер': '6', 'семёр': '7', 'семер': '7', 'восьмёр': '8',
    'девятк': '9', 'десятк': '10', 'сороков': '40', 'пятидесят': '50',
}
WORD_NUM_RE = re.compile('|'.join(sorted(WORD_NUM, key=len, reverse=True)), re.I)

# Разряды по-русски отбивают пробелом («100 000»), по-английски запятой
# («100,000»). Пробел разрешаем только на стороне перевода: в оригинале
# «1 500-Point Essence» — это 1 и 500, а вовсе не 1500.
NUMBER_RU = re.compile(_NB + r'\d{1,3}(?:[,  ]\d{3})+(?![A-Za-z0-9])|'
                       + _NB + r'\d+(?![A-Za-z0-9])')

def numbers_ru(s):
    """Числа в переводе: цифрами (в том числе с пробелом в разрядах) и словом."""
    s = re.sub(r'%\w+%|<[^>]+>|\[pl:"[^"]*"\]', ' ', s)
    s = re.sub(r'(?<=\d):(?=\d)', '', s)
    s = re.sub(r'(?<=\d)\s*[xх×]\s*(?=\d)', ';', s)
    # Строгое (английское) прочтение тоже засчитываем: иначе на одинаковых
    # строках «76 554,326» стороны разошлись бы сами с собой.
    out = numbers(s)
    for m in NUMBER_RU.finditer(s):
        # «100 000» — это сто тысяч, а «31 254 13 56» — четыре числа подряд.
        # Отличить по виду нельзя, поэтому засчитываем оба прочтения: настоящую
        # подмену не спасёт ни одно из них, а ложную тревогу снимут оба.
        out.add(re.sub(r'[,  ]', '', m.group()))
        out |= set(re.findall(r'\d+', m.group()))
    return out | {WORD_NUM[m.group().lower()] for m in WORD_NUM_RE.finditer(s)}

LOWER_WORDS = set()          # заполняется в validate_paths, если корпус достаточно большой
TC_MIN_N, TC_MIN_SHARE, TC_MIN_ROWS = 12, 0.93, 20000

# --- Русская типографика (свод правил, README → «Русская типографика») -------
# Всё, что ловится ниже, портит вид текста, а не ломает строку в игре, поэтому
# идёт предупреждениями: гейт релиза на них не встаёт, но в --warnings видно.

# Буква ё. Машина не решит за переводчика «все» / «всё» — для этого нужен смысл.
# Зато она видит слово, у которого написания через «е» просто не существует.
# Поэтому в списке только однозначные формы: «ещё», «придёт», «чёрный». Слова с
# парой («сестра» — «сёстры», «мечет» — «мечёт», «слезы» — «слёзы», «звезды» —
# «звёзды») сюда не берутся вовсе: на них правило дало бы ложную тревогу.
# Продуктивные хвосты (-йдёт, -шёл, -ьёт) стоят вместо перечисления приставок.
# Кроме «вы-»: эта приставка перетягивает ударение на себя, и «вышел» пишется через «е».
YO = re.compile(r'''(?<![а-яё])(?:
    еще|ее|нее
   |\w*(?<!вы)йдет(?:е|ся|сь)?|\w*(?<!вы)йдем|\w*(?<!вы)йдешь|\w*(?<!вы)шел|\w*ьет(?:е|ся)?
   |придет(?:е|ся)?|придем|придешь
   |ведет|ведем|несет|несем|живет|живем|дает|дается|даете|везет|встает|поет
   |счет|счетчик\w*|отчет\w*|зачет\w*|расчет\w*|учет\w*|подсчет\w*|почет\w*
   |полет(?:а|е|ом|ы|ов|ам|ами|ах)?|вперед
   |объем(?:а|е|ом|ы|ов|ам|ами|ах)?|объемн\w*
   |прием(?:а|е|ом|ы|ов|ам|ами|ах)?|приемник\w*
   |подъем(?:а|е|ом|ы|ов|ам|ами|ах)?|подъемн\w*
   |черн(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую|о)
   |желт(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую|о)
   |зелен(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую)
   |темн(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую)
   |тепл(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую)
   |легк(?:ий|ая|ое|ие|ого|ому|им|ом|их|ими|ой|ую|ость\w*)
   |тяжел(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую)
   |мертв(?:ый|ая|ое|ые|ого|ому|ым|ом|ых|ыми|ой|ую)
   |серьезн\w*|надежн\w*|никчемн\w*|четк\w*|звездн\w*
   |щелк(?:ните|нуть|нув|ает|аете|ают|ая|ай|айте|нул\w*)
   |сестер|острие|копье|копьем|ружье|ружьем|ежик\w*
   |елк(?:а|и|у|ой|ам|ами|ах)|берез(?:а|ы|е|у|ой|ки|кой)
)(?![а-яё])''', re.I | re.X)

# Сочетания знаков конца фразы. В русском их набор закрытый; всё остальное —
# либо калька с английского («!?», «?!?»), либо эмоции набором («!!!???»).
# «…» приводим к трём точкам: это тот же знак, набранный одним символом.
PUNCT_RUN = re.compile(r'[.!?…]{2,}')
PUNCT_OK = {'?!', '?!!', '!!', '!!!', '?..', '!..', '?!.', '...'}
PUNCT_HINT = {'!?': '?!', '...?': '?..', '...!': '!..', '..': '...', '....': '...',
              '......': '...', '!...': '!..', '?...': '?..', '??': '?', '???': '?',
              '????': '?', '?!?': '?!', '!.': '!..', '.!': '!'}
# Диапазон в служебной строке («x/[3..7]») — не многоточие.
PUNCT_RANGE = re.compile(r'\d\.\.\d')
# Точка сокращения — не начало прогона: «F.O.O.L.!» законно.
ABBREV = re.compile(r'\w\.\w+$')
# Точка перед закрывающей кавычкой. Многоточие («…»») законно, поэтому вторую
# точку слева исключаем.
DOT_IN_QUOTE = re.compile(r'(?<![.!?…])\.[»”"]')
# «Ааа!» — английское написание звукоподражания. По-русски буквы разделяют
# дефисом: «А-а-а!». Трёх одинаковых букв подряд в русском слове не бывает.
ONOMAT = re.compile(r'([а-яё])\1{2,}', re.I)
# «Вы» с прописной — из деловой переписки, в игровом тексте её быть не должно.
# Ищем только в середине фразы (после строчной буквы или запятой), иначе поймали
# бы законное начало предложения. «Ваше Величество» — титул, там прописная своя:
# признак титула — следующее слово тоже с прописной.
CAP_VY = re.compile(r'(?<=[а-яё,]\s)(?:Вы|Вас|Вам|Вами|Ваш(?:а|е|и|его|ей|их|у|им|ем|ими)?)(?![а-яё])')
# Падежное окончание при цифре однобуквенное после гласной и двухбуквенное
# после согласной: 5-й, 5-я, 5-го — но не 5-ый, 5-ая, 5-ого.
ORD_BAD = re.compile(r'(\d+)-(ый|ой|ая|ое|ые|ых|ым|ом|ей|ого|его|ому|ему|ыми|ими|ти|ух)(?![а-яё])')
ORD_FIX = {'ый': 'й', 'ой': 'й', 'ая': 'я', 'ое': 'е', 'ые': 'е', 'ых': 'х', 'ым': 'м',
           'ом': 'м', 'ей': 'й', 'ого': 'го', 'его': 'го', 'ому': 'му', 'ему': 'му',
           'ыми': 'ми', 'ими': 'ми', 'ти': '', 'ух': 'х'}
# Стандарты интерфейса: слова, которых в русском либо нет, либо они заняты.
UI_BAD = [
    (re.compile(r'\bклик\w*', re.I), 'щёлкните / нажмите'),
    (re.compile(r'\bюнит\w*', re.I), 'боевая единица / объект'),
    (re.compile(r'\bхит(?:ы|ов|ами|ах)(?![а-яё])', re.I), 'единицы здоровья'),
    (re.compile(r'\b(?:лев|прав)[а-яё]{2,4}\s+щелч\w+', re.I), 'щелчок левой/правой кнопкой'),
]
# Термины, у которых есть принятый перевод; ругаемся только когда оригинал
# действительно про них, иначе «опция» в реплике NPC ловилась бы зря.
UI_TERMS = [(re.compile(r'\boptions?\b', re.I), re.compile(r'\bопци\w+', re.I), 'Настройки'),
            (re.compile(r'\bcontrols?\b', re.I), re.compile(r'назначени\w+ клавиш', re.I), 'Управление')]
# Меню выбора языка: строку видит тот, кто НЕ читает текущий язык интерфейса,
# и по ней он возвращается к своему. Переводить нельзя — это правило шире игр.
LANG_MENU = {'english', 'deutsch', 'français', 'francais', 'español', 'espanol',
             'italiano', 'polski', 'русский', '한국어', '中文', '日本語'}
# «Бог» в устойчивых оборотах разговорной речи — со строчной. Прописная остаётся
# только там, где это обращение к Богу, а не междометие.
GOD_LOWER = re.compile(r'(?:не дай|ради|убей меня|дай)\s+Бог|Бог\s+(?:его|весть|знает)'
                       r'|[Ее]й-Богу|Боже мой|Господи боже мой|Бог ты мой')

def typography(en, ru):
    """Предупреждения по русской типографике и стилю."""
    w = []
    m = YO.search(ru)
    if m:
        w.append(f"буква ё: «{m.group()}» написано через «е»")
    for m in PUNCT_RUN.finditer(ru):
        run = m.group().replace('…', '...')
        if run in PUNCT_OK or PUNCT_RANGE.search(ru[max(0, m.start() - 1):m.end() + 1]):
            continue
        if run[0] == '.' and ABBREV.search(ru[:m.start()]):   # «F.O.O.L.!»
            continue
        hint = PUNCT_HINT.get(run)
        w.append(f"недопустимое сочетание знаков «{run}»"
                 + (f", по-русски «{hint}»" if hint else ""))
        break
    if DOT_IN_QUOTE.search(ru):
        w.append("точка внутри кавычек — по-русски она ставится за кавычкой")
    # Рисунок кавычек: снаружи «ёлочки», внутри „лапки“. Прямые кавычки — крайний
    # случай; если в оригинале их нет, значит принесены переводом.
    if '"' in ru and ('«' in ru or '»' in ru):
        w.append("кавычки разного рисунка в одной строке — снаружи «…», внутри „…“")
    elif '"' in ru and '"' not in en:
        w.append("прямые кавычки в переводе — по-русски «…», внутри „…“")
    lost = ru.count('«') - ru.count('»')
    # Непарная кавычка — не всегда ошибка: реплика бывает длиннее записи, и в
    # оригинале кавычка открывается, а закрывается уже в следующей строке
    # словаря («"Not going down...without a fight.», «—Rinceword</c>"»).
    # Перевод обязан повторить эту структуру, поэтому ругаемся, только если
    # перекос НЕ такой, как в оригинале: там нечётное число прямых кавычек, а
    # здесь ровно одна лишняя «ёлочка».
    if lost and not (abs(lost) == 1 and en.count('"') % 2 == 1):
        w.append("кавычки не парные («…»)")
    elif re.search(r'«[^«»]*«|»[^«»]*»', ru):
        w.append("кавычки одного рисунка вложены — внутренние должны быть „…“")
    m = ONOMAT.search(ru)
    if m:
        w.append(f"повтор буквы «{m.group()}» — по-русски через дефис («А-а-а»)")
    for m in CAP_VY.finditer(ru):
        if not re.match(r'\s*[А-ЯЁ]', ru[m.end():]):   # «Ваше Величество» — титул
            w.append(f"«{m.group()}» с прописной — в игровом тексте только со строчной")
            break
    m = ORD_BAD.search(ru)
    if m:
        w.append(f"падежное окончание: «{m.group()}» → «{m.group(1)}"
                 + (f"-{ORD_FIX[m.group(2)]}»" if ORD_FIX[m.group(2)] else "»"))
    for bad, good in UI_BAD:
        m = bad.search(ru)
        if m:
            w.append(f"«{m.group()}» — стандарт интерфейса: {good}")
            break
    for en_re, ru_re, good in UI_TERMS:
        if en_re.search(en) and ru_re.search(ru):
            w.append(f"стандарт интерфейса: «{good}»")
            break
    if en.strip().lower() in LANG_MENU and ru.strip() != en.strip():
        w.append("название языка из меню выбора языка не переводится")
    for m in GOD_LOWER.finditer(ru):
        # В начале предложения прописная не «прописная в обороте», а орфография:
        # «Боже мой!» первым словом реплики иначе не пишется. Правило про строчную
        # относится к обороту внутри фразы.
        head = ru[:m.start()].rstrip()
        if not head or head[-1] in '.!?…»"' or head.endswith('<br>'):
            continue
        w.append(f"«{m.group()}» — в устойчивом обороте со строчной буквы")
        break
    return w

def check_row(en, ru):
    errs, warns = [], []
    # Кириллица в колонке english — не строка на перевод, а след разъехавшегося
    # CSV: колонки склеились («EN,RU» целиком в первой ячейке) либо запись без
    # кавычек перечитали и разрубили по запятой. Хеш считается от такого огрызка,
    # и в игре запись мертва — совпасть ей не с чем. Остальные правила по ней
    # дают только шум, поэтому дальше не идём.
    m = CYR.search(en)
    if m:
        i = m.start()
        return ["в колонке english кириллица — колонки разъехались: «%s»"
                % en[max(0, i - 20):i + 20]], warns
    if tokens(en) != tokens(ru):
        errs.append("плейсхолдеры/теги не совпадают с оригиналом")
    if LEFTOVER.search(ru):
        errs.append(f"в переводе остался маркер оригинала «{LEFTOVER.search(ru).group()}…»")
    rs = strip_known(ru)
    if rs.count('[') != rs.count(']'):
        errs.append("несбалансированные скобки [ ]")
    else:
        groups = [(m.group(1), m.group(2)) for m in GROUP_STEM.finditer(rs)]
        # Три формы нужны именно там, где оригинал склоняет по числу: 1 / 2-4 / 5+.
        # Две формы — только для рода ([|а] в «готов[|а]»), там [s] в оригинале нет.
        plural_src = bool(PLURAL_EN.search(en))
        for stem, grp in groups:
            if '|' in grp:
                forms = grp[1:-1].split('|')
                # Движок берёт из группы ровно три формы. Четвёртая — след машинного
                # батча, в игру уедет мусором («паук[|а|и|и]»).
                if len(forms) > 3:
                    n = "формы" if len(forms) == 4 else "форм"
                    errs.append(f"в группе {len(forms)} {n}, движок берёт три (1 / 2-4 / 5+): {grp}")
                elif plural_src and len(forms) == 2 and not GENDER_SRC.search(en):
                    errs.append(f"в группе две формы, для числа нужно три (1 / 2-4 / 5+): {grp}")
                errs += empty_forms(stem, grp, forms, warns)
                # Форма, повторённая во всех позициях, — группа впустую («[Мини|Мини]»).
                if len(set(forms)) == 1:
                    warns.append(f"все формы в группе одинаковые: {grp}")
                # Группа форм там, где склонять не по чему: в оригинале нет ни
                # [s]/[pl:…], ни числа рядом. Машина размечала имя предмета
                # («[Сундук|Сундука|Сундуков] Амнитаса») — выбирать форму движку
                # нечем. Две формы не трогаем: это род («сломал[ся|ась]»).
                elif not plural_src and len(forms) >= 3 and not NUM_PH.search(en):
                    warns.append(f"группа форм, а в оригинале ни [s]/[pl:…], ни числа: {grp}")
            elif plural_src:
                # «Ящик[и]» уедет в игру вместе со скобками — это не «подозрительно», это брак.
                errs.append(f"группа без | при [s]/[pl:…] в оригинале — нужны три формы: {grp}")
            elif BRACKET_SRC.search(strip_known(en)):
                # Скобка с текстом внутри — не группа форм, а пояснение игры
                # («…убежище. [Living World, 1-й сезон…]»), и перевод обязан её
                # сохранить. Ругаться на неё — то же самое, что ругаться на
                # непарную кавычку, стоящую так же в оригинале.
                pass
            else:
                warns.append(f"скобка без | : {grp}")
        # Обе проверки выше смотрят на уже существующую группу, поэтому перевод
        # совсем без скобок проходил мимо: «Осмотрите %num1%/%num2% виды» уедет в
        # игру одной формой на все числа. Ругаемся только когда число печатается
        # рядом (%num%) — у имени предмета без счёта («Emblem[s] of Victory»)
        # единственное число законно, и таких в корпусе большинство.
        # Счётчик — не брак: если переводчик перестроил фразу и число уехало в
        # конец («Уничтожено караванов: %num1%»), русская форма от числа больше
        # не зависит — «караванов: 1» и «караванов: 5» одинаково верны, склонять
        # нечего. Отличаем по тому, что после последнего числа русских букв нет.
        if (plural_src and NUM_PH.search(en)
                and not any('|' in g for _, g in groups)
                and not NUM_TAIL.search(ru.strip())):
            warns.append("потеряна плюрал-разметка: в оригинале [s]/[pl:…] и %num%, "
                         "в переводе форм нет")
    if PREFIX_EN.match(en) and ':' not in ru:
        errs.append(f"потерян префикс «{PREFIX_EN.match(en).group().strip()}» — в переводе нет двоеточия")
    # «Лавровый лист[лист|листа|листов]» — движок склеит в «Лавровый листлист».
    # Формы задают либо окончанием («Ящик[|а|ов]»), либо словом целиком
    # («[Ящик|Ящика|Ящиков]»); машина смешала режимы и оставила слово снаружи.
    for m in DUP_WORD.finditer(rs):
        w, forms = m.group(1), m.group(2).split('|')
        if any(w[:4].lower() in f.lower() for f in forms):
            errs.append(f"слово «{w}» продублировано внутри группы: {m.group()[:40]}")
            break
    gm = GENDER_MARK.match(en)
    if gm and not ru.startswith(f'[{gm.group(1)}]'):
        errs.append(f"потерян родовой маркер [{gm.group(1)}] в начале строки")
    for en_re, canon, bans, canon_re in GLOSSARY_BANS:
        if not en_re.search(en):
            continue
        # Запрет привязан к оригиналу, но иногда в строке стоят оба существа сразу:
        # «Ride a skyscale or griffon…». Тогда «грифон» в переводе — не подмена
        # скайскейла, а честный перевод соседнего слова.
        if canon in GLOSS_ALSO_OK and re.search(GLOSS_ALSO_OK[canon], en, re.I):
            continue
        if canon in GLOSS_SKIP_EN and re.search(GLOSS_SKIP_EN[canon], en, re.I):
            continue
        # Места, занятые каноном: попадание запрета внутрь них не в счёт.
        ok = [m.span() for m in canon_re.finditer(ru)]
        for bad, bad_re in bans:
            if any(not any(a <= m.start() and m.end() <= z for a, z in ok)
                   for m in bad_re.finditer(ru)):
                errs.append(f"форма «{bad}» запрещена глоссарием, канон — «{canon}»")
    if STRESS_ANY.search(STRESS_OK.sub('', ru)):
        errs.append("знак ударения не на гласной (мусор от набора)")
    hg = homoglyph(ru)
    if hg:
        errs.append(f"латинская буква внутри русского слова: «{hg}»")
    if TY.search(ru) and VY.search(ru):
        warns.append("«ты» и «вы» в одной строке")
    if en.rstrip()[-1:] in '.!?' and ru.rstrip()[-1:] not in '.!?…»"\')%]>':
        warns.append("оригинал кончается точкой/!/?, перевод — нет")
    if re.search(r'\s[,.;:!?](?=\s|$)', ru):
        warns.append("пробел перед знаком препинания")
    warns += typography(en, ru)
    # Процент в оригинале всегда экранирован как %%. Одиночный % в переводе движок
    # разберёт как начало спецификатора формата и съест соседний текст.
    if en.count('%%') != ru.count('%%'):
        errs.append(f"число %% не совпадает ({en.count('%%')} / {ru.count('%%')})")
    if LOWER_WORDS:
        tc = [w for w in title_case_suspects(ru) if w.lower() in LOWER_WORDS]
        if tc:
            warns.append(f"английский Title Case в русском: {' '.join(tc[:3])}")
    en_num = numbers(en)
    if en_num:
        ru_num = numbers_ru(ru)
        lost = en_num - ru_num
        if lost:
            extra = numbers(ru) - en_num
            # Подменой считаем только когда списки чисел выровнены — их поровну.
            # В длинном тексте с россыпью чисел «потерялось одно, зато есть другие»
            # ещё не значит, что одно подменили другим.
            if extra and len(NUMBER.findall(en)) == len(NUMBER_RU.findall(ru)):
                errs.append(f"число подменено: в оригинале {'/'.join(sorted(lost))}, "
                            f"в переводе {'/'.join(sorted(extra))}")
            else:
                # Потеря — не всегда брак: число пишут словом («шесть миллионов»),
                # римскими («XI веке»), или оно идиома («Golemancy 101» -> «для
                # начинающих»). Поэтому предупреждение: видно всё, гейт не встаёт.
                # Подмена выше — другое дело, там перевод просто врёт.
                warns.append(f"число оригинала потеряно: {'/'.join(sorted(lost))}")
    if '�' in ru:
        errs.append("символ U+FFFD (битая кодировка)")
    # --- служебные символы: перенос строки, края, невидимки, маркеры ---------
    # Перенос строки — часть вёрстки, а не оформления: игра рисует строку так,
    # как её разбил оригинал. Потерянный перенос склеивает фразы («…площадке.
    # Примечание:» без пробела), и это видно игроку.
    nl_en, nl_ru = en.count('\n'), ru.count('\n')
    if nl_en > nl_ru:
        if len(NOSPACE.sub('', ru)) < 0.55 * len(NOSPACE.sub('', en)):
            errs.append(f"потерян перенос строки и, похоже, целый сегмент "
                        f"({nl_en} -> {nl_ru}); перевод вдвое короче оригинала")
        else:
            errs.append(f"потерян перенос строки ({nl_en} -> {nl_ru})")
    elif nl_ru > nl_en:
        warns.append(f"лишний перенос строки ({nl_en} -> {nl_ru})")
    # Подпись письма стоит отдельной строкой после пустой; теряют её вместе с
    # переносами, а пропажу видно только по оригиналу.
    sig = SIGNATURE.search(en)
    if sig:
        # Хвоста в 45 знаков хватает не всегда: «—Полевой справочник Приората
        # Дурманд по скриттам</c>» длиннее, и тире в окно не попадает. Подпись
        # стоит отдельной строкой, поэтому надёжнее смотреть её начало.
        tail = [ln for ln in ru.strip().split('\n') if ln.strip()]
        last = tail[-1] if tail else ''
        if not re.match(r'\s*[—–]', last) and not re.search(r'[—–]\s*\S', ru.strip()[-45:]):
            errs.append(f"потеряна подпись «{sig.group(1).strip()[:30]}»")
    # Краевой пробел оригинала — часть склейки («Рецепт: » + название). Лишний
    # краевой пробел — тоже брак: строка склеится с двойным.
    if en.strip(EDGE_WS)[:1] and (en[:len(en) - len(en.lstrip(EDGE_WS))]
                                  != ru[:len(ru) - len(ru.lstrip(EDGE_WS))]):
        errs.append("краевые пробелы в начале не совпадают с оригиналом")
    if en[len(en.rstrip(EDGE_WS)):] != ru[len(ru.rstrip(EDGE_WS)):]:
        errs.append("краевые пробелы в конце не совпадают с оригиналом")
    # Невидимки: в оригинале их нет, а в переводе есть — принесены копипастой
    # из вики и документов. Ломают поиск по строке и подстановку имён.
    for ch in ZW_CHARS:
        if ru.count(ch) > en.count(ch):
            errs.append(f"невидимый символ U+{ord(ch):04X}, которого нет в оригинале")
            break
    else:
        if ZW.search(ru):
            warns.append("zero-width символ")
    for ch in ' ⁠ ':
        if en.count(ch) > ru.count(ch):
            warns.append(f"потерян неразрывный символ U+{ord(ch):04X}")
            break
    if en.count('•') > ru.count('•'):
        warns.append("потерян маркер списка •")
    if ru.strip() == en.strip() and not CYR.search(en) and re.search(r'[.!?]', en) and len(en) >= 15:
        warns.append("перевод == оригиналу (возможно, не переведено)")
    lost = layer_name_lost(en, ru)
    if lost:
        msg = ("название из слоя пропало из перевода — оставь латиницей, слой "
               "подставит русскую форму сам: " + ", ".join(sorted(set(lost))[:3]))
        (errs if NAME_LOST_IS_ERROR else warns).append(msg)
    srv = server_check(en)
    if srv:
        warns.append(srv)
    elif SERVER_STRINGS and not SERVER_NUM.search(en):
        near = server_near(en)
        if near:
            warns.append(near)
    return errs, warns

# Каталоги, которые батчами не являются: sync/ — кеш выгрузок API и отчёты
# (в .gitignore целиком), .batch_bak/ и .dict_bak/ — локальные бэкапы. Источник
# истины — батчи, а в кеше лежит вторая копия тех же строк: линтер ругался на неё
# отдельно и удваивал каждый класс. Явно переданный путь внутрь этих папок
# по-прежнему проверяется — исключение только для обхода каталога.
NOT_SOURCE = ('sync', '.batch_bak', '.dict_bak', '__pycache__')

def iter_csv(paths):
    files = []
    for p in paths:
        if os.path.isdir(p):
            for fp in glob.glob(os.path.join(p, '**', '*.csv'), recursive=True):
                parts = os.path.relpath(fp, p).split(os.sep)
                if not any(part in NOT_SOURCE for part in parts[:-1]):
                    files.append(fp)
        elif p.endswith('.csv'):
            files.append(p)
    return sorted(set(files))

def read_batch(fp):
    """Строки батча или None, если это не батч (у служебных таблиц другие колонки)."""
    rows = list(csv.reader(open(fp, encoding='utf-8-sig', newline='')))
    if not rows or not rows[0] or rows[0][0].strip().lower() != 'english':
        return None
    return rows

def build_case_model(files):
    """Как корпус пишет слово в середине фразы: строчным или с заглавной."""
    stat, rows_seen = {}, 0
    for fp in files:
        try:
            rows = read_batch(fp)
        except Exception:
            continue
        if not rows:
            continue
        for r in rows[1:]:
            if len(r) < 2 or not r[1].strip():
                continue
            rows_seen += 1
            for w in MID_WORD.findall(r[1]):
                s = stat.setdefault(w.lower(), [0, 0])
                s[0 if w[0].islower() else 1] += 1
    if rows_seen < TC_MIN_ROWS:      # на одном файле модель недостоверна — проверку не включаем
        return set()
    return {w for w, (lo, up) in stat.items()
            if lo + up >= TC_MIN_N and lo / (lo + up) >= TC_MIN_SHARE}

def validate_paths(paths):
    """Возвращает (rows_checked, [(file,line,en,msg)] ошибок, [...] предупреждений)."""
    errors, warnings, checked = [], [], 0
    global LOWER_WORDS
    LOWER_WORDS = build_case_model(iter_csv(paths))
    for fp in iter_csv(paths):
        try:
            rows = list(csv.reader(open(fp, encoding='utf-8-sig', newline='')))
        except Exception as e:
            errors.append((fp, 0, '', f"не читается: {e}")); continue
        # Батч — это CSV с заголовком «english,translate». Служебные таблицы
        # (отчёты синка, sync/reports/*.csv) пропускаем: у них другие колонки.
        if not rows or not rows[0] or rows[0][0].strip().lower() != 'english':
            continue
        for i, r in enumerate(rows[1:], start=2):  # line number in file
            if len(r) < 2 or not r[1].strip():
                continue
            checked += 1
            e, w = check_row(r[0], r[1])
            rel = os.path.relpath(fp)
            d = layer_duplicate(fp, r[0], r[1])
            if d:
                e = e + [d]
            for m in e: errors.append((rel, i, r[0][:60], m))
            for m in w: warnings.append((rel, i, r[0][:60], m))
    return checked, errors, warnings

def main():
    global NAME_LOST_IS_ERROR
    args = [a for a in sys.argv[1:] if not a.startswith('-')]
    show_warn = '--warnings' in sys.argv
    if '--warn-names' in sys.argv:
        # Пропавшее название из слоя — предупреждением, а не ошибкой. Нужно,
        # пока класс не расчищен: иначе гейт валит 934 файла из 996.
        NAME_LOST_IS_ERROR = False
    here = os.path.dirname(os.path.abspath(__file__))
    paths = args or [here]
    checked, errors, warnings = validate_paths(paths)
    print(f"Проверено переведённых строк: {checked:,} | ошибок: {len(errors)} | предупреждений: {len(warnings)}")
    for f, ln, en, m in errors[:200]:
        print(f"  ОШИБКА  {f}:{ln}  «{en}» — {m}")
    if len(errors) > 200:
        print(f"  … и ещё {len(errors)-200} ошибок")
    if show_warn:
        for f, ln, en, m in warnings[:200]:
            print(f"  warn    {f}:{ln}  «{en}» — {m}")
        if len(warnings) > 200:
            print(f"  … и ещё {len(warnings)-200} предупреждений")
    sys.exit(1 if errors else 0)

if __name__ == '__main__':
    main()