From e1d7b29f77a7308c844fa988669c95c6decc5648 Mon Sep 17 00:00:00 2001
From: mrleo1nid <43583385+mrleo1nid@users.noreply.github.com>
Date: Sun, 25 Oct 2026 03:39:40 +0300
Subject: [PATCH] Localization stage 1: stable IDs, import of tl/ translations,
 language picker

- every script node gets a permanent id, say nodes a Ren'Py-style tid
- all languages from the game's tl/ are imported at conversion: dialogue blocks
  matched by their source-location comment or by label + original text,
  `translate strings` become a per-language strings table
- source language from config.language or detected from the dialogue
- manifest stores locales/<lang>/<module>.json and strings.json; game.json
  lists sourceLang and available locales with progress
- player: language picker in main menu and settings, fallback to source,
  __(), [var!t] and _preferences.language
- parser: `default` with init priority, and one bad statement no longer drops
  the whole file
- docs/LOCALIZATION.md: design for translations, publishing and mods

Line endings of several converter/player files go back to LF: an earlier
commit accidentally stored them as CRLF.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 backend/app/converter/analyze.py              |  299 +-
 backend/app/converter/locales.py              |  280 ++
 backend/app/converter/pipeline.py             |  638 ++--
 backend/app/converter/rpy_parser.py           | 2455 +++++++--------
 .../fixtures/sample/tl/english/script.rpy     |   28 +
 backend/tests/make_sample.py                  |    2 +
 backend/tests/test_converter.py               |   13 +-
 docs/ARCHITECTURE.md                          |    5 +-
 docs/LOCALIZATION.md                          |  182 ++
 frontend/src/player/engine.ts                 | 2769 +++++++++--------
 frontend/src/player/i18n.ts                   |   94 +
 frontend/src/player/index.ts                  |   10 +-
 frontend/src/player/player.css                |   11 +
 frontend/src/player/renderer.ts               |  732 ++---
 frontend/src/player/text.ts                   |    4 +-
 frontend/src/player/types.ts                  |  288 +-
 16 files changed, 4280 insertions(+), 3530 deletions(-)
 create mode 100644 backend/app/converter/locales.py
 create mode 100644 backend/tests/fixtures/sample/tl/english/script.rpy
 create mode 100644 docs/LOCALIZATION.md
 create mode 100644 frontend/src/player/i18n.ts

diff --git a/backend/app/converter/analyze.py b/backend/app/converter/analyze.py
index 53d476d..c940dac 100644
--- a/backend/app/converter/analyze.py
+++ b/backend/app/converter/analyze.py
@@ -1,144 +1,155 @@
-"""Dry run of the script part of the converter on unpacked games (no media work).
-
-    python -m app.converter.analyze /games/Some-Game [/games/Other ...]
-
-Prints, per game, how much of the script was understood and the top warnings.
-"""
-
-import json
-import re
-import shutil
-import sys
-import tempfile
-import time
-from collections import Counter
-from pathlib import Path
-
-from app.converter import assets
-from app.converter.archive import ArchiveError, find_game_dir
-from app.converter.pipeline import _auto_images, _is_engine_file, _resolve_image, anchors
-from app.converter.rpa import RpaError, extract_rpa, read_index
-from app.converter.rpy_lexer import ParseError
-from app.converter.rpy_parser import RpyParser, ScriptData
-from app.converter.rpyc import decompile_missing
-
-SCRIPT_EXTS = (".rpy", ".rpyc", ".rpym", ".rpymc")
-
-
-def renpy_version(root: Path) -> str:
-    for vc in root.rglob("renpy/vc_version.py"):
-        m = re.search(r"version\s*=\s*u?['\"]([^'\"]+)", vc.read_text(errors="replace"))
-        if m:
-            return m.group(1)
-    for init in root.rglob("renpy/__init__.py"):
-        m = re.search(r"version_tuple\s*=\s*\(([^)]*)\)", init.read_text(errors="replace"))
-        if m:
-            return ".".join(x.strip() for x in m.group(1).split(",")[:3])
-    return "?"
-
-
-def analyze(src: Path, dump: Path | None = None) -> dict:
-    started = time.monotonic()
-    game_dir = find_game_dir(src)
-    data = ScriptData()
-    work = Path(tempfile.mkdtemp(prefix="analyze-"))
-    try:
-        files: dict[str, str] = {}  # lowercase path -> path, for asset resolution
-        for p in game_dir.rglob("*"):
-            if p.is_file():
-                rel = p.relative_to(game_dir).as_posix()
-                if p.suffix.lower() in SCRIPT_EXTS:
-                    dest = work / rel
-                    dest.parent.mkdir(parents=True, exist_ok=True)
-                    shutil.copyfile(p, dest)
-                elif p.suffix.lower() != ".rpa":
-                    files[rel.lower()] = rel
-        rpa_errors = []
-        for rpa in game_dir.rglob("*.rpa"):
-            try:
-                for name in read_index(rpa):
-                    if not name.lower().endswith(SCRIPT_EXTS):
-                        files[name.lower()] = name
-                extract_rpa(rpa, work, only=lambda n: n.lower().endswith(SCRIPT_EXTS))
-            except RpaError as e:
-                rpa_errors.append(str(e))
-        decompiled = decompile_missing(work, data.warn)
-        if dump is not None:
-            shutil.copytree(work, dump / src.name, dirs_exist_ok=True,
-                            ignore=shutil.ignore_patterns("*.rpyc", "*.rpymc"))
-        rpy = sorted((p for p in work.rglob("*.rpy") if not _is_engine_file(work, p)),
-                     key=lambda p: p.relative_to(work).as_posix().lower())
-        lines = 0
-        for p in rpy:
-            rel = p.relative_to(work).as_posix()
-            text = p.read_text(encoding="utf-8", errors="replace")
-            lines += text.count("\n")
-            try:
-                RpyParser(data, rel).parse(text)
-            except ParseError as e:
-                data.warn(f"Ошибка разбора файла: {e.msg}", f"{e.filename}:{e.lineno}")
-            except RecursionError:
-                data.warn("Слишком глубокая вложенность", rel)
-
-        # media aliases as the real pipeline would produce them
-        aliases = {k: str(Path(v).with_suffix(assets.target_ext(Path(v))).as_posix())
-                   for k, v in files.items() if assets.kind_of(Path(v))}
-        _auto_images(data, aliases)
-        missing: set[str] = set()
-        for img in data.images.values():
-            _resolve_image(img, aliases, missing)
-        labels = {lbl["name"] for mod in data.modules.values() for lbl in mod}
-        labels |= {name for mod in data.modules.values() for name in anchors(mod)}
-        targets = Counter()
-        _collect_targets(data.modules, targets)
-        media = Counter(assets.kind_of(Path(v)) for v in files.values() if assets.kind_of(Path(v)))
-        return {
-            "game": src.name,
-            "renpy": renpy_version(src),
-            "seconds": round(time.monotonic() - started, 1),
-            "rpyFiles": len(rpy),
-            "decompiled": decompiled,
-            "lines": lines,
-            "labels": len(labels),
-            "hasStart": "start" in labels,
-            "stats": dict(data.stats),
-            "media": dict(media),
-            "images": len(data.images),
-            "characters": len(data.characters),
-            "missingJumpTargets": sorted(t for t in targets if t not in labels)[:15],
-            "missingFiles": sorted(missing)[:15],
-            "rpaErrors": rpa_errors,
-            "warningsTotal": sum(data.warnings.values()),
-            "warnings": [{"n": n, "msg": m, "ex": data.warning_examples.get(m)}
-                         for m, n in data.warnings.most_common(25)],
-        }
-    finally:
-        shutil.rmtree(work, ignore_errors=True)
-
-
-def _collect_targets(modules, out: Counter) -> None:
-    def walk(nodes):
-        for n in nodes:
-            if n["op"] in ("jump", "call") and n.get("target"):
-                out[n["target"]] += 1
-            for b in n.get("branches", []):
-                walk(b["body"])
-            for it in n.get("items", []):
-                walk(it["body"])
-            walk(n.get("body", []))
-    for mod in modules.values():
-        for lbl in mod:
-            walk(lbl["body"])
-
-
-if __name__ == "__main__":
-    args = sys.argv[1:]
-    dump = None
-    if args[:1] == ["--dump"]:
-        dump, args = Path(args[1]), args[2:]
-    for arg in args:
-        try:
-            result = analyze(Path(arg), dump)
-        except (ArchiveError, OSError) as e:
-            result = {"game": Path(arg).name, "error": str(e)}
-        print(json.dumps(result, ensure_ascii=False), flush=True)
+"""Dry run of the script part of the converter on unpacked games (no media work).
+
+    python -m app.converter.analyze /games/Some-Game [/games/Other ...]
+
+Prints, per game, how much of the script was understood and the top warnings.
+"""
+
+import json
+import re
+import shutil
+import sys
+import tempfile
+import time
+from collections import Counter
+from pathlib import Path
+
+from app.converter import assets, locales
+from app.converter.archive import ArchiveError, find_game_dir
+from app.converter.pipeline import _auto_images, _is_engine_file, _resolve_image, anchors
+from app.converter.rpa import RpaError, extract_rpa, read_index
+from app.converter.rpy_lexer import ParseError
+from app.converter.rpy_parser import RpyParser, ScriptData
+from app.converter.rpyc import decompile_missing
+
+SCRIPT_EXTS = (".rpy", ".rpyc", ".rpym", ".rpymc")
+
+
+def renpy_version(root: Path) -> str:
+    for vc in root.rglob("renpy/vc_version.py"):
+        m = re.search(r"version\s*=\s*u?['\"]([^'\"]+)", vc.read_text(errors="replace"))
+        if m:
+            return m.group(1)
+    for init in root.rglob("renpy/__init__.py"):
+        m = re.search(r"version_tuple\s*=\s*\(([^)]*)\)", init.read_text(errors="replace"))
+        if m:
+            return ".".join(x.strip() for x in m.group(1).split(",")[:3])
+    return "?"
+
+
+def analyze(src: Path, dump: Path | None = None) -> dict:
+    started = time.monotonic()
+    game_dir = find_game_dir(src)
+    data = ScriptData()
+    work = Path(tempfile.mkdtemp(prefix="analyze-"))
+    try:
+        files: dict[str, str] = {}  # lowercase path -> path, for asset resolution
+        for p in game_dir.rglob("*"):
+            if p.is_file():
+                rel = p.relative_to(game_dir).as_posix()
+                if p.suffix.lower() in SCRIPT_EXTS:
+                    dest = work / rel
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copyfile(p, dest)
+                elif p.suffix.lower() != ".rpa":
+                    files[rel.lower()] = rel
+        rpa_errors = []
+        for rpa in game_dir.rglob("*.rpa"):
+            try:
+                for name in read_index(rpa):
+                    if not name.lower().endswith(SCRIPT_EXTS):
+                        files[name.lower()] = name
+                extract_rpa(rpa, work, only=lambda n: n.lower().endswith(SCRIPT_EXTS))
+            except RpaError as e:
+                rpa_errors.append(str(e))
+        decompiled = decompile_missing(work, data.warn)
+        if dump is not None:
+            shutil.copytree(work, dump / src.name, dirs_exist_ok=True,
+                            ignore=shutil.ignore_patterns("*.rpyc", "*.rpymc"))
+        rpy = sorted((p for p in work.rglob("*.rpy") if not _is_engine_file(work, p)),
+                     key=lambda p: p.relative_to(work).as_posix().lower())
+        lines = 0
+        for p in rpy:
+            rel = p.relative_to(work).as_posix()
+            text = p.read_text(encoding="utf-8", errors="replace")
+            lines += text.count("\n")
+            try:
+                RpyParser(data, rel).parse(text)
+            except ParseError as e:
+                data.warn(f"Ошибка разбора файла: {e.msg}", f"{e.filename}:{e.lineno}")
+            except RecursionError:
+                data.warn("Слишком глубокая вложенность", rel)
+
+        by_line = locales.assign_ids(data.modules)
+        translations = locales.import_tl(work, data.modules, by_line, data.warn)
+        says = len(by_line) or 1
+        language = data.config.get("language")
+        source_lang = (locales.lang_code(language) if isinstance(language, str)
+                       else locales.detect_language(data.modules))
+
+        # media aliases as the real pipeline would produce them
+        aliases = {k: str(Path(v).with_suffix(assets.target_ext(Path(v))).as_posix())
+                   for k, v in files.items() if assets.kind_of(Path(v))}
+        _auto_images(data, aliases)
+        missing: set[str] = set()
+        for img in data.images.values():
+            _resolve_image(img, aliases, missing)
+        labels = {lbl["name"] for mod in data.modules.values() for lbl in mod}
+        labels |= {name for mod in data.modules.values() for name in anchors(mod)}
+        targets = Counter()
+        _collect_targets(data.modules, targets)
+        media = Counter(assets.kind_of(Path(v)) for v in files.values() if assets.kind_of(Path(v)))
+        return {
+            "game": src.name,
+            "renpy": renpy_version(src),
+            "seconds": round(time.monotonic() - started, 1),
+            "rpyFiles": len(rpy),
+            "decompiled": decompiled,
+            "lines": lines,
+            "labels": len(labels),
+            "hasStart": "start" in labels,
+            "stats": dict(data.stats),
+            "media": dict(media),
+            "images": len(data.images),
+            "sourceLang": source_lang,
+            "locales": {code: {"lines": len(t.lines), "strings": len(t.strings),
+                               "progress": round(len(t.lines) / says, 3), "unmatched": t.unmatched}
+                        for code, t in translations.items()},
+            "characters": len(data.characters),
+            "missingJumpTargets": sorted(t for t in targets if t not in labels)[:15],
+            "missingFiles": sorted(missing)[:15],
+            "rpaErrors": rpa_errors,
+            "warningsTotal": sum(data.warnings.values()),
+            "warnings": [{"n": n, "msg": m, "ex": data.warning_examples.get(m)}
+                         for m, n in data.warnings.most_common(25)],
+        }
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+
+
+def _collect_targets(modules, out: Counter) -> None:
+    def walk(nodes):
+        for n in nodes:
+            if n["op"] in ("jump", "call") and n.get("target"):
+                out[n["target"]] += 1
+            for b in n.get("branches", []):
+                walk(b["body"])
+            for it in n.get("items", []):
+                walk(it["body"])
+            walk(n.get("body", []))
+    for mod in modules.values():
+        for lbl in mod:
+            walk(lbl["body"])
+
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    dump = None
+    if args[:1] == ["--dump"]:
+        dump, args = Path(args[1]), args[2:]
+    for arg in args:
+        try:
+            result = analyze(Path(arg), dump)
+        except (ArchiveError, OSError) as e:
+            result = {"game": Path(arg).name, "error": str(e)}
+        print(json.dumps(result, ensure_ascii=False), flush=True)
diff --git a/backend/app/converter/locales.py b/backend/app/converter/locales.py
new file mode 100644
index 0000000..cd8e085
--- /dev/null
+++ b/backend/app/converter/locales.py
@@ -0,0 +1,280 @@
+"""Stable IDs for script nodes and strings, and import of Ren'Py translations (tl/).
+
+* every statement node gets a permanent ``id``; say nodes also get a ``tid``
+  (translation id) — Ren'Py's own id when the game's tl/ files know it;
+* ``tl/<lang>/*.rpy`` is turned into per-language tables: dialogue lines keyed by
+  tid and a strings table (names, menu choices, ``_()``) keyed by source text.
+"""
+
+import hashlib
+import re
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from app.converter.rpy_lexer import Cursor, Line, ParseError, parse_tree
+
+# Ren'Py language names -> BCP-47
+RENPY_LANGS = {
+    "english": "en", "russian": "ru", "ukrainian": "uk", "belarusian": "be", "german": "de",
+    "french": "fr", "spanish": "es", "spanish_latam": "es-419", "latam": "es-419",
+    "portuguese": "pt", "brazilian": "pt-BR", "portuguese_br": "pt-BR", "italian": "it",
+    "polish": "pl", "czech": "cs", "slovak": "sk", "dutch": "nl", "norwegian": "no",
+    "swedish": "sv", "danish": "da", "finnish": "fi", "turkish": "tr", "greek": "el",
+    "hungarian": "hu", "romanian": "ro", "bulgarian": "bg", "serbian": "sr", "croatian": "hr",
+    "bosnian": "bs", "japanese": "ja", "korean": "ko", "chinese": "zh-Hans",
+    "schinese": "zh-Hans", "tchinese": "zh-Hant", "chinese_traditional": "zh-Hant",
+    "thai": "th", "vietnamese": "vi", "indonesian": "id", "malay": "ms", "filipino": "fil",
+    "tagalog": "fil", "arabic": "ar", "hebrew": "he", "persian": "fa", "hindi": "hi",
+    "hinglish": "hi-Latn",
+}
+LANG_NAMES = {
+    "en": "English", "ru": "Русский", "uk": "Українська", "de": "Deutsch", "fr": "Français",
+    "es": "Español", "es-419": "Español (Latinoamérica)", "pt": "Português",
+    "pt-BR": "Português (Brasil)", "it": "Italiano", "pl": "Polski", "cs": "Čeština",
+    "nl": "Nederlands", "no": "Norsk", "tr": "Türkçe", "ja": "日本語", "ko": "한국어",
+    "zh-Hans": "简体中文", "zh-Hant": "繁體中文", "th": "ไทย", "vi": "Tiếng Việt",
+    "id": "Bahasa Indonesia", "bs": "Bosanski", "hi-Latn": "Hinglish",
+}
+
+_STOPWORDS = {
+    "en": {"the", "you", "and", "is", "to", "it", "what", "i'm", "that", "of"},
+    "fr": {"le", "la", "les", "et", "est", "je", "tu", "vous", "pas", "une", "des", "c'est"},
+    "de": {"der", "die", "und", "ist", "ich", "du", "nicht", "das", "ein", "zu"},
+    "es": {"el", "la", "que", "y", "es", "no", "un", "los", "por", "qué"},
+    "pt": {"o", "a", "que", "não", "é", "um", "uma", "você", "eu", "de"},
+    "it": {"il", "che", "non", "è", "un", "di", "sono", "io", "per", "la"},
+}
+_TAGS = re.compile(r"\{[^{}]*\}|\[[^\[\]]*\]")
+_WORDS = re.compile(r"[^\W\d_]+(?:'[^\W\d_]+)?", re.UNICODE)
+_SRC_COMMENT = re.compile(r"#\s*(?:game/)?(.+?\.rpym?):(\d+)\s*$")
+_TRANSLATE = re.compile(r"^translate\s+(\w+)\s+([\w.]+)\s*:\s*$")
+
+
+def lang_code(renpy_name: str) -> str:
+    return RENPY_LANGS.get(renpy_name.lower(), renpy_name.lower())
+
+
+def short_hash(text: str) -> str:
+    return hashlib.md5(text.encode("utf-8")).hexdigest()[:8]
+
+
+@dataclass
+class LocaleData:
+    renpy: str
+    lines: dict[str, str] = field(default_factory=dict)     # tid -> text
+    strings: dict[str, str] = field(default_factory=dict)   # source text -> text
+    unmatched: int = 0
+
+
+def walk(nodes: list[dict[str, Any]]):
+    """All statement nodes in a body, depth first, including menu captions."""
+    for n in nodes:
+        yield n
+        if n.get("op") == "menu" and n.get("say"):
+            yield n["say"]
+        for b in n.get("branches", []):
+            yield from walk(b["body"])
+        for it in n.get("items", []):
+            yield from walk(it["body"])
+        if n.get("op") == "while":
+            yield from walk(n["body"])
+
+
+def assign_ids(modules: dict[str, list[dict[str, Any]]]) -> dict[tuple[str, int], dict]:
+    """Give every node an ``id`` and say nodes a ``tid``.
+
+    Returns an index (file, line) -> say node used to attach translations.
+    """
+    by_line: dict[tuple[str, int], dict] = {}
+    used: Counter = Counter()
+    for file, labels in modules.items():
+        n = 0
+        for label in labels:
+            group = label["name"]
+            for node in walk(label["body"]):
+                n += 1
+                node["id"] = short_hash(f"{file}:{n}")
+                if node.get("op") == "label":
+                    group = node["name"]
+                if node.get("op") != "say":
+                    continue
+                # Ren'Py style: <label>_<hash of the line>, de-duplicated
+                base = f"{group}_{short_hash((node.get('who') or '') + chr(0) + node['what'])}"
+                used[base] += 1
+                node["tid"] = base if used[base] == 1 else f"{base}_{used[base] - 1}"
+                node["_group"] = group
+                if "_ln" in node:
+                    by_line[(file, node["_ln"])] = node
+    return by_line
+
+
+def strip_temp(modules: dict[str, list[dict[str, Any]]]) -> None:
+    for labels in modules.values():
+        for label in labels:
+            for node in walk(label["body"]):
+                node.pop("_ln", None)
+                node.pop("_group", None)
+
+
+def import_tl(game_dir: Path, modules: dict[str, list[dict[str, Any]]],
+              by_line: dict[tuple[str, int], dict], warn) -> dict[str, LocaleData]:
+    """Read tl/<lang>/ of a game into per-language tables (lines are re-keyed to our tids)."""
+    tl_root = next((p for p in game_dir.iterdir() if p.is_dir() and p.name.lower() == "tl"), None)
+    if tl_root is None:
+        return {}
+    # fallback matching: Ren'Py id prefix is the label; compare the line text
+    by_group: dict[str, list[dict]] = defaultdict(list)
+    for labels in modules.values():
+        for label in labels:
+            for node in walk(label["body"]):
+                if node.get("op") == "say":
+                    by_group[node.get("_group", label["name"])].append(node)
+
+    result: dict[str, LocaleData] = {}
+    for lang_dir in sorted(p for p in tl_root.iterdir() if p.is_dir()):
+        if lang_dir.name == "None":
+            continue  # strings for the source language itself
+        loc = LocaleData(renpy=lang_dir.name)
+        for f in sorted(lang_dir.rglob("*.rpy")):
+            try:
+                _read_tl_file(f.read_text(encoding="utf-8", errors="replace"), loc, by_line,
+                              by_group)
+            except ParseError as e:
+                warn(f"Перевод {lang_dir.name}: ошибка разбора", f"{f.name}:{e.lineno}")
+        if loc.lines or loc.strings:
+            result[lang_code(lang_dir.name)] = loc
+            if loc.unmatched:
+                warn(f"Перевод {lang_dir.name}: реплики без пары в скрипте ({loc.unmatched})")
+    return result
+
+
+def _read_tl_file(text: str, loc: LocaleData, by_line, by_group) -> None:
+    tree = parse_tree(text)
+    raw_lines = text.replace("\r\n", "\n").split("\n")
+    for line in tree:
+        m = _TRANSLATE.match(line.text)
+        if not m:
+            continue
+        ident = m.group(2)
+        if ident == "strings":
+            _read_strings(line.block, loc)
+            continue
+        if ident == "python" or ident == "style":
+            continue
+        texts = [s for s in (_say_text(child) for child in line.block) if s is not None]
+        if not texts:
+            continue
+        translated = "\n".join(texts) if len(texts) > 1 else texts[0]
+        target = None
+        src = _source_location(raw_lines, line.lineno)
+        if src is not None:
+            target = by_line.get(src)
+        if target is None:
+            original = _source_comment(line.block, raw_lines)
+            group = ident.rsplit("_", 1)[0]
+            for node in by_group.get(group, []):
+                if original is not None and node["what"] == original:
+                    target = node
+                    break
+        if target is None:
+            loc.unmatched += 1
+            continue
+        loc.lines[target["tid"]] = translated
+
+
+def _source_location(raw_lines: list[str], lineno: int) -> tuple[str, int] | None:
+    """The `# game/file.rpy:N` comment Ren'Py writes above each translate block."""
+    for i in range(lineno - 2, max(lineno - 5, -1), -1):
+        m = _SRC_COMMENT.match(raw_lines[i].strip())
+        if m:
+            return m.group(1), int(m.group(2))
+    return None
+
+
+def _source_comment(block: list[Line], raw_lines: list[str]) -> str | None:
+    # comments are stripped from logical lines; look at the raw text before the first line
+    if not block:
+        return None
+    for raw in raw_lines[max(0, block[0].lineno - 4):block[0].lineno - 1]:
+        s = raw.strip()
+        if s.startswith("#"):
+            c = Cursor(s[1:].strip())
+            c.dotted() if not (c.peek('"') or c.peek("'")) else None
+            while c.image_part() is not None and not (c.peek('"') or c.peek("'")):
+                pass
+            text = c.string()
+            if text is not None:
+                return text
+    return None
+
+
+def _say_text(line: Line) -> str | None:
+    c = Cursor(line.text)
+    first = c.string()
+    if first is not None:
+        second = c.string() if not c.eol() else None
+        return second if second is not None else first
+    if c.dotted() is None:
+        return None
+    while True:
+        save = c.pos
+        if c.string_raw() is not None:
+            c.pos = save
+            break
+        if c.image_part() is None and not c.char("@"):
+            c.pos = save
+            break
+    return c.string()
+
+
+def _read_strings(block: list[Line], loc: LocaleData) -> None:
+    old = None
+    for line in block:
+        c = Cursor(line.text)
+        kw = c.word()
+        if kw == "old":
+            old = c.string()
+        elif kw == "new" and old is not None:
+            new = c.string()
+            if new is not None and new != old:
+                loc.strings[old] = new
+            old = None
+
+
+def detect_language(modules: dict[str, list[dict[str, Any]]]) -> str | None:
+    """Guess the source language of the dialogue from a sample of lines."""
+    scores: Counter = Counter()
+    letters = Counter()
+    seen = 0
+    for labels in modules.values():
+        for label in labels:
+            for node in walk(label["body"]):
+                if node.get("op") != "say" or seen > 4000:
+                    continue
+                seen += 1
+                text = _TAGS.sub(" ", node["what"]).lower()
+                for ch in text:
+                    if "Ѐ" <= ch <= "ӿ":
+                        letters["cyr"] += 1
+                    elif "぀" <= ch <= "ヿ":
+                        letters["ja"] += 1
+                    elif "一" <= ch <= "鿿":
+                        letters["zh"] += 1
+                    elif ch.isalpha():
+                        letters["lat"] += 1
+                for w in _WORDS.findall(text):
+                    for lang, words in _STOPWORDS.items():
+                        if w in words:
+                            scores[lang] += 1
+    if not seen:
+        return None
+    total = sum(letters.values()) or 1
+    if letters["cyr"] / total > 0.4:
+        return "ru"
+    if letters["ja"] / total > 0.2:
+        return "ja"
+    if letters["zh"] / total > 0.3:
+        return "zh-Hans"
+    return scores.most_common(1)[0][0] if scores else None
diff --git a/backend/app/converter/pipeline.py b/backend/app/converter/pipeline.py
index d30f458..5140fc2 100644
--- a/backend/app/converter/pipeline.py
+++ b/backend/app/converter/pipeline.py
@@ -1,289 +1,349 @@
-"""Full conversion: uploaded archive → blobs + version manifest."""
-
-import json
-import logging
-import os
-import shutil
-import time
-from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import dataclass
-from pathlib import Path, PurePosixPath
-from typing import Any
-
-from app.blobs import put_bytes, put_file
-from app.config import get_settings
-from app.converter import assets
-from app.converter.archive import extract, find_game_dir
-from app.converter.rpa import RpaError, extract_rpa
-from app.converter.rpy_lexer import ParseError
-from app.converter.rpy_parser import RpyParser, ScriptData
-from app.converter.rpyc import decompile_missing
-
-log = logging.getLogger(__name__)
-FORMAT = "pgvn/1"
-
-Progress = Callable[[str], None]
-
-
-@dataclass
-class Result:
-    manifest: dict[str, Any]
-    report: dict[str, Any]
-    title: str | None
-    cover_source: str | None  # blob id of an image suitable as a cover
-    size: int
-
-
-def convert_archive(archive: Path, filename: str, work: Path, progress: Progress) -> Result:
-    """Convert an uploaded archive, or an already unpacked game directory (left untouched)."""
-    started = time.monotonic()
-    if work.exists():
-        shutil.rmtree(work)
-    src_root = work / "src"
-    out_dir = work / "out"
-    out_dir.mkdir(parents=True)
-    data = ScriptData()
-
-    if archive.is_dir():
-        progress("Копирование файлов игры")
-        game_dir = src_root / "game"
-        shutil.copytree(find_game_dir(archive), game_dir)
-    else:
-        progress("Распаковка архива")
-        extract(archive, filename, src_root)
-        game_dir = find_game_dir(src_root)
-
-    rpas = sorted(game_dir.rglob("*.rpa"))
-    for i, rpa in enumerate(rpas, 1):
-        progress(f"Распаковка {rpa.name} ({i}/{len(rpas)})")
-        try:
-            extract_rpa(rpa, game_dir)
-        except RpaError as e:
-            data.warn(str(e))
-        rpa.unlink()
-
-    progress("Декомпиляция .rpyc")
-    decompiled = decompile_missing(game_dir, data.warn)
-
-    progress("Разбор скриптов")
-    rpy_files = sorted((p for p in game_dir.rglob("*.rpy") if not _is_engine_file(game_dir, p)),
-                       key=lambda p: p.relative_to(game_dir).as_posix().lower())
-    for p in rpy_files:
-        rel = p.relative_to(game_dir).as_posix()
-        try:
-            RpyParser(data, rel).parse(p.read_text(encoding="utf-8", errors="replace"))
-        except ParseError as e:
-            data.warn(f"Ошибка разбора файла: {e.msg}", f"{e.filename}:{e.lineno}")
-        except RecursionError:
-            data.warn("Слишком глубокая вложенность", rel)
-    if not any(lbl["name"] == "start" for labels in data.modules.values() for lbl in labels):
-        raise RuntimeError("В скриптах не найдена метка start — нечего запускать")
-
-    files: dict[str, dict[str, Any]] = {}
-    aliases: dict[str, str] = {}
-    media = [p for p in game_dir.rglob("*")
-             if p.is_file() and assets.kind_of(p) and not _is_engine_file(game_dir, p)]
-    counts = {"image": 0, "audio": 0, "video": 0, "font": 0}
-    failed: list[str] = []
-    done = 0
-
-    def work_one(p: Path) -> tuple[str, str, str, int]:
-        out, ext = assets.convert(p, out_dir)
-        blob_id, size = put_file(out, ext, move=True)
-        rel = p.relative_to(game_dir).as_posix()
-        logical = str(PurePosixPath(rel).with_suffix(ext))
-        return rel, logical, blob_id, size
-
-    with ThreadPoolExecutor(max_workers=get_settings().worker_threads) as pool:
-        futures = {pool.submit(work_one, p): p for p in media}
-        for fut in as_completed(futures):
-            p = futures[fut]
-            done += 1
-            if done % 20 == 0 or done == len(media):
-                progress(f"Конвертация медиа {done}/{len(media)}")
-            try:
-                rel, logical, blob_id, size = fut.result()
-            except Exception as e:  # noqa: BLE001 — one broken file must not fail the game
-                failed.append(p.name)
-                data.warn("Не удалось сконвертировать файл", f"{p.name}: {e}")
-                continue
-            files[logical] = {"hash": blob_id, "size": size}
-            aliases[rel.lower()] = logical
-            counts[assets.kind_of(p)] += 1
-
-    progress("Сборка формата PGVN")
-    _auto_images(data, aliases)
-    missing: set[str] = set()
-    images = {name: _resolve_image(img, aliases, missing) for name, img in data.images.items()}
-    audio = {name: _resolve(path, aliases) or path for name, path in data.audio.items()}
-
-    scripts: list[str] = []
-    for rel, labels in data.modules.items():
-        logical = "script/" + str(PurePosixPath(rel).with_suffix(".json"))
-        payload = json.dumps({"file": rel, "labels": labels, "anchors": anchors(labels)},
-                             ensure_ascii=False,
-                             separators=(",", ":")).encode()
-        blob_id, size = put_bytes(payload, ".json")
-        files[logical] = {"hash": blob_id, "size": size}
-        scripts.append(logical)
-
-    gui = data.gui
-    resolution = gui.get("resolution") or [
-        data.config.get("screen_width") or 1280, data.config.get("screen_height") or 720]
-    title = data.config.get("name") if isinstance(data.config.get("name"), str) else None
-    game = {
-        "format": FORMAT,
-        "engine": "renpy",
-        "title": title,
-        "version": data.config.get("version"),
-        "resolution": resolution,
-        "entry": "start",
-        "scripts": scripts,
-        "characters": data.characters,
-        "images": images,
-        "transforms": data.transforms,
-        "transitions": data.transitions,
-        "audio": audio,
-        "channels": data.channels,
-        "files": aliases,
-        "defaults": data.defaults,
-        "init": data.init_code,
-        "ui": _ui(gui, aliases),
-    }
-    payload = json.dumps(game, ensure_ascii=False, separators=(",", ":")).encode()
-    blob_id, size = put_bytes(payload, ".json")
-    files["game.json"] = {"hash": blob_id, "size": size}
-
-    cover = None
-    for candidate in ("gui/main_menu.png", "gui/main_menu.jpg", "gui/main_menu.webp",
-                      "gui/window_icon.png"):
-        if (logical := aliases.get(candidate)) and logical in files:
-            cover = files[logical]["hash"]
-            break
-
-    total = sum(f["size"] for f in files.values())
-    report = {
-        "format": FORMAT,
-        "durationSec": round(time.monotonic() - started, 1),
-        "scripts": len(rpy_files),
-        "decompiled": decompiled,
-        "labels": sum(len(v) for v in data.modules.values()),
-        "stats": dict(data.stats),
-        "media": counts,
-        "failedMedia": failed[:50],
-        "missingFiles": sorted(missing)[:100],
-        "warnings": [
-            {"message": msg, "count": n, "example": data.warning_examples.get(msg)}
-            for msg, n in data.warnings.most_common()
-        ],
-        "sourceSize": _size(archive),
-        "outputSize": total,
-    }
-    return Result({"format": FORMAT, "files": files}, report, title, cover, total)
-
-
-def _size(path: Path) -> int:
-    if path.is_file():
-        return path.stat().st_size
-    return sum(p.stat().st_size for p in path.rglob("*") if p.is_file())
-
-
-def _is_engine_file(game_dir: Path, p: Path) -> bool:
-    parts = [x.lower() for x in p.relative_to(game_dir).parts]
-    return len(parts) > 1 and parts[0] in ("cache", "saves", "tl", "renpy")
-
-
-def _resolve(path: str, aliases: dict[str, str]) -> str | None:
-    key = path.replace("\\", "/").lower().lstrip("/")
-    for prefix in ("", "images/", "audio/", "music/", "sound/", "sounds/"):
-        if (hit := aliases.get(prefix + key)) is not None:
-            return hit
-    return None
-
-
-def _resolve_image(img: dict[str, Any], aliases: dict[str, str], missing: set[str]
-                   ) -> dict[str, Any]:
-    img = dict(img)
-    for key in ("file", "movie"):
-        if isinstance(img.get(key), str):
-            hit = _resolve(img[key], aliases)
-            if hit is None:
-                missing.add(img[key])
-            else:
-                img[key] = hit
-    if "switch" in img:
-        img["switch"] = [[c, _resolve_image(sub, aliases, missing)] for c, sub in img["switch"]]
-    if "composite" in img:
-        img["composite"] = [{**layer, "img": _resolve_image(layer["img"], aliases, missing)}
-                            for layer in img["composite"]]
-    if "frames" in img:
-        img["frames"] = [{**f, "img": _resolve_image(f["img"], aliases, missing)}
-                         for f in img["frames"]]
-    if "layered" in img:
-        layers = []
-        for layer in img["layered"]:
-            layer = dict(layer)
-            for key in ("always", "img"):
-                if key in layer:
-                    layer[key] = _resolve_image(layer[key], aliases, missing)
-            if "cond" in layer:
-                layer["cond"] = [[c, _resolve_image(sub, aliases, missing)]
-                                 for c, sub in layer["cond"]]
-            layers.append(layer)
-        img["layered"] = layers
-    return img
-
-
-def anchors(labels: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
-    """Positions of `label` markers (nested labels, named menus) inside label bodies."""
-    found: dict[str, dict[str, Any]] = {}
-
-    def walk(nodes: list[dict[str, Any]], top: str, path: list[int]) -> None:
-        for i, n in enumerate(nodes):
-            here = path + [i]
-            if n["op"] == "label":
-                found[n["name"]] = {"label": top, "path": here, "params": n.get("params")}
-            if n["op"] == "if":
-                for b, branch in enumerate(n["branches"]):
-                    walk(branch["body"], top, here + [b])
-            elif n["op"] == "menu":
-                for b, item in enumerate(n["items"]):
-                    walk(item["body"], top, here + [b])
-            elif n["op"] == "while":
-                walk(n["body"], top, here + [0])
-
-    for label in labels:
-        walk(label["body"], label["name"], [])
-    return found
-
-
-def _auto_images(data: ScriptData, aliases: dict[str, str]) -> None:
-    """Ren'Py defines an image for every file under images/ (name = lowercase basename)."""
-    for rel, logical in aliases.items():
-        if not rel.startswith("images/") or assets.kind_of(Path(rel)) != "image":
-            continue
-        name = os.path.splitext(os.path.basename(rel))[0].lower().strip()
-        name = " ".join(name.split())
-        if name and name not in data.images:
-            data.images[name] = {"file": rel}
-
-
-def _ui(gui: dict[str, Any], aliases: dict[str, str]) -> dict[str, Any]:
-    ui: dict[str, Any] = {}
-    for key, rel in (("textbox", "gui/textbox.png"), ("namebox", "gui/namebox.png"),
-                     ("mainMenu", "gui/main_menu.png"), ("nvl", "gui/nvl.png"),
-                     ("choice", "gui/button/choice_idle_background.png"),
-                     ("choiceHover", "gui/button/choice_hover_background.png")):
-        if hit := aliases.get(rel):
-            ui[key] = hit
-    for key in ("text_font", "name_text_font"):
-        if isinstance(gui.get(key), str) and (hit := _resolve(gui[key], aliases)):
-            ui[key] = hit
-    for key in ("text_size", "name_text_size", "text_color", "accent_color", "textbox_height",
-                "textbox_yalign", "dialogue_xpos", "dialogue_ypos", "dialogue_width",
-                "name_xpos", "name_ypos", "interface_text_color", "idle_color", "hover_color",
-                "choice_button_text_idle_color", "choice_button_text_hover_color"):
-        if isinstance(gui.get(key), (int, float, str)):
-            ui[key] = gui[key]
-    return ui
+"""Full conversion: uploaded archive → blobs + version manifest."""
+
+import json
+import logging
+import os
+import shutil
+import time
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from app.blobs import put_bytes, put_file
+from app.config import get_settings
+from app.converter import assets, locales
+from app.converter.archive import extract, find_game_dir
+from app.converter.rpa import RpaError, extract_rpa
+from app.converter.rpy_lexer import ParseError
+from app.converter.rpy_parser import RpyParser, ScriptData
+from app.converter.rpyc import decompile_missing
+
+log = logging.getLogger(__name__)
+FORMAT = "pgvn/1"
+
+Progress = Callable[[str], None]
+
+
+@dataclass
+class Result:
+    manifest: dict[str, Any]
+    report: dict[str, Any]
+    title: str | None
+    cover_source: str | None  # blob id of an image suitable as a cover
+    size: int
+
+
+def convert_archive(archive: Path, filename: str, work: Path, progress: Progress) -> Result:
+    """Convert an uploaded archive, or an already unpacked game directory (left untouched)."""
+    started = time.monotonic()
+    if work.exists():
+        shutil.rmtree(work)
+    src_root = work / "src"
+    out_dir = work / "out"
+    out_dir.mkdir(parents=True)
+    data = ScriptData()
+
+    if archive.is_dir():
+        progress("Копирование файлов игры")
+        game_dir = src_root / "game"
+        shutil.copytree(find_game_dir(archive), game_dir)
+    else:
+        progress("Распаковка архива")
+        extract(archive, filename, src_root)
+        game_dir = find_game_dir(src_root)
+
+    rpas = sorted(game_dir.rglob("*.rpa"))
+    for i, rpa in enumerate(rpas, 1):
+        progress(f"Распаковка {rpa.name} ({i}/{len(rpas)})")
+        try:
+            extract_rpa(rpa, game_dir)
+        except RpaError as e:
+            data.warn(str(e))
+        rpa.unlink()
+
+    progress("Декомпиляция .rpyc")
+    decompiled = decompile_missing(game_dir, data.warn)
+
+    progress("Разбор скриптов")
+    rpy_files = sorted((p for p in game_dir.rglob("*.rpy") if not _is_engine_file(game_dir, p)),
+                       key=lambda p: p.relative_to(game_dir).as_posix().lower())
+    for p in rpy_files:
+        rel = p.relative_to(game_dir).as_posix()
+        try:
+            RpyParser(data, rel).parse(p.read_text(encoding="utf-8", errors="replace"))
+        except ParseError as e:
+            data.warn(f"Ошибка разбора файла: {e.msg}", f"{e.filename}:{e.lineno}")
+        except RecursionError:
+            data.warn("Слишком глубокая вложенность", rel)
+    if not any(lbl["name"] == "start" for labels in data.modules.values() for lbl in labels):
+        raise RuntimeError("В скриптах не найдена метка start — нечего запускать")
+
+    files: dict[str, dict[str, Any]] = {}
+    aliases: dict[str, str] = {}
+    media = [p for p in game_dir.rglob("*")
+             if p.is_file() and assets.kind_of(p) and not _is_engine_file(game_dir, p)]
+    counts = {"image": 0, "audio": 0, "video": 0, "font": 0}
+    failed: list[str] = []
+    done = 0
+
+    def work_one(p: Path) -> tuple[str, str, str, int]:
+        out, ext = assets.convert(p, out_dir)
+        blob_id, size = put_file(out, ext, move=True)
+        rel = p.relative_to(game_dir).as_posix()
+        logical = str(PurePosixPath(rel).with_suffix(ext))
+        return rel, logical, blob_id, size
+
+    with ThreadPoolExecutor(max_workers=get_settings().worker_threads) as pool:
+        futures = {pool.submit(work_one, p): p for p in media}
+        for fut in as_completed(futures):
+            p = futures[fut]
+            done += 1
+            if done % 20 == 0 or done == len(media):
+                progress(f"Конвертация медиа {done}/{len(media)}")
+            try:
+                rel, logical, blob_id, size = fut.result()
+            except Exception as e:  # noqa: BLE001 — one broken file must not fail the game
+                failed.append(p.name)
+                data.warn("Не удалось сконвертировать файл", f"{p.name}: {e}")
+                continue
+            files[logical] = {"hash": blob_id, "size": size}
+            aliases[rel.lower()] = logical
+            counts[assets.kind_of(p)] += 1
+
+    progress("Сборка формата PGVN")
+    _auto_images(data, aliases)
+    missing: set[str] = set()
+    images = {name: _resolve_image(img, aliases, missing) for name, img in data.images.items()}
+    audio = {name: _resolve(path, aliases) or path for name, path in data.audio.items()}
+
+    progress("Извлечение текстов и переводов")
+    by_line = locales.assign_ids(data.modules)
+    translations = locales.import_tl(game_dir, data.modules, by_line, data.warn)
+    locales.strip_temp(data.modules)
+    language = data.config.get("language")
+    source_lang = (locales.lang_code(language) if isinstance(language, str)
+                   else locales.detect_language(data.modules)) or "und"
+
+    scripts: list[str] = []
+    for rel, labels in data.modules.items():
+        logical = "script/" + str(PurePosixPath(rel).with_suffix(".json"))
+        payload = json.dumps({"file": rel, "labels": labels, "anchors": anchors(labels)},
+                             ensure_ascii=False,
+                             separators=(",", ":")).encode()
+        blob_id, size = put_bytes(payload, ".json")
+        files[logical] = {"hash": blob_id, "size": size}
+        scripts.append(logical)
+
+    locale_index = _write_locales(translations, data.modules, files)
+
+    gui = data.gui
+    resolution = gui.get("resolution") or [
+        data.config.get("screen_width") or 1280, data.config.get("screen_height") or 720]
+    title = data.config.get("name") if isinstance(data.config.get("name"), str) else None
+    game = {
+        "format": FORMAT,
+        "engine": "renpy",
+        "title": title,
+        "version": data.config.get("version"),
+        "resolution": resolution,
+        "entry": "start",
+        "scripts": scripts,
+        "characters": data.characters,
+        "images": images,
+        "transforms": data.transforms,
+        "transitions": data.transitions,
+        "audio": audio,
+        "channels": data.channels,
+        "files": aliases,
+        "defaults": data.defaults,
+        "init": data.init_code,
+        "ui": _ui(gui, aliases),
+        "sourceLang": source_lang,
+        "locales": locale_index,
+    }
+    payload = json.dumps(game, ensure_ascii=False, separators=(",", ":")).encode()
+    blob_id, size = put_bytes(payload, ".json")
+    files["game.json"] = {"hash": blob_id, "size": size}
+
+    cover = None
+    for candidate in ("gui/main_menu.png", "gui/main_menu.jpg", "gui/main_menu.webp",
+                      "gui/window_icon.png"):
+        if (logical := aliases.get(candidate)) and logical in files:
+            cover = files[logical]["hash"]
+            break
+
+    total = sum(f["size"] for f in files.values())
+    report = {
+        "format": FORMAT,
+        "durationSec": round(time.monotonic() - started, 1),
+        "scripts": len(rpy_files),
+        "decompiled": decompiled,
+        "labels": sum(len(v) for v in data.modules.values()),
+        "stats": dict(data.stats),
+        "media": counts,
+        "failedMedia": failed[:50],
+        "missingFiles": sorted(missing)[:100],
+        "sourceLang": source_lang,
+        "locales": {code: {"lines": meta["lines"], "strings": meta["strings_count"],
+                           "progress": meta["progress"]}
+                    for code, meta in locale_index.items()},
+        "warnings": [
+            {"message": msg, "count": n, "example": data.warning_examples.get(msg)}
+            for msg, n in data.warnings.most_common()
+        ],
+        "sourceSize": _size(archive),
+        "outputSize": total,
+    }
+    return Result({"format": FORMAT, "files": files}, report, title, cover, total)
+
+
+def _write_locales(translations: dict[str, "locales.LocaleData"],
+                   modules: dict[str, list[dict[str, Any]]],
+                   files: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
+    """Store each language as per-module line tables plus one strings table."""
+    tid_module: dict[str, str] = {}
+    tid_source: dict[str, str] = {}
+    for rel, labels in modules.items():
+        for label in labels:
+            for node in locales.walk(label["body"]):
+                if node.get("op") == "say":
+                    tid_module[node["tid"]] = rel
+                    tid_source[node["tid"]] = node["what"]
+    index: dict[str, dict[str, Any]] = {}
+
+    def put_json(path: str, value: Any) -> None:
+        payload = json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode()
+        blob_id, size = put_bytes(payload, ".json")
+        files[path] = {"hash": blob_id, "size": size}
+
+    for code, loc in sorted(translations.items()):
+        grouped: dict[str, dict[str, Any]] = {}
+        for tid, text in loc.lines.items():
+            grouped.setdefault(tid_module[tid], {})[tid] = {
+                "t": text, "src": locales.short_hash(tid_source[tid]), "state": "translated"}
+        module_files = {}
+        for rel, entries in grouped.items():
+            path = f"locales/{code}/" + str(PurePosixPath(rel).with_suffix(".json"))
+            put_json(path, entries)
+            module_files["script/" + str(PurePosixPath(rel).with_suffix(".json"))] = path
+        strings_path = f"locales/{code}/strings.json"
+        put_json(strings_path, {old: {"t": new, "state": "translated"}
+                                for old, new in loc.strings.items()})
+        index[code] = {
+            "name": locales.LANG_NAMES.get(code, loc.renpy),
+            "renpy": loc.renpy,
+            "modules": module_files,
+            "strings": strings_path,
+            "lines": len(loc.lines),
+            "strings_count": len(loc.strings),
+            "progress": round(len(loc.lines) / len(tid_module), 3) if tid_module else 0,
+        }
+    return index
+
+
+def _size(path: Path) -> int:
+    if path.is_file():
+        return path.stat().st_size
+    return sum(p.stat().st_size for p in path.rglob("*") if p.is_file())
+
+
+def _is_engine_file(game_dir: Path, p: Path) -> bool:
+    parts = [x.lower() for x in p.relative_to(game_dir).parts]
+    return len(parts) > 1 and parts[0] in ("cache", "saves", "tl", "renpy")
+
+
+def _resolve(path: str, aliases: dict[str, str]) -> str | None:
+    key = path.replace("\\", "/").lower().lstrip("/")
+    for prefix in ("", "images/", "audio/", "music/", "sound/", "sounds/"):
+        if (hit := aliases.get(prefix + key)) is not None:
+            return hit
+    return None
+
+
+def _resolve_image(img: dict[str, Any], aliases: dict[str, str], missing: set[str]
+                   ) -> dict[str, Any]:
+    img = dict(img)
+    for key in ("file", "movie"):
+        if isinstance(img.get(key), str):
+            hit = _resolve(img[key], aliases)
+            if hit is None:
+                missing.add(img[key])
+            else:
+                img[key] = hit
+    if "switch" in img:
+        img["switch"] = [[c, _resolve_image(sub, aliases, missing)] for c, sub in img["switch"]]
+    if "composite" in img:
+        img["composite"] = [{**layer, "img": _resolve_image(layer["img"], aliases, missing)}
+                            for layer in img["composite"]]
+    if "frames" in img:
+        img["frames"] = [{**f, "img": _resolve_image(f["img"], aliases, missing)}
+                         for f in img["frames"]]
+    if "layered" in img:
+        layers = []
+        for layer in img["layered"]:
+            layer = dict(layer)
+            for key in ("always", "img"):
+                if key in layer:
+                    layer[key] = _resolve_image(layer[key], aliases, missing)
+            if "cond" in layer:
+                layer["cond"] = [[c, _resolve_image(sub, aliases, missing)]
+                                 for c, sub in layer["cond"]]
+            layers.append(layer)
+        img["layered"] = layers
+    return img
+
+
+def anchors(labels: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
+    """Positions of `label` markers (nested labels, named menus) inside label bodies."""
+    found: dict[str, dict[str, Any]] = {}
+
+    def walk(nodes: list[dict[str, Any]], top: str, path: list[int]) -> None:
+        for i, n in enumerate(nodes):
+            here = path + [i]
+            if n["op"] == "label":
+                found[n["name"]] = {"label": top, "path": here, "params": n.get("params")}
+            if n["op"] == "if":
+                for b, branch in enumerate(n["branches"]):
+                    walk(branch["body"], top, here + [b])
+            elif n["op"] == "menu":
+                for b, item in enumerate(n["items"]):
+                    walk(item["body"], top, here + [b])
+            elif n["op"] == "while":
+                walk(n["body"], top, here + [0])
+
+    for label in labels:
+        walk(label["body"], label["name"], [])
+    return found
+
+
+def _auto_images(data: ScriptData, aliases: dict[str, str]) -> None:
+    """Ren'Py defines an image for every file under images/ (name = lowercase basename)."""
+    for rel, logical in aliases.items():
+        if not rel.startswith("images/") or assets.kind_of(Path(rel)) != "image":
+            continue
+        name = os.path.splitext(os.path.basename(rel))[0].lower().strip()
+        name = " ".join(name.split())
+        if name and name not in data.images:
+            data.images[name] = {"file": rel}
+
+
+def _ui(gui: dict[str, Any], aliases: dict[str, str]) -> dict[str, Any]:
+    ui: dict[str, Any] = {}
+    for key, rel in (("textbox", "gui/textbox.png"), ("namebox", "gui/namebox.png"),
+                     ("mainMenu", "gui/main_menu.png"), ("nvl", "gui/nvl.png"),
+                     ("choice", "gui/button/choice_idle_background.png"),
+                     ("choiceHover", "gui/button/choice_hover_background.png")):
+        if hit := aliases.get(rel):
+            ui[key] = hit
+    for key in ("text_font", "name_text_font"):
+        if isinstance(gui.get(key), str) and (hit := _resolve(gui[key], aliases)):
+            ui[key] = hit
+    for key in ("text_size", "name_text_size", "text_color", "accent_color", "textbox_height",
+                "textbox_yalign", "dialogue_xpos", "dialogue_ypos", "dialogue_width",
+                "name_xpos", "name_ypos", "interface_text_color", "idle_color", "hover_color",
+                "choice_button_text_idle_color", "choice_button_text_hover_color"):
+        if isinstance(gui.get(key), (int, float, str)):
+            ui[key] = gui[key]
+    return ui
diff --git a/backend/app/converter/rpy_parser.py b/backend/app/converter/rpy_parser.py
index b1ca22d..dae5cb3 100644
--- a/backend/app/converter/rpy_parser.py
+++ b/backend/app/converter/rpy_parser.py
@@ -1,1226 +1,1229 @@
-"""Ren'Py script (.rpy) → PGVN IR."""
-
-import ast
-import re
-import warnings
-from collections import Counter
-from dataclasses import dataclass, field
-from typing import Any
-
-from app.converter import pyexpr
-from app.converter.pyexpr import Expr, Stmt, Unsupported, const
-from app.converter.rpy_lexer import Cursor, Line, ParseError, parse_tree
-
-Node = dict[str, Any]
-
-TRANSITIONS: dict[str, dict[str, Any]] = {
-    "dissolve": {"t": "dissolve", "d": 0.5},
-    "fade": {"t": "fade", "out": 0.5, "hold": 0.0, "in": 0.5, "color": "#000000"},
-    "pixellate": {"t": "dissolve", "d": 1.0},
-    "move": {"t": "move", "d": 0.5},
-    "ease": {"t": "move", "d": 0.5},
-    "vpunch": {"t": "punch", "dir": "v", "d": 0.3},
-    "hpunch": {"t": "punch", "dir": "h", "d": 0.3},
-    "blinds": {"t": "dissolve", "d": 1.0},
-    "squares": {"t": "dissolve", "d": 1.0},
-    "wipeleft": {"t": "wipe", "dir": "left", "d": 1.0},
-    "wiperight": {"t": "wipe", "dir": "right", "d": 1.0},
-    "wipeup": {"t": "wipe", "dir": "up", "d": 1.0},
-    "wipedown": {"t": "wipe", "dir": "down", "d": 1.0},
-    "zoomin": {"t": "dissolve", "d": 0.5},
-    "zoomout": {"t": "dissolve", "d": 0.5},
-}
-for _side in ("left", "right", "top", "bottom"):
-    for _kind in ("movein", "moveout", "easein", "easeout", "slide", "slideaway",
-                  "push", "irisin", "irisout"):
-        TRANSITIONS.setdefault(f"{_kind}{_side}", {"t": "slide", "dir": _side, "d": 0.5,
-                                                    "kind": _kind})
-TRANSITION_CLASSES = {"Dissolve", "Fade", "ImageDissolve", "AlphaDissolve", "Pixellate",
-                      "MoveTransition", "CropMove", "PushMove", "ComposeTransition",
-                      "MultipleTransition", "Move"}
-
-POSITIONS = {"left", "right", "center", "truecenter", "topleft", "topright", "top",
-             "offscreenleft", "offscreenright", "default", "reset"}
-POSITION_PROPS = {"xpos", "ypos", "xanchor", "yanchor", "xalign", "yalign", "xcenter",
-                  "ycenter", "zoom", "xzoom", "yzoom", "alpha", "rotate", "xoffset", "yoffset",
-                  "align", "pos", "anchor", "xysize", "size"}
-CHANNELS = {"music", "sound", "voice", "audio", "movie"}
-SKIP_BLOCKS = {"screen", "style", "translate", "testcase"}
-BUILTIN_CHARACTERS = {"narrator", "centered", "vcentered", "extend", "nvl", "adv", "name_only"}
-
-
-@dataclass
-class ScriptData:
-    characters: dict[str, dict[str, Any]] = field(default_factory=dict)
-    images: dict[str, dict[str, Any]] = field(default_factory=dict)
-    transforms: dict[str, dict[str, Any]] = field(default_factory=dict)
-    transitions: dict[str, dict[str, Any] | None] = field(default_factory=dict)
-    audio: dict[str, str] = field(default_factory=dict)
-    defaults: list[list[Any]] = field(default_factory=list)
-    init_code: list[Stmt] = field(default_factory=list)  # defines + init python, in order
-    gui: dict[str, Any] = field(default_factory=dict)
-    channels: dict[str, dict[str, Any]] = field(default_factory=dict)
-    config: dict[str, Any] = field(default_factory=dict)
-    modules: dict[str, list[Node]] = field(default_factory=dict)  # file -> labels
-    warnings: Counter = field(default_factory=Counter)
-    warning_examples: dict[str, str] = field(default_factory=dict)
-    stats: Counter = field(default_factory=Counter)
-
-    def warn(self, kind: str, where: str = "") -> None:
-        self.warnings[kind] += 1
-        if where and kind not in self.warning_examples:
-            self.warning_examples[kind] = where
-
-
-class RpyParser:
-    def __init__(self, data: ScriptData, filename: str):
-        self.d = data
-        self.filename = filename
-        self.global_label = ""
-
-    def label_ref(self, name: str) -> str:
-        """Resolve `.local` label names against the enclosing global label."""
-        return self.global_label + name if name.startswith(".") else name
-
-    # --- helpers -------------------------------------------------------------
-
-    def where(self, line: Line) -> str:
-        return f"{self.filename}:{line.lineno}"
-
-    def cursor(self, line: Line, text: str | None = None) -> Cursor:
-        return Cursor(line.text if text is None else text, self.filename, line.lineno)
-
-    def expr(self, source: str, line: Line, default: Expr | None = None) -> Expr | None:
-        try:
-            return pyexpr.parse_expr(source)
-        except Unsupported as e:
-            self.d.warn(f"Выражение: {e}", self.where(line))
-            return default
-
-    def python(self, source: str, line: Line) -> list[Stmt]:
-        """Translate python code statement by statement, skipping unsupported ones."""
-        try:
-            tree = _parse_py(source)
-        except SyntaxError as e:
-            self.d.warn(f"Python: синтаксическая ошибка ({e.msg})", self.where(line))
-            return []
-        out: list[Stmt] = []
-        for node in tree.body:
-            try:
-                out.extend(pyexpr.stmt(node))
-            except Unsupported as e:
-                self.d.warn(f"Python: {e}", f"{self.filename}:{line.lineno + node.lineno}")
-        return out
-
-    # --- top level -------------------------------------------------------------
-
-    def parse(self, source: str) -> None:
-        tree = parse_tree(source, self.filename)
-        labels: list[Node] = []
-        current: Node | None = None
-        for line in tree:
-            c = self.cursor(line)
-            first = c.peek_word()
-            if first == "label":
-                name, params = self.label_header(line)
-                if not name.startswith("."):
-                    self.global_label = name
-                current = {"name": self.label_ref(name), "body": self.block(line.block)}
-                if params:
-                    current["params"] = params
-                labels.append(current)
-                continue
-            nodes = self.statement(line, top_level=True)
-            if nodes and current is not None:
-                current["body"].extend(nodes)
-            elif nodes:
-                # statements before any label run on fall-through into the first label
-                labels.append(current := {"name": f"_{self.filename}_{line.lineno}",
-                                          "body": nodes})
-        self.d.modules[self.filename] = labels
-
-    def block(self, lines: list[Line]) -> list[Node]:
-        out: list[Node] = []
-        i = 0
-        while i < len(lines):
-            line = lines[i]
-            word = Cursor(line.text).peek_word()
-            if word == "if":
-                branches, i = self.if_chain(lines, i)
-                out.append({"op": "if", "branches": branches})
-                continue
-            if word == "label":
-                # a label inside a block is an entry point in the middle of the flow:
-                # keep a marker the player can jump to and inline the label's block
-                name, params = self.label_header(line)
-                if not name.startswith("."):
-                    self.global_label = name
-                marker: Node = {"op": "label", "name": self.label_ref(name)}
-                if params:
-                    marker["params"] = params
-                out.append(marker)
-                out.extend(self.block(line.block))
-                i += 1
-                continue
-            out.extend(self.statement(line))
-            i += 1
-        return out
-
-    def label_header(self, line: Line) -> tuple[str, list[list[Any]] | None]:
-        c = self.cursor(line)
-        c.keyword("label")
-        name = c.label_name()
-        if not name:
-            raise c.error("ожидалось имя метки")
-        params = None
-        if c.peek("("):
-            sig = c.until(set(), ":")
-            try:
-                fn = _parse_py(f"def _f{sig}: pass").body[0]
-                args = fn.args
-                defaults = [None] * (len(args.args) - len(args.defaults)) + list(args.defaults)
-                params = [[a.arg, pyexpr.expr(d) if d is not None else None]
-                          for a, d in zip(args.args, defaults)]
-            except (SyntaxError, Unsupported):
-                self.d.warn("Не разобраны параметры метки", self.where(line))
-        return name, params
-
-    def call_args(self, c: Cursor, line: Line) -> dict[str, Any] | None:
-        if not c.peek("("):
-            return None
-        src = c.until({"from"})
-        try:
-            call = _parse_py(f"_f{src}", mode="eval").body
-            return {"a": [pyexpr.expr(a) for a in call.args],
-                    "kw": {k.arg: pyexpr.expr(k.value) for k in call.keywords}}
-        except (SyntaxError, Unsupported, AttributeError):
-            self.d.warn("Не разобраны аргументы call", self.where(line))
-            return None
-
-    def if_chain(self, lines: list[Line], i: int) -> tuple[list[Node], int]:
-        branches: list[Node] = []
-        while i < len(lines):
-            line = lines[i]
-            c = self.cursor(line)
-            kw = c.word()
-            if kw in ("if", "elif") and (kw == "if") == (not branches):
-                cond = c.rest().removesuffix(":").strip()
-                branches.append({"c": self.expr(cond, line, const(False)),
-                                 "body": self.block(line.block)})
-            elif kw == "else" and branches:
-                branches.append({"c": None, "body": self.block(line.block)})
-                i += 1
-                break
-            else:
-                break
-            i += 1
-        return branches, i
-
-    # --- statements ----------------------------------------------------------------
-
-    def statement(self, line: Line, top_level: bool = False) -> list[Node]:
-        text = line.text
-        if text.startswith("$"):
-            return self.dollar(text[1:].strip(), line)
-        c = self.cursor(line)
-        word = c.peek_word()
-        handler = getattr(self, f"st_{word}", None) if word else None
-        if handler and not (word in ("centered", "extend", "narrator", "nvl") and self._is_say(line)):
-            try:
-                return handler(line) or []
-            except ParseError:
-                raise
-        if word in SKIP_BLOCKS:
-            if word not in ("style", "translate"):
-                self.d.warn(f"Не поддерживается: {word}", self.where(line))
-            return []
-        say = self.say(line)
-        if say is not None:
-            return say
-        self.d.warn("Неизвестный оператор", f"{self.where(line)}: {text[:60]}")
-        return []
-
-    def _is_say(self, line: Line) -> bool:
-        c = self.cursor(line)
-        c.word()
-        while c.image_part() is not None and not c.peek('"') and not c.peek("'"):
-            pass
-        return c.string_raw() is not None or c.peek('"') or c.peek("'")
-
-    def dollar(self, code: str, line: Line) -> list[Node]:
-        stmts = self.python(code, line)
-        if len(stmts) == 1 and stmts[0]["op"] == "eval":
-            special = self.renpy_call(stmts[0]["e"], line)
-            if special is not None:
-                return special
-        return [{"op": "exec", "code": stmts}] if stmts else []
-
-    def renpy_call(self, e: Expr, line: Line) -> list[Node] | None:
-        """Turn common renpy.* calls into native script nodes."""
-        if e.get("k") != "call":
-            return None
-        fname = _dotted_name(e["f"])
-        args, kw = e["a"], e["kw"]
-        if fname == "renpy.pause":
-            return [{"op": "pause", "d": args[0] if args else kw.get("delay")}]
-        if fname == "renpy.jump" and args:
-            return [_jump_or_call("jump", args[0])]
-        if fname == "renpy.call" and args:
-            return [_jump_or_call("call", args[0])]
-        if fname in ("renpy.music.play", "renpy.sound.play", "renpy.play"):
-            ch = "sound" if fname != "renpy.music.play" else "music"
-            if "channel" in kw and kw["channel"].get("k") == "const":
-                ch = kw["channel"]["v"]
-            if not args:
-                return None
-            node = {"op": "play", "ch": ch, "files": [args[0]], "loop": _const(kw.get("loop"))}
-            for key in ("fadein", "fadeout"):
-                if key in kw:
-                    node[key] = _const(kw[key])
-            return [node]
-        if fname in ("renpy.music.stop", "renpy.sound.stop"):
-            ch = "music" if fname == "renpy.music.stop" else "sound"
-            if "channel" in kw and kw["channel"].get("k") == "const":
-                ch = kw["channel"]["v"]
-            return [{"op": "stop", "ch": ch, "fadeout": _const(kw.get("fadeout"))}]
-        if fname == "renpy.show" and args and args[0].get("k") == "const":
-            return [{"op": "show", "img": {"name": str(args[0]["v"]).split()}, "at": [],
-                     "with": None}]
-        if fname == "renpy.hide" and args and args[0].get("k") == "const":
-            return [{"op": "hide", "tag": str(args[0]["v"]).split()[0]}]
-        if fname == "renpy.scene":
-            return [{"op": "scene", "img": None, "at": [], "with": None}]
-        if fname == "renpy.with_statement" and args:
-            return [{"op": "with", "t": self.transition_expr(args[0])}]
-        return None
-
-    # init / python ----------------------------------------------------------------
-
-    def st_init(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("init")
-        c.number()
-        if c.keyword("offset"):
-            return []
-        if c.keyword("python") or c.keyword("early"):
-            c.keyword("python")
-            self.init_python(line.block_source(), line)
-            return []
-        for child in line.block:
-            for node in self.statement(child, top_level=True):
-                if node["op"] == "exec":
-                    self.d.init_code.extend(node["code"])
-                else:
-                    self.d.warn("Оператор сцены внутри init", self.where(child))
-        return []
-
-    def st_python(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("python")
-        if c.keyword("early"):
-            self.init_python(line.block_source(), line)
-            return []
-        code = self.python(line.block_source(), line)
-        return [{"op": "exec", "code": code}] if code else []
-
-    def st_rpy(self, line: Line) -> list[Node]:
-        return []
-
-    def init_python(self, source: str, line: Line) -> None:
-        try:
-            tree = _parse_py(source)
-        except SyntaxError as e:
-            self.d.warn(f"Python: синтаксическая ошибка ({e.msg})", self.where(line))
-            return
-        for node in tree.body:
-            if (isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)
-                    and ast.unparse(node.value.func) == "renpy.music.register_channel"):
-                self.register_channel(node.value)
-                continue
-            if isinstance(node, ast.Assign) and len(node.targets) == 1:
-                tgt = node.targets[0]
-                name = _assign_name(tgt)
-                if name and self.define(name, ast.get_source_segment(_dedent(source), node.value)
-                                        or ast.unparse(node.value), line):
-                    continue
-            if (isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)
-                    and ast.unparse(node.value.func) == "gui.init"
-                    and len(node.value.args) == 2):
-                try:
-                    self.d.gui["resolution"] = [ast.literal_eval(a) for a in node.value.args]
-                except ValueError:
-                    pass
-                continue
-            try:
-                self.d.init_code.extend(pyexpr.stmt(node))
-            except Unsupported as e:
-                self.d.warn(f"init python: {e}", f"{self.filename}:{line.lineno + node.lineno}")
-
-    def register_channel(self, call: ast.Call) -> None:
-        args = list(call.args) + [None] * 3
-        kw = {k.arg: k.value for k in call.keywords}
-
-        def lit(node, default=None):
-            try:
-                return ast.literal_eval(node) if node is not None else default
-            except ValueError:
-                return default
-
-        name = lit(args[0])
-        if isinstance(name, str):
-            self.d.channels[name] = {"mixer": lit(kw.get("mixer", args[1]), "sfx"),
-                                     "loop": bool(lit(kw.get("loop", args[2]), False))}
-
-    # define / default / image / transform -------------------------------------------
-
-    def st_define(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("define")
-        c.number()
-        name = c.dotted()
-        if not name:
-            raise c.error("ожидалось имя")
-        op = "="
-        for candidate in ("+=", "|=", "="):
-            if c.char(candidate):
-                op = candidate
-                break
-        value = c.rest()
-        if op != "=":
-            self.d.warn("define с += не поддерживается", self.where(line))
-            return []
-        self.define(name, value, line)
-        return []
-
-    def define(self, name: str, value: str, line: Line) -> bool:
-        """Handle `define name = value`. Returns False if value was not understood."""
-        head, _, attr = name.partition(".")
-        if head in ("config", "gui", "build", "preferences", "style", "_preferences"):
-            if attr:
-                try:
-                    (self.d.config if head == "config" else self.d.gui)[attr] = pyexpr.literal(value)
-                except Unsupported:
-                    pass
-            return True
-        if head == "audio" and attr:
-            try:
-                self.d.audio[attr] = str(pyexpr.literal(value))
-            except Unsupported:
-                pass
-            return True
-        if head == "store":
-            name = attr
-        e = self.expr(value, line)
-        if e is None:
-            return False
-        if "." in name:
-            # e.g. persistent.flag = ... : a plain assignment at init time
-            self.d.init_code.append({"op": "set", "t": pyexpr.parse_expr(name), "v": e})
-            return True
-        if e["k"] == "call":
-            fname = _dotted_name(e["f"])
-            if fname in ("Character", "DynamicCharacter", "ADVCharacter", "NVLCharacter"):
-                self.d.characters[name] = self.character(fname, e, line)
-                return True
-            if fname in TRANSITION_CLASSES or fname in TRANSITIONS:
-                self.d.transitions[name] = self.transition_expr(e)
-                return True
-            if fname in ("Transform", "Position"):
-                self.d.transforms[name] = _static_props(e["kw"])
-                return True
-        if e["k"] == "name" and e["id"] in TRANSITIONS:
-            self.d.transitions[name] = TRANSITIONS[e["id"]]
-            return True
-        if e["k"] == "name" and e["id"] in self.d.characters:
-            self.d.characters[name] = dict(self.d.characters[e["id"]])
-            return True
-        self.d.init_code.append({"op": "set", "t": {"k": "name", "id": name}, "v": e})
-        return True
-
-    def character(self, fname: str, e: Expr, line: Line) -> dict[str, Any]:
-        kw = e["kw"]
-        char: dict[str, Any] = {}
-        kind = kw.get("kind")
-        if kind and kind.get("k") == "name":
-            if kind["id"] == "nvl":
-                char["nvl"] = True
-            elif kind["id"] in self.d.characters:
-                char.update(self.d.characters[kind["id"]])
-        if fname == "NVLCharacter":
-            char["nvl"] = True
-        args = e["a"]
-        if args:
-            name = args[0]
-            if fname == "DynamicCharacter" or (kw.get("dynamic") or {}).get("v"):
-                char["nameExpr"] = (self.expr(name["v"], line, const(""))
-                                    if name.get("k") == "const" and isinstance(name["v"], str)
-                                    else name)
-            elif name.get("k") == "const":
-                char["name"] = name["v"]
-            else:
-                char["nameExpr"] = name
-        mapping = {"color": "color", "who_color": "color", "what_color": "whatColor",
-                   "what_prefix": "whatPrefix", "what_suffix": "whatSuffix",
-                   "who_prefix": "whoPrefix", "who_suffix": "whoSuffix", "image": "image",
-                   "what_italic": "whatItalic", "what_bold": "whatBold"}
-        for key, target in mapping.items():
-            v = kw.get(key)
-            if v is not None and v.get("k") == "const":
-                char[target] = v["v"]
-        return char
-
-    def st_default(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("default")
-        name = c.dotted()
-        if not name or not c.char("="):
-            raise c.error("ожидалось default имя = значение")
-        e = self.expr(c.rest(), line)
-        if e is not None:
-            self.d.defaults.append([name.removeprefix("store."), e])
-        return []
-
-    def st_image(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("image")
-        parts: list[str] = []
-        while (p := c.image_part()) is not None:
-            parts.append(p)
-        if not parts:
-            raise c.error("ожидалось имя изображения")
-        name = " ".join(parts)
-        if c.char("="):
-            img = self.displayable(c.rest(), line)
-        elif c.char(":"):
-            img = self.atl_image(line)
-        else:
-            raise c.error("ожидалось = или :")
-        if img is not None:
-            self.d.images[name] = img
-        return []
-
-    def displayable(self, source: str, line: Line) -> dict[str, Any] | None:
-        e = self.expr(source, line)
-        return self.displayable_expr(e, line) if e is not None else None
-
-    def displayable_expr(self, e: Expr, line: Line) -> dict[str, Any] | None:
-        if e["k"] == "const" and isinstance(e["v"], str):
-            s = e["v"]
-            if s.startswith("#"):
-                return {"color": s}
-            if "." in s and "/" in s or s.rsplit(".", 1)[-1].lower() in _MEDIA_EXTS:
-                return {"file": s}
-            return {"ref": s}
-        if e["k"] != "call":
-            self.d.warn("Изображение задано выражением", self.where(line))
-            return {"expr": e}
-        fname = _dotted_name(e["f"])
-        args, kw = e["a"], e["kw"]
-        if fname == "Solid" and args:
-            return {"color": _const(args[0])}
-        if fname in ("Movie",):
-            play = kw.get("play") or (args[0] if args else None)
-            return {"movie": _const(play)} if play else None
-        if fname == "ConditionSwitch":
-            pairs = []
-            for i in range(0, len(args) - 1, 2):
-                cond = args[i]
-                cexpr = (self.expr(cond["v"], line, const(False))
-                         if cond.get("k") == "const" and isinstance(cond["v"], str) else cond)
-                sub = self.displayable_expr(args[i + 1], line)
-                if sub:
-                    pairs.append([cexpr, sub])
-            return {"switch": pairs}
-        if fname in ("Composite", "LiveComposite", "im.Composite") and args:
-            size = _const(args[0])
-            layers = []
-            for i in range(1, len(args) - 1, 2):
-                pos = _const(args[i])
-                sub = self.displayable_expr(args[i + 1], line)
-                if sub and isinstance(pos, (list, tuple)):
-                    layers.append({"pos": list(pos), "img": sub})
-            return {"composite": layers, "size": list(size) if isinstance(size, (list, tuple))
-                    else None}
-        # wrappers: Transform("x.png", zoom=.5), im.Scale(...), im.Flip(...), etc.
-        for a in args:
-            sub = self.displayable_expr(a, line) if a.get("k") in ("const", "call") else None
-            if sub:
-                props = _static_props(kw)
-                if fname in ("im.Flip", "Flip") and (_const(kw.get("horizontal")) is True):
-                    props["xzoom"] = -1
-                if fname in ("im.Scale", "im.FactorScale") and len(args) >= 2:
-                    if fname == "im.FactorScale":
-                        props["zoom"] = _const(args[1])
-                    elif len(args) >= 3:
-                        props["size"] = [_const(args[1]), _const(args[2])]
-                if fname in ("im.Grayscale", "im.Sepia"):
-                    props["filter"] = "grayscale" if fname == "im.Grayscale" else "sepia"
-                if props:
-                    sub = {**sub, "props": {**sub.get("props", {}), **props}}
-                return sub
-        self.d.warn(f"Изображение {fname}() не поддерживается", self.where(line))
-        return None
-
-    def atl_image(self, line: Line) -> dict[str, Any] | None:
-        frames: list[dict[str, Any]] = []
-        props: dict[str, Any] = {}
-        repeat = self.atl_frames(line.block, frames, props)
-        if not frames:
-            self.d.warn("ATL-изображение без кадров", self.where(line))
-            return None
-        if len(frames) == 1:
-            img = dict(frames[0]["img"])
-        else:
-            img = {"frames": frames, "repeat": repeat}
-        if props:
-            img["props"] = {**img.get("props", {}), **props}
-        return img
-
-    def atl_frames(self, lines: list[Line], frames: list[dict[str, Any]],
-                   props: dict[str, Any]) -> bool:
-        """Collect displayable frames of an ATL block. Returns whether it repeats."""
-        repeat = False
-        for child in lines:
-            c = self.cursor(child)
-            word = c.peek_word()
-            if word in ("contains", "block", "parallel", "choice"):
-                if not frames or word == "block":
-                    repeat = self.atl_frames(child.block, frames, props) or repeat
-                continue
-            if word == "repeat":
-                repeat = True
-                continue
-            if word in ("pause",) or _NUMBER_LINE.match(child.text):
-                c.keyword("pause")
-                d = _num(c.number())
-                if frames and d is not None:
-                    frames[-1]["d"] = frames[-1].get("d", 0) + d
-                continue
-            if word in ("function", "on", "event", "time", "transform"):
-                continue
-            s = c.string()
-            if s is not None:
-                img = self.displayable_expr(const(s), child)
-                if img:
-                    frames.append({"img": img})
-                continue
-            m = _CALL_LINE.match(child.text)
-            if m and m.group(1) in _DISPLAYABLE_CALLS:
-                e = self.expr(child.text.split(" with ")[0], child)
-                img = self.displayable_expr(e, child) if e else None
-                if img:
-                    frames.append({"img": img})
-                continue
-            if m and not frames and not _atl_props(child.text):
-                # e.g. get_face_path("base"): an image computed by game code
-                e = self.expr(child.text, child)
-                if e is not None:
-                    self.d.warn("Изображение задано выражением", self.where(child))
-                    frames.append({"img": {"expr": e}})
-                continue
-            if not frames or not frames[-1].get("d"):
-                props.update(_atl_props(child.text))
-        return repeat
-
-    def st_layeredimage(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("layeredimage")
-        parts: list[str] = []
-        while (p := c.image_part()) is not None:
-            parts.append(p)
-        name = " ".join(parts)
-        layers: list[dict[str, Any]] = []
-        at: list[dict[str, Any]] = []
-        for child in line.block:
-            cc = self.cursor(child)
-            kw = cc.word()
-            if kw == "always":
-                img = self.layer_image(cc, child, None)
-                if img:
-                    layers.append({"always": img})
-            elif kw == "attribute":
-                layers.append(self.layer_attribute(cc, child, name, None))
-            elif kw == "group":
-                group = cc.word() or ""
-                auto = False
-                while not cc.eol():
-                    w = cc.word()
-                    if w == "auto":
-                        auto = True
-                    elif w in ("multiple", "prefix", "variant"):
-                        cc.word() if w in ("prefix", "variant") else None
-                    elif w is None:
-                        break
-                for sub in child.block:
-                    sc = self.cursor(sub)
-                    if sc.keyword("attribute"):
-                        layers.append(self.layer_attribute(sc, sub, name, group))
-                if auto:
-                    layers.append({"autoGroup": group})
-            elif kw == "if":
-                cond = self.expr(cc.rest().removesuffix(":"), child, const(False))
-                img = self.layer_image(Cursor(""), child, None)
-                if img:
-                    layers.append({"cond": [[cond, img]]})
-            elif kw in ("elif", "else"):
-                img = self.layer_image(Cursor(""), child, None)
-                if img and layers and "cond" in layers[-1]:
-                    cond = None
-                    if kw == "elif":
-                        cond = self.expr(cc.rest().removesuffix(":"), child, const(False))
-                    layers[-1]["cond"].append([cond, img])
-            elif kw == "at":
-                for item in _split_top(cc.rest()):
-                    at.append(self.transform_ref(item, child))
-        self.d.images[name] = {"layered": layers, "at": at}
-        self.d.stats["layeredimage"] += 1
-        return []
-
-    def layer_attribute(self, c: Cursor, line: Line, image: str, group: str | None
-                        ) -> dict[str, Any]:
-        attr = c.image_part() or ""
-        layer: dict[str, Any] = {"attr": attr, "group": group}
-        img = None
-        while not c.eol():
-            if c.peek('"') or c.peek("'"):
-                img = self.displayable_expr(const(c.string()), line)
-                continue
-            w = c.word()
-            if w == "default":
-                layer["default"] = True
-            elif w == "null":
-                layer["null"] = True
-            elif w in ("if_any", "if_all", "if_not"):
-                src = c.until({"if_any", "if_all", "if_not", "default", "null", "variant", "at"},
-                              ":")
-                try:
-                    val = pyexpr.literal(src)
-                    layer[w] = [val] if isinstance(val, str) else list(val)
-                except Unsupported:
-                    pass
-            elif w in ("variant", "at"):
-                c.until({"if_any", "if_all", "if_not", "default", "null"}, ":")
-            elif w is None:
-                break
-        if img is None and line.block:
-            img = self.layer_image(Cursor(""), line, None)
-        if img is None and not layer.get("null"):
-            # Ren'Py's default naming: <image>_<group>_<attribute>
-            img = {"ref": "_".join(x for x in (image.replace(" ", "_"), group, attr) if x)}
-        if img:
-            layer["img"] = img
-        return layer
-
-    def layer_image(self, c: Cursor, line: Line, default) -> dict[str, Any] | None:
-        s = c.string() if c.text else None
-        if s is not None:
-            return self.displayable_expr(const(s), line)
-        for child in line.block:
-            cc = self.cursor(child)
-            s = cc.string()
-            if s is not None:
-                return self.displayable_expr(const(s), child)
-            m = _CALL_LINE.match(child.text)
-            if m and m.group(1) in _DISPLAYABLE_CALLS:
-                e = self.expr(child.text, child)
-                return self.displayable_expr(e, child) if e else None
-        return default
-
-    def st_camera(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("camera")
-        c.word() if not c.peek("at") and not c.peek(":") else None
-        node: Node = {"op": "camera", "at": []}
-        if c.keyword("at"):
-            for item in _split_top(c.until(set(), ":")):
-                node["at"].append(self.transform_ref(item, line))
-        props: dict[str, Any] = {}
-        for child in line.block:
-            props.update(_atl_props(child.text))
-        if props:
-            node["at"].append({"props": props})
-        return [node]
-
-    def st_transform(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("transform")
-        name = c.word()
-        props: dict[str, Any] = {}
-        for child in line.block:
-            props.update(_atl_props(child.text))
-        if name:
-            self.d.transforms[name] = props
-        return []
-
-    # visual statements -------------------------------------------------------------
-
-    def image_spec(self, c: Cursor, line: Line) -> dict[str, Any]:
-        if c.keyword("expression"):
-            e = self.expr(c.until(_SHOW_KEYWORDS), line)
-            return {"expr": e}
-        parts: list[str] = []
-        while True:
-            save = c.pos
-            p = c.image_part()
-            if p is None:
-                break
-            if p in _SHOW_KEYWORDS:
-                c.pos = save
-                break
-            parts.append(p)
-        if not parts:
-            raise c.error("ожидалось имя изображения")
-        return {"name": parts}
-
-    def show_clauses(self, c: Cursor, line: Line, node: Node) -> None:
-        node.setdefault("at", [])
-        node.setdefault("with", None)
-        while not c.eol():
-            if c.keyword("as"):
-                node["as"] = c.image_part()
-            elif c.keyword("at"):
-                for item in _split_top(c.until(_SHOW_KEYWORDS - {"at"}, ":")):
-                    node["at"].append(self.transform_ref(item, line))
-            elif c.keyword("behind"):
-                node["behind"] = [b.strip() for b in c.until(_SHOW_KEYWORDS, ":").split(",")]
-            elif c.keyword("onlayer"):
-                node["layer"] = c.word()
-            elif c.keyword("zorder"):
-                node["zorder"] = self.expr(c.until(_SHOW_KEYWORDS, ":"), line)
-            elif c.keyword("with"):
-                node["with"] = self.transition(c.until(set(), ":"), line)
-            elif c.char(":"):
-                props: dict[str, Any] = {}
-                for child in line.block:
-                    props.update(_atl_props(child.text))
-                if props:
-                    node["at"].append({"props": props})
-            else:
-                self.d.warn("Не разобран фрагмент show/scene", f"{self.where(line)}: {c.rest()}")
-                break
-
-    def transform_ref(self, source: str, line: Line) -> dict[str, Any]:
-        source = source.strip()
-        if source in POSITIONS:
-            return {"pos": source}
-        if source in self.d.transforms:
-            return {"props": self.d.transforms[source], "name": source}
-        e = self.expr(source, line)
-        if e and e["k"] == "call":
-            fname = _dotted_name(e["f"])
-            if fname in ("Position", "Transform"):
-                return {"props": _static_props(e["kw"])}
-            if fname in ("Shake", "SnoopyShake"):
-                args = [_const(a) for a in e["a"]]
-                return {"effect": "shake", "d": args[1] if len(args) > 1 else 0.5,
-                        "dist": _const(e["kw"].get("dist")) or 20}
-            if fname in self.d.transforms:
-                return {"props": self.d.transforms[fname], "name": fname}
-        if e and e["k"] == "name" and e["id"] not in self.d.transforms:
-            # transform defined later in another file; the player resolves it by name
-            return {"name": e["id"]}
-        self.d.warn("Неизвестная трансформация", f"{self.where(line)}: {source}")
-        return {"name": source}
-
-    def st_scene(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("scene")
-        node: Node = {"op": "scene", "img": None}
-        if c.keyword("onlayer"):
-            node["layer"] = c.word()
-        if not c.eol() and not c.peek("with") and not c.peek("at"):
-            node["img"] = self.image_spec(c, line)
-        self.show_clauses(c, line, node)
-        self.d.stats["scene"] += 1
-        return [node]
-
-    def st_show(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("show")
-        if c.keyword("screen"):
-            self.d.warn("Не поддерживается: screen", self.where(line))
-            return []
-        if c.keyword("text"):
-            text = c.string()
-            if text is not None:
-                node: Node = {"op": "show", "img": {"text": text}}
-            else:
-                node = {"op": "show", "img": {"textExpr": self.expr(c.until(_SHOW_KEYWORDS), line,
-                                                                     const(""))}}
-            self.show_clauses(c, line, node)
-            return [node]
-        node = {"op": "show", "img": self.image_spec(c, line)}
-        self.show_clauses(c, line, node)
-        self.d.stats["show"] += 1
-        return [node]
-
-    def st_hide(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("hide")
-        if c.keyword("screen"):
-            return []
-        spec = self.image_spec(c, line)
-        node: Node = {"op": "hide", "tag": spec.get("name", [""])[0]}
-        self.show_clauses(c, line, node)
-        node.pop("at", None)
-        return [node]
-
-    def st_with(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("with")
-        return [{"op": "with", "t": self.transition(c.rest(), line)}]
-
-    def transition(self, source: str, line: Line) -> dict[str, Any] | None:
-        source = source.strip()
-        if source in ("None", ""):
-            return None
-        if source in self.d.transitions:
-            return self.d.transitions[source]
-        if source in TRANSITIONS:
-            return TRANSITIONS[source]
-        e = self.expr(source, line)
-        return self.transition_expr(e) if e else TRANSITIONS["dissolve"]
-
-    def transition_expr(self, e: Expr) -> dict[str, Any] | None:
-        if e["k"] == "const" and e["v"] is None:
-            return None
-        if e["k"] == "name":
-            return self.d.transitions.get(e["id"]) or TRANSITIONS.get(e["id"]) or {
-                "t": "ref", "name": e["id"]}
-        if e["k"] == "call":
-            fname = _dotted_name(e["f"])
-            args = [_const(a) for a in e["a"]]
-            kw = {k: _const(v) for k, v in e["kw"].items()}
-            nums = [a for a in args if isinstance(a, (int, float))]
-            if fname == "Fade":
-                out = nums[0] if nums else 0.5
-                hold = nums[1] if len(nums) > 2 else 0.0
-                fin = nums[2] if len(nums) > 2 else (nums[1] if len(nums) > 1 else out)
-                return {"t": "fade", "out": out, "hold": hold, "in": fin,
-                        "color": kw.get("color") or "#000000"}
-            if fname in ("Shake", "SnoopyShake"):
-                return {"t": "punch", "dir": "h", "d": nums[0] if nums else 0.5}
-            if fname in ("MoveTransition", "Move"):
-                return {"t": "move", "d": nums[0] if nums else 0.5}
-            if fname in TRANSITIONS:
-                return TRANSITIONS[fname]
-            return {"t": "dissolve", "d": nums[0] if nums else kw.get("time", 0.5) or 0.5}
-        return TRANSITIONS["dissolve"]
-
-    # audio ------------------------------------------------------------------------
-
-    def audio_files(self, c: Cursor, line: Line) -> list[Expr]:
-        src = c.until({"fadein", "fadeout", "loop", "noloop", "if_changed", "volume", "channel"})
-        e = self.expr(src, line)
-        if e is None:
-            return []
-        if e["k"] in ("list", "tuple"):
-            return e["v"]
-        return [e]
-
-    def st_play(self, line: Line, op: str = "play") -> list[Node]:
-        c = self.cursor(line)
-        c.keyword(op)
-        ch = c.word() or "music"
-        node: Node = {"op": op, "ch": ch, "files": self.audio_files(c, line)}
-        while not c.eol():
-            if c.keyword("fadein"):
-                node["fadein"] = _num(c.number())
-            elif c.keyword("fadeout"):
-                node["fadeout"] = _num(c.number())
-            elif c.keyword("loop"):
-                node["loop"] = True
-            elif c.keyword("noloop"):
-                node["loop"] = False
-            elif c.keyword("if_changed"):
-                node["ifChanged"] = True
-            elif c.keyword("volume"):
-                node["volume"] = _num(c.number())
-            else:
-                c.rest()
-        self.d.stats["audio"] += 1
-        return [node]
-
-    def st_queue(self, line: Line) -> list[Node]:
-        return self.st_play(line, "queue")
-
-    def st_stop(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("stop")
-        node: Node = {"op": "stop", "ch": c.word() or "music"}
-        if c.keyword("fadeout"):
-            node["fadeout"] = _num(c.number())
-        return [node]
-
-    def st_voice(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("voice")
-        if c.keyword("sustain"):
-            return [{"op": "voice", "sustain": True}]
-        e = self.expr(c.rest(), line)
-        return [{"op": "voice", "file": e}] if e else []
-
-    # flow ---------------------------------------------------------------------------
-
-    def st_jump(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("jump")
-        if c.keyword("expression"):
-            return [{"op": "jump", "expr": self.expr(c.rest(), line, const(""))}]
-        return [{"op": "jump", "target": self.label_ref(c.label_name() or "")}]
-
-    def st_call(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("call")
-        if c.keyword("screen"):
-            self.d.warn("Не поддерживается: call screen", self.where(line))
-            return []
-        if c.keyword("expression"):
-            node: Node = {"op": "call", "expr": self.expr(c.until({"pass", "from"}), line,
-                                                             const(""))}
-            c.keyword("pass")
-        else:
-            node = {"op": "call", "target": self.label_ref(c.label_name() or "")}
-        args = self.call_args(c, line)
-        if args:
-            node["args"] = args
-        return [node]
-
-    def st_return(self, line: Line) -> list[Node]:
-        return [{"op": "return"}]
-
-    def st_pass(self, line: Line) -> list[Node]:
-        return []
-
-    def st_pause(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("pause")
-        rest = c.rest()
-        return [{"op": "pause", "d": self.expr(rest, line) if rest else None}]
-
-    def st_while(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("while")
-        cond = c.rest().removesuffix(":").strip()
-        return [{"op": "while", "c": self.expr(cond, line, const(False)),
-                 "body": self.block(line.block)}]
-
-    def st_if(self, line: Line) -> list[Node]:
-        branches, _ = self.if_chain([line], 0)
-        return [{"op": "if", "branches": branches}]
-
-    def st_window(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("window")
-        mode = c.word()
-        return [{"op": "window", "mode": mode}] if mode in ("show", "hide") else []
-
-    def st_nvl(self, line: Line) -> list[Node]:
-        c = self.cursor(line)
-        c.keyword("nvl")
-        action = c.word()
-        return [{"op": "nvl", "a": action}] if action in ("clear", "show", "hide") else []
-
-    def st_menu(self, line: Line) -> list[Node]:
-        node: Node = {"op": "menu", "items": [], "say": None}
-        head = self.cursor(line)
-        head.keyword("menu")
-        name = head.label_name()
-        out: list[Node] = []
-        if name:
-            out.append({"op": "label", "name": self.label_ref(name)})
-        for child in line.block:
-            c = self.cursor(child)
-            if c.keyword("set"):
-                node["set"] = self.expr(c.rest(), child)
-                continue
-            if c.keyword("with"):
-                continue
-            text = c.string()
-            if text is not None and child.text.rstrip().endswith(":"):
-                cond = None
-                if c.keyword("if"):
-                    cond = self.expr(c.rest().removesuffix(":").strip(), child, const(True))
-                elif c.peek("("):
-                    c.until({"if"}, ":")
-                    if c.keyword("if"):
-                        cond = self.expr(c.rest().removesuffix(":").strip(), child, const(True))
-                node["items"].append({"text": text, "if": cond, "body": self.block(child.block)})
-                continue
-            say = self.say(child)
-            if say:
-                node["say"] = say[0]
-            else:
-                self.d.warn("Не разобран пункт меню", f"{self.where(child)}: {child.text[:60]}")
-        self.d.stats["menu"] += 1
-        return out + [node]
-
-    # say ------------------------------------------------------------------------------
-
-    def say(self, line: Line) -> list[Node] | None:
-        c = self.cursor(line)
-        who: str | None = None
-        who_str: str | None = None
-        attrs: list[str] = []
-        first = c.string()
-        if first is not None:
-            second = c.string() if not c.eol() else None
-            if second is not None:
-                who_str, what = first, second
-            else:
-                what = first
-        else:
-            who = c.dotted()
-            if who is None:
-                return None
-            while True:
-                save = c.pos
-                if c.string_raw() is not None:
-                    c.pos = save
-                    break
-                p = c.image_part() or (("@" if c.char("@") else None))
-                if p is None:
-                    c.pos = save
-                    break
-                if p != "@":
-                    attrs.append(p)
-            what = c.string()
-            if what is None:
-                return None
-        node: Node = {"op": "say", "what": what}
-        if who and who != "narrator":
-            node["who"] = who
-        if who_str is not None:
-            node["whoStr"] = who_str
-        if attrs:
-            node["attrs"] = attrs
-        while not c.eol():
-            if c.keyword("with"):
-                node["with"] = self.transition(c.rest(), line)
-            elif c.keyword("nointeract"):
-                node["interact"] = False
-            elif c.keyword("id"):
-                c.word()
-            elif c.char("("):
-                c.pos -= 1
-                c.until({"with", "nointeract", "id"})
-            else:
-                c.rest()
-        self.d.stats["say"] += 1
-        return [node]
-
-
-_SHOW_KEYWORDS = {"at", "as", "behind", "onlayer", "with", "zorder"}
-_NUMBER_LINE = re.compile(r"^\d+(\.\d*)?$|^\.\d+$")
-_CALL_LINE = re.compile(r"^([A-Za-z_][\w.]*)\s*\(")
-_DISPLAYABLE_CALLS = {"Movie", "Solid", "Transform", "Composite", "LiveComposite", "Fixed",
-                      "ConditionSwitch", "Image", "im.Scale", "im.FactorScale", "im.Flip",
-                      "im.Composite", "im.Crop", "im.Grayscale", "im.Sepia", "Frame", "Flatten"}
-_MEDIA_EXTS = {"png", "jpg", "jpeg", "webp", "gif", "bmp", "avif", "ogg", "mp3", "wav", "opus",
-               "flac", "webm", "ogv", "mp4", "mkv", "avi", "m4a"}
-
-
-def _dedent(source: str) -> str:
-    import textwrap
-    return textwrap.dedent(source)
-
-
-def _parse_py(source: str, mode: str = "exec") -> ast.AST:
-    # decompiled scripts are full of "\{" in plain strings: don't spam SyntaxWarning
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        return ast.parse(_dedent(source), mode=mode)
-
-
-def _dotted_name(e: Expr) -> str:
-    if e["k"] == "name":
-        return e["id"]
-    if e["k"] == "attr":
-        return f"{_dotted_name(e['o'])}.{e['a']}"
-    return ""
-
-
-def _assign_name(t: ast.AST) -> str | None:
-    if isinstance(t, ast.Name):
-        return t.id
-    if isinstance(t, ast.Attribute):
-        inner = _assign_name(t.value)
-        return f"{inner}.{t.attr}" if inner else None
-    return None
-
-
-def _const(e: Expr | None) -> Any:
-    if e is None:
-        return None
-    if e.get("k") == "const":
-        return e["v"]
-    if e.get("k") in ("tuple", "list"):
-        return [_const(x) for x in e["v"]]
-    if e.get("k") == "unary" and e["op"] == "-":
-        v = _const(e["v"])
-        return -v if isinstance(v, (int, float)) else None
-    return None
-
-
-def _num(s: str | None) -> float | None:
-    try:
-        return float(s) if s is not None else None
-    except ValueError:
-        return None
-
-
-def _static_props(kw: dict[str, Expr]) -> dict[str, Any]:
-    props = {}
-    for k, v in kw.items():
-        if k in POSITION_PROPS:
-            val = _const(v)
-            if val is not None:
-                props[k] = val
-    return props
-
-
-def _atl_props(text: str) -> dict[str, Any]:
-    """Extract static `prop value` pairs from one ATL line, ignoring timing."""
-    tokens = text.replace(",", " ").split()
-    props: dict[str, Any] = {}
-    i = 0
-    while i < len(tokens) - 1:
-        key = tokens[i]
-        if key in POSITION_PROPS:
-            raw = tokens[i + 1]
-            try:
-                props[key] = ast.literal_eval(raw)
-            except (ValueError, SyntaxError):
-                if raw.startswith("(") and i + 2 < len(tokens):
-                    try:
-                        props[key] = list(ast.literal_eval(raw + "," + tokens[i + 2]))
-                        i += 1
-                    except (ValueError, SyntaxError):
-                        pass
-            i += 2
-        else:
-            i += 1
-    return props
-
-
-def _split_top(source: str) -> list[str]:
-    parts, depth, cur = [], 0, []
-    for ch in source:
-        if ch in "([{":
-            depth += 1
-        elif ch in ")]}":
-            depth -= 1
-        if ch == "," and depth == 0:
-            parts.append("".join(cur))
-            cur = []
-        else:
-            cur.append(ch)
-    if "".join(cur).strip():
-        parts.append("".join(cur))
-    return [p.strip() for p in parts if p.strip()]
-
-
-def _jump_or_call(op: str, target: Expr) -> Node:
-    if target.get("k") == "const":
-        return {"op": op, "target": target["v"]}
-    return {"op": op, "expr": target}
+"""Ren'Py script (.rpy) → PGVN IR."""
+
+import ast
+import re
+import warnings
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any
+
+from app.converter import pyexpr
+from app.converter.pyexpr import Expr, Stmt, Unsupported, const
+from app.converter.rpy_lexer import Cursor, Line, ParseError, parse_tree
+
+Node = dict[str, Any]
+
+TRANSITIONS: dict[str, dict[str, Any]] = {
+    "dissolve": {"t": "dissolve", "d": 0.5},
+    "fade": {"t": "fade", "out": 0.5, "hold": 0.0, "in": 0.5, "color": "#000000"},
+    "pixellate": {"t": "dissolve", "d": 1.0},
+    "move": {"t": "move", "d": 0.5},
+    "ease": {"t": "move", "d": 0.5},
+    "vpunch": {"t": "punch", "dir": "v", "d": 0.3},
+    "hpunch": {"t": "punch", "dir": "h", "d": 0.3},
+    "blinds": {"t": "dissolve", "d": 1.0},
+    "squares": {"t": "dissolve", "d": 1.0},
+    "wipeleft": {"t": "wipe", "dir": "left", "d": 1.0},
+    "wiperight": {"t": "wipe", "dir": "right", "d": 1.0},
+    "wipeup": {"t": "wipe", "dir": "up", "d": 1.0},
+    "wipedown": {"t": "wipe", "dir": "down", "d": 1.0},
+    "zoomin": {"t": "dissolve", "d": 0.5},
+    "zoomout": {"t": "dissolve", "d": 0.5},
+}
+for _side in ("left", "right", "top", "bottom"):
+    for _kind in ("movein", "moveout", "easein", "easeout", "slide", "slideaway",
+                  "push", "irisin", "irisout"):
+        TRANSITIONS.setdefault(f"{_kind}{_side}", {"t": "slide", "dir": _side, "d": 0.5,
+                                                    "kind": _kind})
+TRANSITION_CLASSES = {"Dissolve", "Fade", "ImageDissolve", "AlphaDissolve", "Pixellate",
+                      "MoveTransition", "CropMove", "PushMove", "ComposeTransition",
+                      "MultipleTransition", "Move"}
+
+POSITIONS = {"left", "right", "center", "truecenter", "topleft", "topright", "top",
+             "offscreenleft", "offscreenright", "default", "reset"}
+POSITION_PROPS = {"xpos", "ypos", "xanchor", "yanchor", "xalign", "yalign", "xcenter",
+                  "ycenter", "zoom", "xzoom", "yzoom", "alpha", "rotate", "xoffset", "yoffset",
+                  "align", "pos", "anchor", "xysize", "size"}
+CHANNELS = {"music", "sound", "voice", "audio", "movie"}
+SKIP_BLOCKS = {"screen", "style", "translate", "testcase"}
+BUILTIN_CHARACTERS = {"narrator", "centered", "vcentered", "extend", "nvl", "adv", "name_only"}
+
+
+@dataclass
+class ScriptData:
+    characters: dict[str, dict[str, Any]] = field(default_factory=dict)
+    images: dict[str, dict[str, Any]] = field(default_factory=dict)
+    transforms: dict[str, dict[str, Any]] = field(default_factory=dict)
+    transitions: dict[str, dict[str, Any] | None] = field(default_factory=dict)
+    audio: dict[str, str] = field(default_factory=dict)
+    defaults: list[list[Any]] = field(default_factory=list)
+    init_code: list[Stmt] = field(default_factory=list)  # defines + init python, in order
+    gui: dict[str, Any] = field(default_factory=dict)
+    channels: dict[str, dict[str, Any]] = field(default_factory=dict)
+    config: dict[str, Any] = field(default_factory=dict)
+    modules: dict[str, list[Node]] = field(default_factory=dict)  # file -> labels
+    warnings: Counter = field(default_factory=Counter)
+    warning_examples: dict[str, str] = field(default_factory=dict)
+    stats: Counter = field(default_factory=Counter)
+
+    def warn(self, kind: str, where: str = "") -> None:
+        self.warnings[kind] += 1
+        if where and kind not in self.warning_examples:
+            self.warning_examples[kind] = where
+
+
+class RpyParser:
+    def __init__(self, data: ScriptData, filename: str):
+        self.d = data
+        self.filename = filename
+        self.global_label = ""
+
+    def label_ref(self, name: str) -> str:
+        """Resolve `.local` label names against the enclosing global label."""
+        return self.global_label + name if name.startswith(".") else name
+
+    # --- helpers -------------------------------------------------------------
+
+    def where(self, line: Line) -> str:
+        return f"{self.filename}:{line.lineno}"
+
+    def cursor(self, line: Line, text: str | None = None) -> Cursor:
+        return Cursor(line.text if text is None else text, self.filename, line.lineno)
+
+    def expr(self, source: str, line: Line, default: Expr | None = None) -> Expr | None:
+        try:
+            return pyexpr.parse_expr(source)
+        except Unsupported as e:
+            self.d.warn(f"Выражение: {e}", self.where(line))
+            return default
+
+    def python(self, source: str, line: Line) -> list[Stmt]:
+        """Translate python code statement by statement, skipping unsupported ones."""
+        try:
+            tree = _parse_py(source)
+        except SyntaxError as e:
+            self.d.warn(f"Python: синтаксическая ошибка ({e.msg})", self.where(line))
+            return []
+        out: list[Stmt] = []
+        for node in tree.body:
+            try:
+                out.extend(pyexpr.stmt(node))
+            except Unsupported as e:
+                self.d.warn(f"Python: {e}", f"{self.filename}:{line.lineno + node.lineno}")
+        return out
+
+    # --- top level -------------------------------------------------------------
+
+    def parse(self, source: str) -> None:
+        tree = parse_tree(source, self.filename)
+        labels: list[Node] = []
+        current: Node | None = None
+        for line in tree:
+            c = self.cursor(line)
+            first = c.peek_word()
+            if first == "label":
+                name, params = self.label_header(line)
+                if not name.startswith("."):
+                    self.global_label = name
+                current = {"name": self.label_ref(name), "body": self.block(line.block)}
+                if params:
+                    current["params"] = params
+                labels.append(current)
+                continue
+            nodes = self.statement(line, top_level=True)
+            if nodes and current is not None:
+                current["body"].extend(nodes)
+            elif nodes:
+                # statements before any label run on fall-through into the first label
+                labels.append(current := {"name": f"_{self.filename}_{line.lineno}",
+                                          "body": nodes})
+        self.d.modules[self.filename] = labels
+
+    def block(self, lines: list[Line]) -> list[Node]:
+        out: list[Node] = []
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            word = Cursor(line.text).peek_word()
+            if word == "if":
+                branches, i = self.if_chain(lines, i)
+                out.append({"op": "if", "branches": branches})
+                continue
+            if word == "label":
+                # a label inside a block is an entry point in the middle of the flow:
+                # keep a marker the player can jump to and inline the label's block
+                name, params = self.label_header(line)
+                if not name.startswith("."):
+                    self.global_label = name
+                marker: Node = {"op": "label", "name": self.label_ref(name)}
+                if params:
+                    marker["params"] = params
+                out.append(marker)
+                out.extend(self.block(line.block))
+                i += 1
+                continue
+            out.extend(self.statement(line))
+            i += 1
+        return out
+
+    def label_header(self, line: Line) -> tuple[str, list[list[Any]] | None]:
+        c = self.cursor(line)
+        c.keyword("label")
+        name = c.label_name()
+        if not name:
+            raise c.error("ожидалось имя метки")
+        params = None
+        if c.peek("("):
+            sig = c.until(set(), ":")
+            try:
+                fn = _parse_py(f"def _f{sig}: pass").body[0]
+                args = fn.args
+                defaults = [None] * (len(args.args) - len(args.defaults)) + list(args.defaults)
+                params = [[a.arg, pyexpr.expr(d) if d is not None else None]
+                          for a, d in zip(args.args, defaults)]
+            except (SyntaxError, Unsupported):
+                self.d.warn("Не разобраны параметры метки", self.where(line))
+        return name, params
+
+    def call_args(self, c: Cursor, line: Line) -> dict[str, Any] | None:
+        if not c.peek("("):
+            return None
+        src = c.until({"from"})
+        try:
+            call = _parse_py(f"_f{src}", mode="eval").body
+            return {"a": [pyexpr.expr(a) for a in call.args],
+                    "kw": {k.arg: pyexpr.expr(k.value) for k in call.keywords}}
+        except (SyntaxError, Unsupported, AttributeError):
+            self.d.warn("Не разобраны аргументы call", self.where(line))
+            return None
+
+    def if_chain(self, lines: list[Line], i: int) -> tuple[list[Node], int]:
+        branches: list[Node] = []
+        while i < len(lines):
+            line = lines[i]
+            c = self.cursor(line)
+            kw = c.word()
+            if kw in ("if", "elif") and (kw == "if") == (not branches):
+                cond = c.rest().removesuffix(":").strip()
+                branches.append({"c": self.expr(cond, line, const(False)),
+                                 "body": self.block(line.block)})
+            elif kw == "else" and branches:
+                branches.append({"c": None, "body": self.block(line.block)})
+                i += 1
+                break
+            else:
+                break
+            i += 1
+        return branches, i
+
+    # --- statements ----------------------------------------------------------------
+
+    def statement(self, line: Line, top_level: bool = False) -> list[Node]:
+        text = line.text
+        if text.startswith("$"):
+            return self.dollar(text[1:].strip(), line)
+        c = self.cursor(line)
+        word = c.peek_word()
+        handler = getattr(self, f"st_{word}", None) if word else None
+        if handler and not (word in ("centered", "extend", "narrator", "nvl") and self._is_say(line)):
+            try:
+                return handler(line) or []
+            except ParseError as e:
+                # one odd statement (custom syntax, typo) must not drop the whole file
+                self.d.warn(f"Не разобран оператор {word}", f"{e.filename}:{e.lineno}")
+                return []
+        if word in SKIP_BLOCKS:
+            if word not in ("style", "translate"):
+                self.d.warn(f"Не поддерживается: {word}", self.where(line))
+            return []
+        say = self.say(line)
+        if say is not None:
+            return say
+        self.d.warn("Неизвестный оператор", f"{self.where(line)}: {text[:60]}")
+        return []
+
+    def _is_say(self, line: Line) -> bool:
+        c = self.cursor(line)
+        c.word()
+        while c.image_part() is not None and not c.peek('"') and not c.peek("'"):
+            pass
+        return c.string_raw() is not None or c.peek('"') or c.peek("'")
+
+    def dollar(self, code: str, line: Line) -> list[Node]:
+        stmts = self.python(code, line)
+        if len(stmts) == 1 and stmts[0]["op"] == "eval":
+            special = self.renpy_call(stmts[0]["e"], line)
+            if special is not None:
+                return special
+        return [{"op": "exec", "code": stmts}] if stmts else []
+
+    def renpy_call(self, e: Expr, line: Line) -> list[Node] | None:
+        """Turn common renpy.* calls into native script nodes."""
+        if e.get("k") != "call":
+            return None
+        fname = _dotted_name(e["f"])
+        args, kw = e["a"], e["kw"]
+        if fname == "renpy.pause":
+            return [{"op": "pause", "d": args[0] if args else kw.get("delay")}]
+        if fname == "renpy.jump" and args:
+            return [_jump_or_call("jump", args[0])]
+        if fname == "renpy.call" and args:
+            return [_jump_or_call("call", args[0])]
+        if fname in ("renpy.music.play", "renpy.sound.play", "renpy.play"):
+            ch = "sound" if fname != "renpy.music.play" else "music"
+            if "channel" in kw and kw["channel"].get("k") == "const":
+                ch = kw["channel"]["v"]
+            if not args:
+                return None
+            node = {"op": "play", "ch": ch, "files": [args[0]], "loop": _const(kw.get("loop"))}
+            for key in ("fadein", "fadeout"):
+                if key in kw:
+                    node[key] = _const(kw[key])
+            return [node]
+        if fname in ("renpy.music.stop", "renpy.sound.stop"):
+            ch = "music" if fname == "renpy.music.stop" else "sound"
+            if "channel" in kw and kw["channel"].get("k") == "const":
+                ch = kw["channel"]["v"]
+            return [{"op": "stop", "ch": ch, "fadeout": _const(kw.get("fadeout"))}]
+        if fname == "renpy.show" and args and args[0].get("k") == "const":
+            return [{"op": "show", "img": {"name": str(args[0]["v"]).split()}, "at": [],
+                     "with": None}]
+        if fname == "renpy.hide" and args and args[0].get("k") == "const":
+            return [{"op": "hide", "tag": str(args[0]["v"]).split()[0]}]
+        if fname == "renpy.scene":
+            return [{"op": "scene", "img": None, "at": [], "with": None}]
+        if fname == "renpy.with_statement" and args:
+            return [{"op": "with", "t": self.transition_expr(args[0])}]
+        return None
+
+    # init / python ----------------------------------------------------------------
+
+    def st_init(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("init")
+        c.number()
+        if c.keyword("offset"):
+            return []
+        if c.keyword("python") or c.keyword("early"):
+            c.keyword("python")
+            self.init_python(line.block_source(), line)
+            return []
+        for child in line.block:
+            for node in self.statement(child, top_level=True):
+                if node["op"] == "exec":
+                    self.d.init_code.extend(node["code"])
+                else:
+                    self.d.warn("Оператор сцены внутри init", self.where(child))
+        return []
+
+    def st_python(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("python")
+        if c.keyword("early"):
+            self.init_python(line.block_source(), line)
+            return []
+        code = self.python(line.block_source(), line)
+        return [{"op": "exec", "code": code}] if code else []
+
+    def st_rpy(self, line: Line) -> list[Node]:
+        return []
+
+    def init_python(self, source: str, line: Line) -> None:
+        try:
+            tree = _parse_py(source)
+        except SyntaxError as e:
+            self.d.warn(f"Python: синтаксическая ошибка ({e.msg})", self.where(line))
+            return
+        for node in tree.body:
+            if (isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)
+                    and ast.unparse(node.value.func) == "renpy.music.register_channel"):
+                self.register_channel(node.value)
+                continue
+            if isinstance(node, ast.Assign) and len(node.targets) == 1:
+                tgt = node.targets[0]
+                name = _assign_name(tgt)
+                if name and self.define(name, ast.get_source_segment(_dedent(source), node.value)
+                                        or ast.unparse(node.value), line):
+                    continue
+            if (isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)
+                    and ast.unparse(node.value.func) == "gui.init"
+                    and len(node.value.args) == 2):
+                try:
+                    self.d.gui["resolution"] = [ast.literal_eval(a) for a in node.value.args]
+                except ValueError:
+                    pass
+                continue
+            try:
+                self.d.init_code.extend(pyexpr.stmt(node))
+            except Unsupported as e:
+                self.d.warn(f"init python: {e}", f"{self.filename}:{line.lineno + node.lineno}")
+
+    def register_channel(self, call: ast.Call) -> None:
+        args = list(call.args) + [None] * 3
+        kw = {k.arg: k.value for k in call.keywords}
+
+        def lit(node, default=None):
+            try:
+                return ast.literal_eval(node) if node is not None else default
+            except ValueError:
+                return default
+
+        name = lit(args[0])
+        if isinstance(name, str):
+            self.d.channels[name] = {"mixer": lit(kw.get("mixer", args[1]), "sfx"),
+                                     "loop": bool(lit(kw.get("loop", args[2]), False))}
+
+    # define / default / image / transform -------------------------------------------
+
+    def st_define(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("define")
+        c.number()
+        name = c.dotted()
+        if not name:
+            raise c.error("ожидалось имя")
+        op = "="
+        for candidate in ("+=", "|=", "="):
+            if c.char(candidate):
+                op = candidate
+                break
+        value = c.rest()
+        if op != "=":
+            self.d.warn("define с += не поддерживается", self.where(line))
+            return []
+        self.define(name, value, line)
+        return []
+
+    def define(self, name: str, value: str, line: Line) -> bool:
+        """Handle `define name = value`. Returns False if value was not understood."""
+        head, _, attr = name.partition(".")
+        if head in ("config", "gui", "build", "preferences", "style", "_preferences"):
+            if attr:
+                try:
+                    (self.d.config if head == "config" else self.d.gui)[attr] = pyexpr.literal(value)
+                except Unsupported:
+                    pass
+            return True
+        if head == "audio" and attr:
+            try:
+                self.d.audio[attr] = str(pyexpr.literal(value))
+            except Unsupported:
+                pass
+            return True
+        if head == "store":
+            name = attr
+        e = self.expr(value, line)
+        if e is None:
+            return False
+        if "." in name:
+            # e.g. persistent.flag = ... : a plain assignment at init time
+            self.d.init_code.append({"op": "set", "t": pyexpr.parse_expr(name), "v": e})
+            return True
+        if e["k"] == "call":
+            fname = _dotted_name(e["f"])
+            if fname in ("Character", "DynamicCharacter", "ADVCharacter", "NVLCharacter"):
+                self.d.characters[name] = self.character(fname, e, line)
+                return True
+            if fname in TRANSITION_CLASSES or fname in TRANSITIONS:
+                self.d.transitions[name] = self.transition_expr(e)
+                return True
+            if fname in ("Transform", "Position"):
+                self.d.transforms[name] = _static_props(e["kw"])
+                return True
+        if e["k"] == "name" and e["id"] in TRANSITIONS:
+            self.d.transitions[name] = TRANSITIONS[e["id"]]
+            return True
+        if e["k"] == "name" and e["id"] in self.d.characters:
+            self.d.characters[name] = dict(self.d.characters[e["id"]])
+            return True
+        self.d.init_code.append({"op": "set", "t": {"k": "name", "id": name}, "v": e})
+        return True
+
+    def character(self, fname: str, e: Expr, line: Line) -> dict[str, Any]:
+        kw = e["kw"]
+        char: dict[str, Any] = {}
+        kind = kw.get("kind")
+        if kind and kind.get("k") == "name":
+            if kind["id"] == "nvl":
+                char["nvl"] = True
+            elif kind["id"] in self.d.characters:
+                char.update(self.d.characters[kind["id"]])
+        if fname == "NVLCharacter":
+            char["nvl"] = True
+        args = e["a"]
+        if args:
+            name = args[0]
+            if fname == "DynamicCharacter" or (kw.get("dynamic") or {}).get("v"):
+                char["nameExpr"] = (self.expr(name["v"], line, const(""))
+                                    if name.get("k") == "const" and isinstance(name["v"], str)
+                                    else name)
+            elif name.get("k") == "const":
+                char["name"] = name["v"]
+            else:
+                char["nameExpr"] = name
+        mapping = {"color": "color", "who_color": "color", "what_color": "whatColor",
+                   "what_prefix": "whatPrefix", "what_suffix": "whatSuffix",
+                   "who_prefix": "whoPrefix", "who_suffix": "whoSuffix", "image": "image",
+                   "what_italic": "whatItalic", "what_bold": "whatBold"}
+        for key, target in mapping.items():
+            v = kw.get(key)
+            if v is not None and v.get("k") == "const":
+                char[target] = v["v"]
+        return char
+
+    def st_default(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("default")
+        c.number()  # optional init priority
+        name = c.dotted()
+        if not name or not c.char("="):
+            raise c.error("ожидалось default имя = значение")
+        e = self.expr(c.rest(), line)
+        if e is not None:
+            self.d.defaults.append([name.removeprefix("store."), e])
+        return []
+
+    def st_image(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("image")
+        parts: list[str] = []
+        while (p := c.image_part()) is not None:
+            parts.append(p)
+        if not parts:
+            raise c.error("ожидалось имя изображения")
+        name = " ".join(parts)
+        if c.char("="):
+            img = self.displayable(c.rest(), line)
+        elif c.char(":"):
+            img = self.atl_image(line)
+        else:
+            raise c.error("ожидалось = или :")
+        if img is not None:
+            self.d.images[name] = img
+        return []
+
+    def displayable(self, source: str, line: Line) -> dict[str, Any] | None:
+        e = self.expr(source, line)
+        return self.displayable_expr(e, line) if e is not None else None
+
+    def displayable_expr(self, e: Expr, line: Line) -> dict[str, Any] | None:
+        if e["k"] == "const" and isinstance(e["v"], str):
+            s = e["v"]
+            if s.startswith("#"):
+                return {"color": s}
+            if "." in s and "/" in s or s.rsplit(".", 1)[-1].lower() in _MEDIA_EXTS:
+                return {"file": s}
+            return {"ref": s}
+        if e["k"] != "call":
+            self.d.warn("Изображение задано выражением", self.where(line))
+            return {"expr": e}
+        fname = _dotted_name(e["f"])
+        args, kw = e["a"], e["kw"]
+        if fname == "Solid" and args:
+            return {"color": _const(args[0])}
+        if fname in ("Movie",):
+            play = kw.get("play") or (args[0] if args else None)
+            return {"movie": _const(play)} if play else None
+        if fname == "ConditionSwitch":
+            pairs = []
+            for i in range(0, len(args) - 1, 2):
+                cond = args[i]
+                cexpr = (self.expr(cond["v"], line, const(False))
+                         if cond.get("k") == "const" and isinstance(cond["v"], str) else cond)
+                sub = self.displayable_expr(args[i + 1], line)
+                if sub:
+                    pairs.append([cexpr, sub])
+            return {"switch": pairs}
+        if fname in ("Composite", "LiveComposite", "im.Composite") and args:
+            size = _const(args[0])
+            layers = []
+            for i in range(1, len(args) - 1, 2):
+                pos = _const(args[i])
+                sub = self.displayable_expr(args[i + 1], line)
+                if sub and isinstance(pos, (list, tuple)):
+                    layers.append({"pos": list(pos), "img": sub})
+            return {"composite": layers, "size": list(size) if isinstance(size, (list, tuple))
+                    else None}
+        # wrappers: Transform("x.png", zoom=.5), im.Scale(...), im.Flip(...), etc.
+        for a in args:
+            sub = self.displayable_expr(a, line) if a.get("k") in ("const", "call") else None
+            if sub:
+                props = _static_props(kw)
+                if fname in ("im.Flip", "Flip") and (_const(kw.get("horizontal")) is True):
+                    props["xzoom"] = -1
+                if fname in ("im.Scale", "im.FactorScale") and len(args) >= 2:
+                    if fname == "im.FactorScale":
+                        props["zoom"] = _const(args[1])
+                    elif len(args) >= 3:
+                        props["size"] = [_const(args[1]), _const(args[2])]
+                if fname in ("im.Grayscale", "im.Sepia"):
+                    props["filter"] = "grayscale" if fname == "im.Grayscale" else "sepia"
+                if props:
+                    sub = {**sub, "props": {**sub.get("props", {}), **props}}
+                return sub
+        self.d.warn(f"Изображение {fname}() не поддерживается", self.where(line))
+        return None
+
+    def atl_image(self, line: Line) -> dict[str, Any] | None:
+        frames: list[dict[str, Any]] = []
+        props: dict[str, Any] = {}
+        repeat = self.atl_frames(line.block, frames, props)
+        if not frames:
+            self.d.warn("ATL-изображение без кадров", self.where(line))
+            return None
+        if len(frames) == 1:
+            img = dict(frames[0]["img"])
+        else:
+            img = {"frames": frames, "repeat": repeat}
+        if props:
+            img["props"] = {**img.get("props", {}), **props}
+        return img
+
+    def atl_frames(self, lines: list[Line], frames: list[dict[str, Any]],
+                   props: dict[str, Any]) -> bool:
+        """Collect displayable frames of an ATL block. Returns whether it repeats."""
+        repeat = False
+        for child in lines:
+            c = self.cursor(child)
+            word = c.peek_word()
+            if word in ("contains", "block", "parallel", "choice"):
+                if not frames or word == "block":
+                    repeat = self.atl_frames(child.block, frames, props) or repeat
+                continue
+            if word == "repeat":
+                repeat = True
+                continue
+            if word in ("pause",) or _NUMBER_LINE.match(child.text):
+                c.keyword("pause")
+                d = _num(c.number())
+                if frames and d is not None:
+                    frames[-1]["d"] = frames[-1].get("d", 0) + d
+                continue
+            if word in ("function", "on", "event", "time", "transform"):
+                continue
+            s = c.string()
+            if s is not None:
+                img = self.displayable_expr(const(s), child)
+                if img:
+                    frames.append({"img": img})
+                continue
+            m = _CALL_LINE.match(child.text)
+            if m and m.group(1) in _DISPLAYABLE_CALLS:
+                e = self.expr(child.text.split(" with ")[0], child)
+                img = self.displayable_expr(e, child) if e else None
+                if img:
+                    frames.append({"img": img})
+                continue
+            if m and not frames and not _atl_props(child.text):
+                # e.g. get_face_path("base"): an image computed by game code
+                e = self.expr(child.text, child)
+                if e is not None:
+                    self.d.warn("Изображение задано выражением", self.where(child))
+                    frames.append({"img": {"expr": e}})
+                continue
+            if not frames or not frames[-1].get("d"):
+                props.update(_atl_props(child.text))
+        return repeat
+
+    def st_layeredimage(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("layeredimage")
+        parts: list[str] = []
+        while (p := c.image_part()) is not None:
+            parts.append(p)
+        name = " ".join(parts)
+        layers: list[dict[str, Any]] = []
+        at: list[dict[str, Any]] = []
+        for child in line.block:
+            cc = self.cursor(child)
+            kw = cc.word()
+            if kw == "always":
+                img = self.layer_image(cc, child, None)
+                if img:
+                    layers.append({"always": img})
+            elif kw == "attribute":
+                layers.append(self.layer_attribute(cc, child, name, None))
+            elif kw == "group":
+                group = cc.word() or ""
+                auto = False
+                while not cc.eol():
+                    w = cc.word()
+                    if w == "auto":
+                        auto = True
+                    elif w in ("multiple", "prefix", "variant"):
+                        cc.word() if w in ("prefix", "variant") else None
+                    elif w is None:
+                        break
+                for sub in child.block:
+                    sc = self.cursor(sub)
+                    if sc.keyword("attribute"):
+                        layers.append(self.layer_attribute(sc, sub, name, group))
+                if auto:
+                    layers.append({"autoGroup": group})
+            elif kw == "if":
+                cond = self.expr(cc.rest().removesuffix(":"), child, const(False))
+                img = self.layer_image(Cursor(""), child, None)
+                if img:
+                    layers.append({"cond": [[cond, img]]})
+            elif kw in ("elif", "else"):
+                img = self.layer_image(Cursor(""), child, None)
+                if img and layers and "cond" in layers[-1]:
+                    cond = None
+                    if kw == "elif":
+                        cond = self.expr(cc.rest().removesuffix(":"), child, const(False))
+                    layers[-1]["cond"].append([cond, img])
+            elif kw == "at":
+                for item in _split_top(cc.rest()):
+                    at.append(self.transform_ref(item, child))
+        self.d.images[name] = {"layered": layers, "at": at}
+        self.d.stats["layeredimage"] += 1
+        return []
+
+    def layer_attribute(self, c: Cursor, line: Line, image: str, group: str | None
+                        ) -> dict[str, Any]:
+        attr = c.image_part() or ""
+        layer: dict[str, Any] = {"attr": attr, "group": group}
+        img = None
+        while not c.eol():
+            if c.peek('"') or c.peek("'"):
+                img = self.displayable_expr(const(c.string()), line)
+                continue
+            w = c.word()
+            if w == "default":
+                layer["default"] = True
+            elif w == "null":
+                layer["null"] = True
+            elif w in ("if_any", "if_all", "if_not"):
+                src = c.until({"if_any", "if_all", "if_not", "default", "null", "variant", "at"},
+                              ":")
+                try:
+                    val = pyexpr.literal(src)
+                    layer[w] = [val] if isinstance(val, str) else list(val)
+                except Unsupported:
+                    pass
+            elif w in ("variant", "at"):
+                c.until({"if_any", "if_all", "if_not", "default", "null"}, ":")
+            elif w is None:
+                break
+        if img is None and line.block:
+            img = self.layer_image(Cursor(""), line, None)
+        if img is None and not layer.get("null"):
+            # Ren'Py's default naming: <image>_<group>_<attribute>
+            img = {"ref": "_".join(x for x in (image.replace(" ", "_"), group, attr) if x)}
+        if img:
+            layer["img"] = img
+        return layer
+
+    def layer_image(self, c: Cursor, line: Line, default) -> dict[str, Any] | None:
+        s = c.string() if c.text else None
+        if s is not None:
+            return self.displayable_expr(const(s), line)
+        for child in line.block:
+            cc = self.cursor(child)
+            s = cc.string()
+            if s is not None:
+                return self.displayable_expr(const(s), child)
+            m = _CALL_LINE.match(child.text)
+            if m and m.group(1) in _DISPLAYABLE_CALLS:
+                e = self.expr(child.text, child)
+                return self.displayable_expr(e, child) if e else None
+        return default
+
+    def st_camera(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("camera")
+        c.word() if not c.peek("at") and not c.peek(":") else None
+        node: Node = {"op": "camera", "at": []}
+        if c.keyword("at"):
+            for item in _split_top(c.until(set(), ":")):
+                node["at"].append(self.transform_ref(item, line))
+        props: dict[str, Any] = {}
+        for child in line.block:
+            props.update(_atl_props(child.text))
+        if props:
+            node["at"].append({"props": props})
+        return [node]
+
+    def st_transform(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("transform")
+        name = c.word()
+        props: dict[str, Any] = {}
+        for child in line.block:
+            props.update(_atl_props(child.text))
+        if name:
+            self.d.transforms[name] = props
+        return []
+
+    # visual statements -------------------------------------------------------------
+
+    def image_spec(self, c: Cursor, line: Line) -> dict[str, Any]:
+        if c.keyword("expression"):
+            e = self.expr(c.until(_SHOW_KEYWORDS), line)
+            return {"expr": e}
+        parts: list[str] = []
+        while True:
+            save = c.pos
+            p = c.image_part()
+            if p is None:
+                break
+            if p in _SHOW_KEYWORDS:
+                c.pos = save
+                break
+            parts.append(p)
+        if not parts:
+            raise c.error("ожидалось имя изображения")
+        return {"name": parts}
+
+    def show_clauses(self, c: Cursor, line: Line, node: Node) -> None:
+        node.setdefault("at", [])
+        node.setdefault("with", None)
+        while not c.eol():
+            if c.keyword("as"):
+                node["as"] = c.image_part()
+            elif c.keyword("at"):
+                for item in _split_top(c.until(_SHOW_KEYWORDS - {"at"}, ":")):
+                    node["at"].append(self.transform_ref(item, line))
+            elif c.keyword("behind"):
+                node["behind"] = [b.strip() for b in c.until(_SHOW_KEYWORDS, ":").split(",")]
+            elif c.keyword("onlayer"):
+                node["layer"] = c.word()
+            elif c.keyword("zorder"):
+                node["zorder"] = self.expr(c.until(_SHOW_KEYWORDS, ":"), line)
+            elif c.keyword("with"):
+                node["with"] = self.transition(c.until(set(), ":"), line)
+            elif c.char(":"):
+                props: dict[str, Any] = {}
+                for child in line.block:
+                    props.update(_atl_props(child.text))
+                if props:
+                    node["at"].append({"props": props})
+            else:
+                self.d.warn("Не разобран фрагмент show/scene", f"{self.where(line)}: {c.rest()}")
+                break
+
+    def transform_ref(self, source: str, line: Line) -> dict[str, Any]:
+        source = source.strip()
+        if source in POSITIONS:
+            return {"pos": source}
+        if source in self.d.transforms:
+            return {"props": self.d.transforms[source], "name": source}
+        e = self.expr(source, line)
+        if e and e["k"] == "call":
+            fname = _dotted_name(e["f"])
+            if fname in ("Position", "Transform"):
+                return {"props": _static_props(e["kw"])}
+            if fname in ("Shake", "SnoopyShake"):
+                args = [_const(a) for a in e["a"]]
+                return {"effect": "shake", "d": args[1] if len(args) > 1 else 0.5,
+                        "dist": _const(e["kw"].get("dist")) or 20}
+            if fname in self.d.transforms:
+                return {"props": self.d.transforms[fname], "name": fname}
+        if e and e["k"] == "name" and e["id"] not in self.d.transforms:
+            # transform defined later in another file; the player resolves it by name
+            return {"name": e["id"]}
+        self.d.warn("Неизвестная трансформация", f"{self.where(line)}: {source}")
+        return {"name": source}
+
+    def st_scene(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("scene")
+        node: Node = {"op": "scene", "img": None}
+        if c.keyword("onlayer"):
+            node["layer"] = c.word()
+        if not c.eol() and not c.peek("with") and not c.peek("at"):
+            node["img"] = self.image_spec(c, line)
+        self.show_clauses(c, line, node)
+        self.d.stats["scene"] += 1
+        return [node]
+
+    def st_show(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("show")
+        if c.keyword("screen"):
+            self.d.warn("Не поддерживается: screen", self.where(line))
+            return []
+        if c.keyword("text"):
+            text = c.string()
+            if text is not None:
+                node: Node = {"op": "show", "img": {"text": text}}
+            else:
+                node = {"op": "show", "img": {"textExpr": self.expr(c.until(_SHOW_KEYWORDS), line,
+                                                                     const(""))}}
+            self.show_clauses(c, line, node)
+            return [node]
+        node = {"op": "show", "img": self.image_spec(c, line)}
+        self.show_clauses(c, line, node)
+        self.d.stats["show"] += 1
+        return [node]
+
+    def st_hide(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("hide")
+        if c.keyword("screen"):
+            return []
+        spec = self.image_spec(c, line)
+        node: Node = {"op": "hide", "tag": spec.get("name", [""])[0]}
+        self.show_clauses(c, line, node)
+        node.pop("at", None)
+        return [node]
+
+    def st_with(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("with")
+        return [{"op": "with", "t": self.transition(c.rest(), line)}]
+
+    def transition(self, source: str, line: Line) -> dict[str, Any] | None:
+        source = source.strip()
+        if source in ("None", ""):
+            return None
+        if source in self.d.transitions:
+            return self.d.transitions[source]
+        if source in TRANSITIONS:
+            return TRANSITIONS[source]
+        e = self.expr(source, line)
+        return self.transition_expr(e) if e else TRANSITIONS["dissolve"]
+
+    def transition_expr(self, e: Expr) -> dict[str, Any] | None:
+        if e["k"] == "const" and e["v"] is None:
+            return None
+        if e["k"] == "name":
+            return self.d.transitions.get(e["id"]) or TRANSITIONS.get(e["id"]) or {
+                "t": "ref", "name": e["id"]}
+        if e["k"] == "call":
+            fname = _dotted_name(e["f"])
+            args = [_const(a) for a in e["a"]]
+            kw = {k: _const(v) for k, v in e["kw"].items()}
+            nums = [a for a in args if isinstance(a, (int, float))]
+            if fname == "Fade":
+                out = nums[0] if nums else 0.5
+                hold = nums[1] if len(nums) > 2 else 0.0
+                fin = nums[2] if len(nums) > 2 else (nums[1] if len(nums) > 1 else out)
+                return {"t": "fade", "out": out, "hold": hold, "in": fin,
+                        "color": kw.get("color") or "#000000"}
+            if fname in ("Shake", "SnoopyShake"):
+                return {"t": "punch", "dir": "h", "d": nums[0] if nums else 0.5}
+            if fname in ("MoveTransition", "Move"):
+                return {"t": "move", "d": nums[0] if nums else 0.5}
+            if fname in TRANSITIONS:
+                return TRANSITIONS[fname]
+            return {"t": "dissolve", "d": nums[0] if nums else kw.get("time", 0.5) or 0.5}
+        return TRANSITIONS["dissolve"]
+
+    # audio ------------------------------------------------------------------------
+
+    def audio_files(self, c: Cursor, line: Line) -> list[Expr]:
+        src = c.until({"fadein", "fadeout", "loop", "noloop", "if_changed", "volume", "channel"})
+        e = self.expr(src, line)
+        if e is None:
+            return []
+        if e["k"] in ("list", "tuple"):
+            return e["v"]
+        return [e]
+
+    def st_play(self, line: Line, op: str = "play") -> list[Node]:
+        c = self.cursor(line)
+        c.keyword(op)
+        ch = c.word() or "music"
+        node: Node = {"op": op, "ch": ch, "files": self.audio_files(c, line)}
+        while not c.eol():
+            if c.keyword("fadein"):
+                node["fadein"] = _num(c.number())
+            elif c.keyword("fadeout"):
+                node["fadeout"] = _num(c.number())
+            elif c.keyword("loop"):
+                node["loop"] = True
+            elif c.keyword("noloop"):
+                node["loop"] = False
+            elif c.keyword("if_changed"):
+                node["ifChanged"] = True
+            elif c.keyword("volume"):
+                node["volume"] = _num(c.number())
+            else:
+                c.rest()
+        self.d.stats["audio"] += 1
+        return [node]
+
+    def st_queue(self, line: Line) -> list[Node]:
+        return self.st_play(line, "queue")
+
+    def st_stop(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("stop")
+        node: Node = {"op": "stop", "ch": c.word() or "music"}
+        if c.keyword("fadeout"):
+            node["fadeout"] = _num(c.number())
+        return [node]
+
+    def st_voice(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("voice")
+        if c.keyword("sustain"):
+            return [{"op": "voice", "sustain": True}]
+        e = self.expr(c.rest(), line)
+        return [{"op": "voice", "file": e}] if e else []
+
+    # flow ---------------------------------------------------------------------------
+
+    def st_jump(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("jump")
+        if c.keyword("expression"):
+            return [{"op": "jump", "expr": self.expr(c.rest(), line, const(""))}]
+        return [{"op": "jump", "target": self.label_ref(c.label_name() or "")}]
+
+    def st_call(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("call")
+        if c.keyword("screen"):
+            self.d.warn("Не поддерживается: call screen", self.where(line))
+            return []
+        if c.keyword("expression"):
+            node: Node = {"op": "call", "expr": self.expr(c.until({"pass", "from"}), line,
+                                                             const(""))}
+            c.keyword("pass")
+        else:
+            node = {"op": "call", "target": self.label_ref(c.label_name() or "")}
+        args = self.call_args(c, line)
+        if args:
+            node["args"] = args
+        return [node]
+
+    def st_return(self, line: Line) -> list[Node]:
+        return [{"op": "return"}]
+
+    def st_pass(self, line: Line) -> list[Node]:
+        return []
+
+    def st_pause(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("pause")
+        rest = c.rest()
+        return [{"op": "pause", "d": self.expr(rest, line) if rest else None}]
+
+    def st_while(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("while")
+        cond = c.rest().removesuffix(":").strip()
+        return [{"op": "while", "c": self.expr(cond, line, const(False)),
+                 "body": self.block(line.block)}]
+
+    def st_if(self, line: Line) -> list[Node]:
+        branches, _ = self.if_chain([line], 0)
+        return [{"op": "if", "branches": branches}]
+
+    def st_window(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("window")
+        mode = c.word()
+        return [{"op": "window", "mode": mode}] if mode in ("show", "hide") else []
+
+    def st_nvl(self, line: Line) -> list[Node]:
+        c = self.cursor(line)
+        c.keyword("nvl")
+        action = c.word()
+        return [{"op": "nvl", "a": action}] if action in ("clear", "show", "hide") else []
+
+    def st_menu(self, line: Line) -> list[Node]:
+        node: Node = {"op": "menu", "items": [], "say": None}
+        head = self.cursor(line)
+        head.keyword("menu")
+        name = head.label_name()
+        out: list[Node] = []
+        if name:
+            out.append({"op": "label", "name": self.label_ref(name)})
+        for child in line.block:
+            c = self.cursor(child)
+            if c.keyword("set"):
+                node["set"] = self.expr(c.rest(), child)
+                continue
+            if c.keyword("with"):
+                continue
+            text = c.string()
+            if text is not None and child.text.rstrip().endswith(":"):
+                cond = None
+                if c.keyword("if"):
+                    cond = self.expr(c.rest().removesuffix(":").strip(), child, const(True))
+                elif c.peek("("):
+                    c.until({"if"}, ":")
+                    if c.keyword("if"):
+                        cond = self.expr(c.rest().removesuffix(":").strip(), child, const(True))
+                node["items"].append({"text": text, "if": cond, "body": self.block(child.block)})
+                continue
+            say = self.say(child)
+            if say:
+                node["say"] = say[0]
+            else:
+                self.d.warn("Не разобран пункт меню", f"{self.where(child)}: {child.text[:60]}")
+        self.d.stats["menu"] += 1
+        return out + [node]
+
+    # say ------------------------------------------------------------------------------
+
+    def say(self, line: Line) -> list[Node] | None:
+        c = self.cursor(line)
+        who: str | None = None
+        who_str: str | None = None
+        attrs: list[str] = []
+        first = c.string()
+        if first is not None:
+            second = c.string() if not c.eol() else None
+            if second is not None:
+                who_str, what = first, second
+            else:
+                what = first
+        else:
+            who = c.dotted()
+            if who is None:
+                return None
+            while True:
+                save = c.pos
+                if c.string_raw() is not None:
+                    c.pos = save
+                    break
+                p = c.image_part() or (("@" if c.char("@") else None))
+                if p is None:
+                    c.pos = save
+                    break
+                if p != "@":
+                    attrs.append(p)
+            what = c.string()
+            if what is None:
+                return None
+        node: Node = {"op": "say", "what": what, "_ln": line.lineno}  # _ln: dropped after IDs
+        if who and who != "narrator":
+            node["who"] = who
+        if who_str is not None:
+            node["whoStr"] = who_str
+        if attrs:
+            node["attrs"] = attrs
+        while not c.eol():
+            if c.keyword("with"):
+                node["with"] = self.transition(c.rest(), line)
+            elif c.keyword("nointeract"):
+                node["interact"] = False
+            elif c.keyword("id"):
+                c.word()
+            elif c.char("("):
+                c.pos -= 1
+                c.until({"with", "nointeract", "id"})
+            else:
+                c.rest()
+        self.d.stats["say"] += 1
+        return [node]
+
+
+_SHOW_KEYWORDS = {"at", "as", "behind", "onlayer", "with", "zorder"}
+_NUMBER_LINE = re.compile(r"^\d+(\.\d*)?$|^\.\d+$")
+_CALL_LINE = re.compile(r"^([A-Za-z_][\w.]*)\s*\(")
+_DISPLAYABLE_CALLS = {"Movie", "Solid", "Transform", "Composite", "LiveComposite", "Fixed",
+                      "ConditionSwitch", "Image", "im.Scale", "im.FactorScale", "im.Flip",
+                      "im.Composite", "im.Crop", "im.Grayscale", "im.Sepia", "Frame", "Flatten"}
+_MEDIA_EXTS = {"png", "jpg", "jpeg", "webp", "gif", "bmp", "avif", "ogg", "mp3", "wav", "opus",
+               "flac", "webm", "ogv", "mp4", "mkv", "avi", "m4a"}
+
+
+def _dedent(source: str) -> str:
+    import textwrap
+    return textwrap.dedent(source)
+
+
+def _parse_py(source: str, mode: str = "exec") -> ast.AST:
+    # decompiled scripts are full of "\{" in plain strings: don't spam SyntaxWarning
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        return ast.parse(_dedent(source), mode=mode)
+
+
+def _dotted_name(e: Expr) -> str:
+    if e["k"] == "name":
+        return e["id"]
+    if e["k"] == "attr":
+        return f"{_dotted_name(e['o'])}.{e['a']}"
+    return ""
+
+
+def _assign_name(t: ast.AST) -> str | None:
+    if isinstance(t, ast.Name):
+        return t.id
+    if isinstance(t, ast.Attribute):
+        inner = _assign_name(t.value)
+        return f"{inner}.{t.attr}" if inner else None
+    return None
+
+
+def _const(e: Expr | None) -> Any:
+    if e is None:
+        return None
+    if e.get("k") == "const":
+        return e["v"]
+    if e.get("k") in ("tuple", "list"):
+        return [_const(x) for x in e["v"]]
+    if e.get("k") == "unary" and e["op"] == "-":
+        v = _const(e["v"])
+        return -v if isinstance(v, (int, float)) else None
+    return None
+
+
+def _num(s: str | None) -> float | None:
+    try:
+        return float(s) if s is not None else None
+    except ValueError:
+        return None
+
+
+def _static_props(kw: dict[str, Expr]) -> dict[str, Any]:
+    props = {}
+    for k, v in kw.items():
+        if k in POSITION_PROPS:
+            val = _const(v)
+            if val is not None:
+                props[k] = val
+    return props
+
+
+def _atl_props(text: str) -> dict[str, Any]:
+    """Extract static `prop value` pairs from one ATL line, ignoring timing."""
+    tokens = text.replace(",", " ").split()
+    props: dict[str, Any] = {}
+    i = 0
+    while i < len(tokens) - 1:
+        key = tokens[i]
+        if key in POSITION_PROPS:
+            raw = tokens[i + 1]
+            try:
+                props[key] = ast.literal_eval(raw)
+            except (ValueError, SyntaxError):
+                if raw.startswith("(") and i + 2 < len(tokens):
+                    try:
+                        props[key] = list(ast.literal_eval(raw + "," + tokens[i + 2]))
+                        i += 1
+                    except (ValueError, SyntaxError):
+                        pass
+            i += 2
+        else:
+            i += 1
+    return props
+
+
+def _split_top(source: str) -> list[str]:
+    parts, depth, cur = [], 0, []
+    for ch in source:
+        if ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            depth -= 1
+        if ch == "," and depth == 0:
+            parts.append("".join(cur))
+            cur = []
+        else:
+            cur.append(ch)
+    if "".join(cur).strip():
+        parts.append("".join(cur))
+    return [p.strip() for p in parts if p.strip()]
+
+
+def _jump_or_call(op: str, target: Expr) -> Node:
+    if target.get("k") == "const":
+        return {"op": op, "target": target["v"]}
+    return {"op": op, "expr": target}
diff --git a/backend/tests/fixtures/sample/tl/english/script.rpy b/backend/tests/fixtures/sample/tl/english/script.rpy
new file mode 100644
index 0000000..fe1b96e
--- /dev/null
+++ b/backend/tests/fixtures/sample/tl/english/script.rpy
@@ -0,0 +1,28 @@
+# TODO: Translation updated at 2026-10-25 12:00
+
+# game/script.rpy:29
+translate english start_1a2b3c4d:
+
+    # "Добро пожаловать в {b}тестовую{/b} новеллу."
+    "Welcome to the {b}test{/b} novel."
+
+# game/script.rpy:32
+translate english start_5e6f7a8b:
+
+    # e "Привет! Как тебя зовут?"
+    e "Hi! What's your name?"
+
+# matched by label + original text, the location comment is stale
+translate english walk_deadbeef:
+
+    # e sad "На улице дождь..."
+    e sad "It's raining outside..."
+
+translate english strings:
+
+    # game/script.rpy:2
+    old "Эйлин"
+    new "Eileen"
+
+    old "Пойдём гулять"
+    new "Let's go for a walk"
diff --git a/backend/tests/make_sample.py b/backend/tests/make_sample.py
index 35fd13b..a447b06 100644
--- a/backend/tests/make_sample.py
+++ b/backend/tests/make_sample.py
@@ -59,6 +59,8 @@ def build(path: Path) -> Path:
     with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
         zf.writestr("SampleGame-1.0-pc/game/archive.rpa", rpa_path.read_bytes())
         zf.writestr("SampleGame-1.0-pc/game/options.rpy", options)
+        zf.writestr("SampleGame-1.0-pc/game/tl/english/script.rpy",
+                    (FIXTURES / "tl" / "english" / "script.rpy").read_bytes())
         zf.writestr("SampleGame-1.0-pc/game/audio/theme.wav", _wav())
         zf.writestr("SampleGame-1.0-pc/game/gui/main_menu.png",
                     _png((1280, 720), (30, 30, 50), "Main menu"))
diff --git a/backend/tests/test_converter.py b/backend/tests/test_converter.py
index 08eb3cc..153c106 100644
--- a/backend/tests/test_converter.py
+++ b/backend/tests/test_converter.py
@@ -36,7 +36,7 @@ def test_say_variants():
     d = parse('label start:\n    "narration"\n    e happy "hi" with dissolve\n'
               '    "Bob" "named"\n    centered "c"\n')
     body = d.modules["t.rpy"][0]["body"]
-    assert body[0] == {"op": "say", "what": "narration"}
+    assert {k: v for k, v in body[0].items() if k != "_ln"} == {"op": "say", "what": "narration"}
     assert body[1]["who"] == "e" and body[1]["attrs"] == ["happy"] and body[1]["with"]["t"] == "dissolve"
     assert body[2]["whoStr"] == "Bob"
     assert body[3]["who"] == "centered"
@@ -80,6 +80,17 @@ def test_full_pipeline(data_dir, tmp_path):
     if shutil.which("ffmpeg"):
         assert "audio/theme.ogg" in files
 
+    # every node has an id, says have tids; tl/english imported into our tables
+    assert all("id" in n for n in script["labels"][0]["body"])
+    assert game["sourceLang"] == "ru"
+    en = game["locales"]["en"]
+    assert en["renpy"] == "english" and en["lines"] == 3
+    lines = json.loads(read_bytes(files[en["modules"]["script/script.json"]]["hash"]))
+    first_say = next(n for n in script["labels"][0]["body"] if n["op"] == "say")
+    assert lines[first_say["tid"]]["t"] == "Welcome to the {b}test{/b} novel."
+    strings = json.loads(read_bytes(files[en["strings"]]["hash"]))
+    assert strings["Эйлин"]["t"] == "Eileen"
+
 
 def test_nested_labels_and_named_menus_become_anchors():
     from app.converter.pipeline import anchors
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index f0a7a27..eba3419 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -105,7 +105,10 @@ LOCKED`), Redis не нужен.
 редактировать), состояние плеера — стек `{label, path}` где `path` — индексы
 внутри вложенных блоков, так что сохранения стабильны и компактны.
 
-Узлы (`op`): `say`, `scene`, `show`, `hide`, `with`, `play`, `stop`, `queue`,
+У каждого узла есть постоянный `id`, у реплик — ещё `tid` для перевода.
+Переводы лежат отдельно, в `locales/<язык>/…` (см. [LOCALIZATION.md](LOCALIZATION.md)).
+
+Узлы (`op`): `label` (точка входа внутри блока), `camera`, `say`, `scene`, `show`, `hide`, `with`, `play`, `stop`, `queue`,
 `pause`, `menu`, `if`, `while`, `jump`, `call`, `return`, `exec`, `window`,
 `noop`. Выражения: `const`, `name`, `attr`, `sub`, `bin`, `bool`, `cmp`,
 `unary`, `if`, `list`, `tuple`, `dict`, `call`, `fmt`.
diff --git a/docs/LOCALIZATION.md b/docs/LOCALIZATION.md
new file mode 100644
index 0000000..d0fe628
--- /dev/null
+++ b/docs/LOCALIZATION.md
@@ -0,0 +1,182 @@
+# Локализация и моды — проект
+
+Цель: переводить и модифицировать игры прямо в библиотеке, нативно и удобно.
+Переводы из самих игр импортируются при конвертации, дальше живут только в
+нашем формате.
+
+## Почему это нужно решить сейчас
+
+Исходники игры удаляются после конвертации. Всё, что не вытащено в момент
+конвертации (готовые переводы из `tl/`, привязка реплик к их месту в
+исходнике), потом взять будет неоткуда. Поэтому стабильные идентификаторы
+и импорт переводов должны появиться в конвертере до того, как библиотека
+наполнится играми.
+
+## Что есть в играх (по примерам)
+
+| Игра | Языки в `tl/` | Переведённых реплик |
+|---|---|---|
+| That New Teacher | 19 (в т.ч. russian) | ~350 000 блоков |
+| Twisted Thoughts | 9; исходник на французском, english — перевод | ~117 000 |
+| остальные 4 | только исходный | — |
+
+Формат Ren'Py:
+
+```
+# game/Days/dayEight.rpy:248
+translate russian D8_Clarissa_c7855708:
+    # "You lie on your side, facing away..."
+    "Ты лежишь на боку, отвернувшись..."
+
+translate russian strings:
+    old "Iris"
+    new "Айрис"
+```
+
+Реплики переводятся блоками с идентификатором (`метка_хэш`) и ссылкой на
+строку оригинала; имена, пункты меню и строки интерфейса — таблицей old/new.
+Бывает и игровая логика, зависящая от языка (`_preferences.language`).
+
+## Главная идея: текст отдельно от скрипта, у всего стабильные ID
+
+1. **ID узлов.** Каждый оператор скрипта получает постоянный `id`. Он
+   присваивается один раз при конвертации и дальше не меняется при правках.
+   На этих ID держатся переводы, сохранения и в будущем слияние модов.
+2. **ID строк.** Реплики получают `tid` в стиле Ren'Py (`метка_хэш`) и
+   хранят его в скрипте, так что правки текста ID не меняют. Пункты меню,
+   имена, `_()` и `show text` переводятся таблицей строк по исходному тексту,
+   как в Ren'Py.
+3. **Исходный текст остаётся в скрипте.** Скрипт читается как есть, язык
+   оригинала — это просто «исходная локаль» (у Twisted Thoughts — французский).
+4. **Переводы — отдельные таблицы** `locales/<язык>/<модуль>.json`:
+
+   ```json
+   { "start_577f33b3": { "t": "Ммм...", "src": "a1b2c3", "state": "translated" } }
+   ```
+
+   `src` — хэш исходного текста на момент перевода. Если в моде или новой
+   версии оригинал реплики изменился, перевод помечается «устарел», а не
+   теряется молча. Состояния: `translated`, `fuzzy`/устарел, `machine`,
+   `approved`.
+5. **Файлы локали режутся по модулям скрипта.** Правка одной реплики создаёт
+   один новый маленький блоб — остальное общее (наш content-addressed store).
+
+`locales/<язык>/meta.json`: код языка (BCP-47: `ru`), название, авторы,
+прогресс, шрифт-замена (у многих игр в шрифтах нет кириллицы или CJK),
+переопределения ассетов для языка: картинки с надписями, озвучка.
+
+## Импорт переводов из игры
+
+При конвертации разбираем `tl/<lang>/`:
+
+* блок `translate <lang> <id>` сопоставляем с нашей репликой по комментарию
+  `# game/file.rpy:строка` (точно и просто), запасной вариант — по ID Ren'Py;
+* `translate <lang> strings` превращаем в таблицу old→new для имён, меню и `_()`;
+* языки Ren'Py (`russian`, `spanish_latam`, `None`) переводим в коды `ru`,
+  `es-419` и исходную локаль;
+* импортируются все языки игры — это только текст, места почти не занимает.
+
+## Плеер
+
+* Выбор языка в главном меню и настройках, запоминается для каждого
+  пользователя.
+* Цепочка запасных языков: `ru → en → исходный`. Непереведённая строка
+  показывается на запасном языке и не ломает игру.
+* `_()`, флаг `!t` в `[переменных]`, имена персонажей переводятся из таблиц;
+  `_preferences.language` отдаёт выбранный язык, поэтому языковая логика
+  игры (как в Twisted Thoughts) работает.
+* Шрифт и ассеты подменяются из `meta.json` локали.
+
+## Версии и публикация
+
+Сценарий:
+
+1. Модератор делает форк главной версии: «Перевод RU (черновик)».
+2. Переводит в редакторе. Форк виден только ему и тем, у кого есть права
+   на рецензию.
+3. Нажимает «Опубликовать перевод».
+
+**Публикация переносит локаль, а не подменяет версию.** Если два
+переводчика параллельно делают RU и DE в двух форках, «сделать форк главным»
+потеряет работу одного из них. Поэтому публикация создаёт новую главную
+версию: главная + локаль из форка. Переводы склеиваются по `tid` построчно,
+это тривиально. Перенос перевода в любую совместимую версию (например, в мод)
+работает так же — одной кнопкой, по тем же ID.
+
+Модели:
+
+* `games.main_version_id` — главная версия (её открывает кнопка «Играть»);
+* у версии `visibility`: `draft` / `published`, а также `kind`: оригинал,
+  перевод, мод;
+* новые права: `translations.edit` — переводить в своих форках,
+  `versions.publish` — публиковать, назначать главную.
+
+## Редактор перевода
+
+* Таблица строк по сценам и меткам: оригинал | перевод | статус, фильтры
+  «не переведено / устарело / машинное», поиск, прогресс в процентах.
+* Контекст строки: кто говорит, соседние реплики, фон и спрайты сцены на этом
+  месте, кнопка «проиграть с этой строки» в плеере.
+* Глоссарий: имена и термины подставляются и проверяются на единообразие.
+* Экспорт и импорт PO/XLIFF/CSV для внешних инструментов, экспорт обратно
+  в формат Ren'Py `tl/`.
+* Позже: режим «править прямо в игре» — клик по реплике в плеере;
+  машинный предперевод с пометкой `machine`.
+
+## Моды
+
+Те же основы делают моды нативными:
+
+* скрипт редактируется на уровне меток и операторов с постоянными ID;
+* мод — форк с изменёнными модулями скрипта и ассетами: в хранилище только
+  отличия;
+* переводы оригинала автоматически применяются к неизменённым репликам мода,
+  новые реплики мода видны как непереведённые;
+* так как у всего есть ID и родитель, можно делать трёхстороннее слияние:
+  мод A + мод B, или перенос мода на новую версию оригинала.
+
+## Принятые решения
+
+* Публикация перевода — **слияние локали** в новую главную версию, а не
+  подмена главной версии форком.
+* Из игр импортируются **все языки** `tl/`.
+* Машинный предперевод — **позже, как подключаемый провайдер**. Сейчас
+  закладывается только состояние строки `machine`.
+* Начинаем с этапа 1.
+
+## Состояние
+
+Этап 1 сделан:
+
+* у всех узлов скрипта есть `id`, у реплик — `tid`;
+* при конвертации импортируются все языки из `tl/`. Блок сопоставляется
+  с репликой по комментарию `# game/file.rpy:N`, а если он устарел — по
+  метке и исходному тексту. Отдельные таблицы `strings` тоже импортируются;
+* исходный язык берётся из `config.language` или определяется по тексту
+  (у Twisted Thoughts — французский);
+* в манифесте лежат `locales/<код>/<модуль>.json` и `locales/<код>/strings.json`,
+  в `game.json` — `sourceLang` и `locales` с прогрессом;
+* в плеере есть выбор языка в главном меню и настройках, запасной язык —
+  исходный, работают `__()`, `!t`, `_preferences.language`.
+
+Проверено на примерах: Twisted Thoughts — 9 языков, по 12 949 реплик,
+100% сопоставлено. That New Teacher — 18 языков, около 75% реплик: остальное
+авторы ещё не перевели, а ~750 блоков на язык относятся к уже изменённым
+английским репликам. Ren'Py их тоже не показывает.
+
+Уже сконвертированные версии остаются без ID и без переводов, их нужно
+переимпортировать. Пока в библиотеке только тестовые данные, отдельную
+миграцию не делаем.
+
+## Этапы
+
+1. **Фундамент (сейчас, до наполнения библиотеки):** ID узлов и строк в
+   конвертере, импорт `tl/` всех языков, локали в манифесте, выбор языка и
+   запасные языки в плеере, `_()`/`!t`/`_preferences.language`.
+   Миграция уже сконвертированных версий: ID детерминированно выводятся
+   из текущего IR.
+2. **Перевод в библиотеке:** главная версия, черновик и публикация, права,
+   редактор перевода, прогресс, экспорт и импорт PO/CSV.
+3. **Удобство:** контекст сцены, «проиграть отсюда», глоссарий,
+   рецензирование, шрифты и ассеты локалей, машинный предперевод.
+4. **Моды:** редактор скриптов, замена ассетов, слияние и перенос модов.
diff --git a/frontend/src/player/engine.ts b/frontend/src/player/engine.ts
index 0ae4445..32b34a1 100644
--- a/frontend/src/player/engine.ts
+++ b/frontend/src/player/engine.ts
@@ -1,1357 +1,1412 @@
-// PGVN interpreter + in-game UI.
-
-import { AudioSystem, type Volumes } from "./audio";
-import { JumpSignal, PyDict, Python, decodeValue, encodeValue, pyStr, truthy, type Scope } from "./python";
-import { Renderer, type ResolvedImage } from "./renderer";
-import { fastPoint, interpolate, parseText, plainText, renderText, waitPoints } from "./text";
-import type {
-  CharacterDef, Expr, Frame, GameData, ImageDef, Label, Layer, Manifest, Node, SaveData, ScriptModule,
-} from "./types";
-
-export interface SaveMeta {
-  slot: string;
-  title: string;
-  updated_at: string;
-}
-
-export interface SaveApi {
-  list(): Promise<SaveMeta[]>;
-  get(slot: string): Promise<SaveData | null>;
-  put(slot: string, title: string, data: SaveData): Promise<void>;
-  remove(slot: string): Promise<void>;
-}
-
-interface Settings extends Volumes {
-  cps: number; // characters per second, 0 = instant
-  autoDelay: number; // seconds per 20 characters in auto mode
-}
-
-const DEFAULT_SETTINGS: Settings = { cps: 45, autoDelay: 1.2, music: 0.7, sound: 0.8, voice: 1 };
-const SLOTS = 12;
-
-interface LabelRef {
-  label: Label;
-  module: ScriptModule;
-  index: number;
-}
-
-class Restart extends Error {}
-
-function el<K extends keyof HTMLElementTagNameMap>(tag: K, cls = "", text = ""): HTMLElementTagNameMap[K] {
-  const e = document.createElement(tag);
-  if (cls) e.className = cls;
-  if (text) e.textContent = text;
-  return e;
-}
-
-function loadJSON<T>(key: string, fallback: T): T {
-  try {
-    const raw = localStorage.getItem(key);
-    return raw ? { ...fallback, ...JSON.parse(raw) } : fallback;
-  } catch {
-    return fallback;
-  }
-}
-
-function saveJSON(key: string, value: unknown) {
-  try {
-    localStorage.setItem(key, JSON.stringify(value));
-  } catch {
-    /* storage unavailable */
-  }
-}
-
-export class Engine {
-  private labels = new Map<string, LabelRef>();
-  private anchors = new Map<string, { label: string; path: number[]; params?: [string, Expr | null][] | null }>();
-  private imagesByTag = new Map<string, { attrs: string[]; key: string }[]>();
-  private store: Record<string, any> = {};
-  private builtins: Record<string, any> = {};
-  private persistent: Record<string, any>;
-  private py: Python;
-  private renderer: Renderer;
-  private audio: AudioSystem;
-  private settings: Settings;
-
-  private cur: Frame = { label: "", path: [0] };
-  private stack: Frame[] = [];
-  private gen = 0;
-  private waiters: (() => void)[] = [];
-  private running = false;
-
-  private skip = false;
-  private auto = false;
-  private windowShown = true;
-  private lastSay: { name: string; text: string; color?: string; char?: CharacterDef } | null = null;
-  private history: { name: string; text: string }[] = [];
-  private nvlLines: HTMLElement[] = [];
-  private interactions = 0;
-
-  // UI
-  private container: HTMLDivElement;
-  private textbox!: HTMLDivElement;
-  private namebox!: HTMLDivElement;
-  private textEl!: HTMLDivElement;
-  private ctc!: HTMLSpanElement;
-  private menuEl!: HTMLDivElement;
-  private nvlEl!: HTMLDivElement;
-  private centeredEl!: HTMLDivElement;
-  private quick!: HTMLDivElement;
-  private screen!: HTMLDivElement;
-  private notifyEl!: HTMLDivElement;
-  private baseSize: number;
-  private resizeObserver: ResizeObserver;
-
-  constructor(
-    private root: HTMLElement,
-    private game: GameData,
-    private manifest: Manifest,
-    modules: ScriptModule[],
-    private saves: SaveApi,
-    private persistentKey: string,
-    private onExit: () => void,
-  ) {
-    for (const mod of modules) {
-      let global = "";
-      mod.labels.forEach((label, index) => {
-        if (label.name.startsWith(".")) label.name = global + label.name;
-        else global = label.name.split(".")[0];
-        this.labels.set(label.name, { label, module: mod, index });
-      });
-      for (const [name, anchor] of Object.entries(mod.anchors ?? {})) this.anchors.set(name, anchor);
-    }
-    for (const key of Object.keys(game.images)) {
-      const [tag, ...attrs] = key.split(" ");
-      if (!this.imagesByTag.has(tag)) this.imagesByTag.set(tag, []);
-      this.imagesByTag.get(tag)!.push({ attrs, key });
-    }
-
-    this.settings = loadJSON("pgvn:settings", DEFAULT_SETTINGS);
-    this.persistent = this.makePersistent();
-    const scope: Scope = {
-      get: (n) => (n in this.store ? this.store[n] : this.builtins[n]),
-      has: (n) => n in this.store || n in this.builtins,
-      set: (n, v) => void (this.store[n] = v),
-      del: (n) => void delete this.store[n],
-    };
-    this.py = new Python(scope);
-    this.builtins = this.makeBuiltins();
-
-    const [w, h] = game.resolution;
-    this.baseSize = Number(game.ui.text_size) || Math.round(h * 0.0306);
-    this.container = el("div", "pg-root");
-    root.append(this.container);
-    this.renderer = new Renderer(this.container, w, h, {
-      url: (f) => this.fileUrl(f),
-      resolveRef: (name) => this.resolveImage(name.split(" "))?.def ?? null,
-      evalCond: (c) => truthy(this.safeEval(c)),
-      transform: (name) => game.transforms[name] ?? null,
-      text: (e) => this.interp(pyStr(this.safeEval(e))),
-    });
-    this.audio = new AudioSystem(this.settings, (f) => this.fileUrl(f), game.channels ?? {});
-    this.buildUI();
-    this.resizeObserver = new ResizeObserver(() => this.renderer.fit(this.container));
-    this.resizeObserver.observe(this.container);
-    this.renderer.fit(this.container);
-    window.addEventListener("keydown", this.onKey);
-    window.addEventListener("keyup", this.onKeyUp);
-  }
-
-  destroy() {
-    this.gen++;
-    this.wakeAll();
-    this.audio.stopAll();
-    this.resizeObserver.disconnect();
-    window.removeEventListener("keydown", this.onKey);
-    window.removeEventListener("keyup", this.onKeyUp);
-    this.container.remove();
-  }
-
-  // --- files & images ----------------------------------------------------------
-
-  fileUrl(path: string): string | null {
-    const clean = path.replace(/^<[^>]*>/, "").replace(/\\/g, "/").replace(/^\/+/, "");
-    let logical: string | undefined = this.manifest.files[clean] ? clean : undefined;
-    if (!logical) {
-      const low = clean.toLowerCase();
-      for (const prefix of ["", "images/", "audio/", "music/", "sound/", "sounds/"]) {
-        logical = this.game.files[prefix + low];
-        if (logical) break;
-      }
-    }
-    const entry = logical ? this.manifest.files[logical] : undefined;
-    return entry ? `/blobs/${entry.hash}` : null;
-  }
-
-  private resolveImage(name: string[]): ResolvedImage | null {
-    const full = name.join(" ");
-    const [tag, ...attrs] = name;
-    const layered = this.game.images[tag];
-    if (layered?.layered) return this.resolveLayered(tag, layered, attrs);
-    if (this.game.images[full]) return { def: this.game.images[full], name };
-    const candidates = this.imagesByTag.get(tag) ?? [];
-    let best: { attrs: string[]; key: string } | null = null;
-    for (const c of candidates) {
-      if (attrs.every((a) => c.attrs.includes(a)) && (!best || c.attrs.length < best.attrs.length)) best = c;
-    }
-    if (!best && attrs.length) {
-      // keep attributes of the currently shown image that the new ones don't replace
-      const current = this.renderer.attrsOf(tag)?.slice(1) ?? [];
-      for (const c of candidates) {
-        if (attrs.every((a) => c.attrs.includes(a)) || !c.attrs.some((a) => attrs.includes(a))) continue;
-        const keeps = current.filter((a) => c.attrs.includes(a)).length;
-        if (!best || keeps > 0) best = c;
-      }
-    }
-    if (!best) return null;
-    return { def: this.game.images[best.key], name: best.key.split(" ") };
-  }
-
-  /** Attributes of a layeredimage: new ones replace current ones of the same group. */
-  private resolveLayered(tag: string, def: ImageDef, attrs: string[]): ResolvedImage {
-    const layers = def.layered!;
-    const groupOf = (a: string) => layers.find((l) => l.attr === a)?.group ?? null;
-    const removed = attrs.filter((a) => a.startsWith("-")).map((a) => a.slice(1));
-    const added = attrs.filter((a) => !a.startsWith("-"));
-    const current = (this.renderer.attrsOf(tag)?.slice(1) ?? []).filter((a) => {
-      if (removed.includes(a)) return false;
-      const g = groupOf(a);
-      return !added.some((n) => n === a || (g !== null && groupOf(n) === g));
-    });
-    const selected = [...current, ...added];
-    // `group x auto`: attributes backed by images named <tag>_<group>_<attr>
-    const extra: Layer[] = [];
-    for (const l of layers) {
-      if (!l.autoGroup) continue;
-      for (const a of selected) {
-        const ref = `${tag}_${l.autoGroup}_${a}`;
-        if (this.game.images[ref] && !layers.some((x) => x.attr === a))
-          extra.push({ attr: a, group: l.autoGroup, img: { ref } });
-      }
-    }
-    return { def: { ...def, layered: [...layers, ...extra], selected }, name: [tag, ...selected] };
-  }
-
-  private imageFromSpec(spec: any): ResolvedImage | null {
-    if (spec.name) return this.resolveImage(spec.name);
-    if (spec.text !== undefined) return { def: { text: spec.text }, name: ["text"] };
-    if (spec.textExpr) return { def: { textExpr: spec.textExpr }, name: ["text"] };
-    if (spec.expr) {
-      const v = this.safeEval(spec.expr);
-      if (typeof v !== "string") return null;
-      if (v.startsWith("#")) return { def: { color: v }, name: [v] };
-      if (v.includes(".")) return { def: { file: v }, name: [v.split("/").pop()!.split(".")[0]] };
-      return this.resolveImage(v.split(" "));
-    }
-    return null;
-  }
-
-  // --- python environment ----------------------------------------------------------
-
-  private safeEval(e: Expr | null | undefined): any {
-    try {
-      return this.py.eval(e);
-    } catch (err) {
-      if (err instanceof JumpSignal) throw err;
-      console.warn("[pgvn] ошибка выражения", err);
-      return null;
-    }
-  }
-
-  private makePersistent(): Record<string, any> {
-    const data = decodeValue(loadJSON<Record<string, any>>(this.persistentKey, {}));
-    const save = () => saveJSON(this.persistentKey, encodeValue(data));
-    return new Proxy(data, {
-      get: (t, k: string) => (k in t ? t[k] : k === "toJSON" ? undefined : null),
-      set: (t, k: string, v) => {
-        t[k] = v;
-        save();
-        return true;
-      },
-    });
-  }
-
-  private makeBuiltins(): Record<string, any> {
-    const kwless = (args: any[]) =>
-      args.length && args[args.length - 1]?.__kw ? args.slice(0, -1) : args;
-    const kwOf = (args: any[]) => (args.length && args[args.length - 1]?.__kw) || {};
-    const random = {
-      randint: (a: number, b: number) => a + Math.floor(Math.random() * (b - a + 1)),
-      random: () => Math.random(),
-      choice: (xs: any[]) => xs[Math.floor(Math.random() * xs.length)],
-      shuffle: (xs: any[]) => {
-        for (let i = xs.length - 1; i > 0; i--) {
-          const j = Math.floor(Math.random() * (i + 1));
-          [xs[i], xs[j]] = [xs[j], xs[i]];
-        }
-      },
-      uniform: (a: number, b: number) => a + Math.random() * (b - a),
-    };
-    const music = (ch: string) => ({
-      play: (...a: any[]) => {
-        const kw = kwOf(a);
-        const files = kwless(a)[0];
-        this.audio.play(kw.channel ?? ch, (Array.isArray(files) ? files : [files]).map(String),
-                        { loop: kw.loop, fadein: kw.fadein, fadeout: kw.fadeout });
-      },
-      queue: (...a: any[]) => {
-        const kw = kwOf(a);
-        const files = kwless(a)[0];
-        this.audio.queue(kw.channel ?? ch, (Array.isArray(files) ? files : [files]).map(String), kw.loop);
-      },
-      stop: (...a: any[]) => this.audio.stop(kwOf(a).channel ?? ch, kwOf(a).fadeout ?? 0),
-      set_volume: () => {},
-      get_playing: () => this.audio.current(ch)?.file ?? null,
-      is_playing: () => this.audio.current(ch) !== null,
-    });
-    const renpyImpl: Record<string, any> = {
-      random,
-      music: music("music"),
-      sound: music("sound"),
-      play: (f: string, ...a: any[]) => this.audio.play(kwOf(a).channel ?? "sound", [f], {}),
-      notify: (msg: any) => this.notify(pyStr(msg)),
-      jump: (label: string) => {
-        throw new JumpSignal("jump", label);
-      },
-      call: (label: string) => {
-        throw new JumpSignal("call", label);
-      },
-      input: (...a: any[]) => {
-        const [prompt, def] = kwless(a);
-        const kw = kwOf(a);
-        const v = window.prompt(pyStr(prompt ?? ""), pyStr(def ?? kw.default ?? ""));
-        return (v ?? pyStr(def ?? kw.default ?? "")).slice(0, kw.length ?? 1000);
-      },
-      has_label: (l: string) => this.labels.has(l),
-      seen_label: (l: string) => truthy(this.persistent._seen?.includes?.(l)),
-      showing: (tag: string) => this.renderer.isShown(String(tag).split(" ")[0]),
-      get_attributes: (tag: string) => this.renderer.attrsOf(tag)?.slice(1) ?? [],
-      full_restart: () => {
-        throw new JumpSignal("jump", "__main_menu__");
-      },
-      quit: () => {
-        throw new JumpSignal("jump", "__quit__");
-      },
-      version: () => "pgvn",
-    };
-    const renpy = new Proxy(renpyImpl, {
-      get: (t, k: string) => {
-        if (k in t) return t[k];
-        this.py.warnOnce(`renpy.${k} не поддерживается — пропущено`);
-        return () => null;
-      },
-    });
-    const num = (x: any) => (typeof x === "string" ? Number(x.trim()) : Number(x));
-    return {
-      renpy,
-      persistent: this.persistent,
-      config: {},
-      preferences: {},
-      _preferences: {},
-      gui: {},
-      store: new Proxy({}, { get: (_t, k: string) => this.store[k] ?? null,
-                             set: (_t, k: string, v) => ((this.store[k] = v), true) }),
-      audio: this.game.audio,
-      random,
-      math: { floor: Math.floor, ceil: Math.ceil, sqrt: Math.sqrt, pi: Math.PI, pow: Math.pow },
-      len: (x: any) => (x instanceof PyDict ? x.map.size : x?.length ?? 0),
-      str: (x: any) => pyStr(x),
-      int: (x: any) => Math.trunc(num(x)),
-      float: (x: any) => num(x),
-      bool: (x: any) => truthy(x),
-      abs: Math.abs,
-      round: (x: number, n = 0) => Math.round(x * 10 ** n) / 10 ** n,
-      min: (...a: any[]) => (a.length === 1 ? Math.min(...a[0]) : Math.min(...a)),
-      max: (...a: any[]) => (a.length === 1 ? Math.max(...a[0]) : Math.max(...a)),
-      sum: (xs: number[]) => xs.reduce((s, x) => s + x, 0),
-      any: (xs: any[]) => xs.some(truthy),
-      all: (xs: any[]) => xs.every(truthy),
-      range: (a: number, b?: number, step = 1) => {
-        const [lo, hi] = b === undefined ? [0, a] : [a, b];
-        const out: number[] = [];
-        for (let i = lo; step > 0 ? i < hi : i > hi; i += step) out.push(i);
-        return out;
-      },
-      list: (xs: any = []) => [...(xs instanceof PyDict ? xs.map.keys() : xs)],
-      tuple: (xs: any = []) => [...xs],
-      set: (xs: any = []) => [...new Set(xs)],
-      dict: (...a: any[]) => {
-        const d = new PyDict(Array.isArray(kwless(a)[0]) ? kwless(a)[0] : []);
-        for (const [k, v] of Object.entries(kwOf(a))) d.set(k, v);
-        return d;
-      },
-      sorted: (xs: any[]) => [...xs].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
-      reversed: (xs: any[]) => [...xs].reverse(),
-      enumerate: (xs: any[]) => [...xs].map((x, i) => [i, x]),
-      zip: (...lists: any[][]) => lists[0].map((_, i) => lists.map((l) => l[i])),
-      isinstance: () => false,
-      _: (s: string) => s,
-      __: (s: string) => s,
-    };
-  }
-
-  private resetStore() {
-    this.store = {};
-    try {
-      this.py.exec(this.game.init);
-    } catch (err) {
-      console.warn("[pgvn] ошибка init", err);
-    }
-  }
-
-  private newStore() {
-    this.resetStore();
-    for (const [name, e] of this.game.defaults) {
-      if (!(name in this.store)) this.store[name] = this.safeEval(e);
-    }
-  }
-
-  // --- control flow ------------------------------------------------------------------
-
-  private blockFor(frame: Frame): Node[] {
-    let block = this.labels.get(frame.label)!.label.body;
-    for (let k = 0; k < frame.path.length - 1; k += 2) {
-      block = childBlock(block[frame.path[k]], frame.path[k + 1]);
-    }
-    return block;
-  }
-
-  private node(): Node | null {
-    if (!this.labels.has(this.cur.label)) return null;
-    return this.blockFor(this.cur)[this.cur.path[this.cur.path.length - 1]] ?? null;
-  }
-
-  /** After a path change, move past ended blocks (falling through labels / looping whiles). */
-  private settle() {
-    for (let guard = 0; guard < 10000; guard++) {
-      const p = this.cur.path;
-      if (!this.labels.has(this.cur.label)) return;
-      const block = this.blockFor(this.cur);
-      if (p[p.length - 1] < block.length) return;
-      if (p.length === 1) {
-        const ref = this.labels.get(this.cur.label)!;
-        const next = ref.module.labels[ref.index + 1];
-        if (next) {
-          this.cur = { label: next.name, path: [0] };
-          continue;
-        }
-        this.doReturn();
-        return;
-      }
-      const parent = p.slice(0, -2);
-      const parentNode = this.blockFor({ label: this.cur.label, path: parent })[parent[parent.length - 1]];
-      this.cur.path = parent;
-      if (parentNode.op !== "while") this.cur.path[parent.length - 1]++;
-    }
-  }
-
-  private advance() {
-    this.cur.path[this.cur.path.length - 1]++;
-    this.settle();
-  }
-
-  private enter(branch: number) {
-    this.cur.path.push(branch, 0);
-    this.settle();
-  }
-
-  private jump(target: string, args?: { a: any[]; kw: Record<string, any> }, frame?: Frame) {
-    if (target === "__main_menu__" || target === "__quit__") {
-      throw new Restart(target);
-    }
-    let name = target;
-    if (name.startsWith(".")) name = this.cur.label.split(".")[0] + name;
-    const anchor = this.labels.has(name) ? null : this.anchors.get(name);
-    if (!this.labels.has(name) && !anchor) {
-      this.notify(`Метка «${target}» не найдена`);
-      console.warn("[pgvn] нет метки", target);
-      if (frame) this.stack.pop();
-      this.advance();
-      return;
-    }
-    const params = anchor ? anchor.params : this.labels.get(name)!.label.params;
-    if (params?.length) this.bindParams(params, args, frame);
-    this.cur = anchor ? { label: anchor.label, path: [...anchor.path] } : { label: name, path: [0] };
-    this.markSeen(name);
-    this.settle();
-  }
-
-  /** Label parameters are dynamically scoped: a call restores old values on return. */
-  private bindParams(params: [string, Expr | null][], args?: { a: any[]; kw: Record<string, any> },
-                     frame?: Frame) {
-    const values: Record<string, any> = {};
-    params.forEach(([p, def], i) => {
-      if (args && i < args.a.length) values[p] = args.a[i];
-      else if (args && p in args.kw) values[p] = args.kw[p];
-      else values[p] = def ? this.safeEval(def) : null;
-    });
-    if (frame) {
-      frame.saved = {};
-      for (const p of Object.keys(values)) frame.saved[p] = { had: p in this.store, value: this.store[p] };
-    }
-    Object.assign(this.store, values);
-  }
-
-  private call(target: string, argExprs?: { a: Expr[]; kw: Record<string, Expr> }) {
-    // arguments are evaluated in the caller's scope, before parameters are bound
-    const args = argExprs && {
-      a: argExprs.a.map((e) => this.safeEval(e)),
-      kw: Object.fromEntries(Object.entries(argExprs.kw).map(([k, e]) => [k, this.safeEval(e)])),
-    };
-    const frame: Frame = { label: this.cur.label, path: [...this.cur.path] };
-    this.stack.push(frame);
-    this.jump(target, args, frame);
-  }
-
-  private doReturn() {
-    const frame = this.stack.pop();
-    if (!frame) {
-      this.cur = { label: "", path: [0] };
-      return;
-    }
-    for (const [p, old] of Object.entries(frame.saved ?? {})) {
-      if (old.had) this.store[p] = old.value;
-      else delete this.store[p];
-    }
-    this.cur = { label: frame.label, path: frame.path };
-    this.advance();
-  }
-
-  private markSeen(label: string) {
-    const seen: string[] = this.persistent._seen ?? [];
-    if (!seen.includes(label)) this.persistent._seen = [...seen, label];
-  }
-
-  // --- main loop --------------------------------------------------------------------
-
-  private wait<T = void>(setup: (done: (v: T) => void) => void): Promise<T> {
-    const gen = this.gen;
-    return new Promise<T>((resolve, reject) => {
-      const wake = () => reject(new Restart());
-      this.waiters.push(wake);
-      setup((v) => {
-        this.waiters = this.waiters.filter((w) => w !== wake);
-        if (gen === this.gen) resolve(v);
-        else reject(new Restart());
-      });
-    });
-  }
-
-  private wakeAll() {
-    const ws = this.waiters;
-    this.waiters = [];
-    ws.forEach((w) => w());
-  }
-
-  private async loop() {
-    const gen = this.gen;
-    this.running = true;
-    try {
-      while (gen === this.gen) {
-        if (!this.cur.label) {
-          this.showMainMenu();
-          return;
-        }
-        const node = this.node();
-        if (!node) {
-          this.settle();
-          if (!this.node()) {
-            this.cur = { label: "", path: [0] };
-          }
-          continue;
-        }
-        try {
-          await this.exec(node);
-        } catch (err) {
-          if (err instanceof JumpSignal) {
-            if (err.kind === "jump") this.jump(err.target);
-            else this.call(err.target);
-          } else throw err;
-        }
-      }
-    } catch (err) {
-      if (err instanceof Restart) {
-        if (err.message === "__main_menu__") this.showMainMenu();
-        if (err.message === "__quit__") this.onExit();
-        return;
-      }
-      console.error(err);
-      this.notify(`Ошибка плеера: ${(err as Error).message}`);
-    } finally {
-      if (gen === this.gen) this.running = false;
-    }
-  }
-
-  private async exec(node: Node) {
-    switch (node.op) {
-      case "say":
-        await this.say(node);
-        this.advance();
-        return;
-      case "scene":
-      case "show":
-      case "hide": {
-        if (node.with) this.renderer.commit();
-        if (node.op === "scene") {
-          this.renderer.scene();
-          this.clearNvl();
-        }
-        if (node.op === "hide") this.renderer.hide(node.tag);
-        else if (node.img) this.showNode(node);
-        if (node.with) await this.renderer.transition(this.transition(node.with));
-        this.advance();
-        return;
-      }
-      case "with":
-        await this.renderer.transition(this.transition(node.t));
-        this.advance();
-        return;
-      case "play":
-      case "queue": {
-        const files = node.files.map((f: Expr) => this.audioFile(f)).filter(Boolean) as string[];
-        if (files.length) {
-          if (node.op === "play")
-            this.audio.play(node.ch, files, { loop: node.loop, fadein: node.fadein, fadeout: node.fadeout,
-                                              ifChanged: node.ifChanged });
-          else this.audio.queue(node.ch, files, node.loop);
-        }
-        this.advance();
-        return;
-      }
-      case "stop":
-        this.audio.stop(node.ch, node.fadeout ?? 0);
-        this.advance();
-        return;
-      case "voice":
-        if (node.file) {
-          const f = this.audioFile(node.file);
-          if (f) this.audio.play("voice", [f], { loop: false });
-        }
-        this.advance();
-        return;
-      case "pause": {
-        const d = node.d ? Number(this.safeEval(node.d)) : null;
-        await this.pause(d);
-        this.advance();
-        return;
-      }
-      case "menu":
-        return this.menu(node);
-      case "if": {
-        const i = node.branches.findIndex((b: any) => b.c === null || truthy(this.safeEval(b.c)));
-        if (i >= 0) this.enter(i);
-        else this.advance();
-        return;
-      }
-      case "while":
-        if (truthy(this.safeEval(node.c))) this.enter(0);
-        else this.advance();
-        return;
-      case "jump":
-        return this.jump(node.target ?? pyStr(this.safeEval(node.expr)));
-      case "call":
-        return this.call(node.target ?? pyStr(this.safeEval(node.expr)), node.args);
-      case "camera":
-        this.renderer.camera(node.at ?? []);
-        this.advance();
-        return;
-      case "return":
-        this.doReturn();
-        return;
-      case "exec":
-        try {
-          this.py.exec(node.code);
-        } catch (err) {
-          if (err instanceof JumpSignal) throw err;
-          console.warn("[pgvn] ошибка python", err, node.code);
-        }
-        this.advance();
-        return;
-      case "window":
-        this.windowShown = node.mode !== "hide";
-        if (!this.windowShown) this.textbox.classList.add("pg-hidden");
-        this.advance();
-        return;
-      case "nvl":
-        if (node.a === "clear") this.clearNvl();
-        else this.nvlEl.classList.toggle("pg-hidden", node.a === "hide");
-        this.advance();
-        return;
-      default:
-        this.advance();
-    }
-  }
-
-  private showNode(node: Node) {
-    const img = this.imageFromSpec(node.img);
-    if (!img) {
-      console.warn("[pgvn] нет изображения", node.img);
-      return;
-    }
-    const tag = node.as ?? (node.img.name ? node.img.name[0] : img.name[0]);
-    const zorder = node.zorder ? Number(this.safeEval(node.zorder)) : undefined;
-    this.renderer.show(img, tag, node.at ?? [], { zorder, behind: node.behind });
-  }
-
-  private transition(t: any) {
-    if (t && t.t === "ref") return this.game.transitions[t.name] ?? { t: "dissolve", d: 0.5 };
-    return t;
-  }
-
-  private audioFile(e: Expr): string | null {
-    if (e.k === "name" && this.game.audio[e.id] && !(e.id in this.store)) return this.game.audio[e.id];
-    const v = this.safeEval(e);
-    if (typeof v !== "string") return null;
-    return this.game.audio[v] ?? v;
-  }
-
-  // --- interactions -----------------------------------------------------------------
-
-  private interactionStart() {
-    this.renderer.commit();
-    this.interactions++;
-    if (this.interactions % 15 === 0) void this.save("auto", true);
-    this.preloadAhead();
-  }
-
-  private preloadAhead() {
-    const block = this.labels.has(this.cur.label) ? this.blockFor(this.cur) : [];
-    const start = this.cur.path[this.cur.path.length - 1];
-    for (const n of block.slice(start + 1, start + 12)) {
-      if ((n.op === "show" || n.op === "scene") && n.img?.name) this.renderer.preload(this.resolveImage(n.img.name)?.def ?? null);
-    }
-  }
-
-  private characterFor(node: Node): { char: CharacterDef; name: string; mode: string } {
-    const who: string | undefined = node.who;
-    if (node.whoStr !== undefined) return { char: {}, name: node.whoStr, mode: "adv" };
-    if (!who || who === "narrator") return { char: {}, name: "", mode: "adv" };
-    if (who === "centered" || who === "vcentered") return { char: {}, name: "", mode: "centered" };
-    if (who === "extend") return { char: this.lastSay?.char ?? {}, name: this.lastSay?.name ?? "", mode: "extend" };
-    if (who === "nvl") return { char: { nvl: true }, name: "", mode: "nvl" };
-    const char = this.game.characters[who];
-    if (!char) {
-      const v = this.store[who];
-      return { char: {}, name: typeof v === "string" ? v : who, mode: "adv" };
-    }
-    let name = char.name ?? "";
-    if (char.nameExpr) name = pyStr(this.safeEval(char.nameExpr));
-    name = this.interp(name);
-    return { char, name: `${char.whoPrefix ?? ""}${name}${char.whoSuffix ?? ""}`, mode: char.nvl ? "nvl" : "adv" };
-  }
-
-  private interp(s: string): string {
-    return interpolate(s, (expr) => this.lookupPath(expr));
-  }
-
-  private lookupPath(expr: string): any {
-    const m = expr.match(/^[A-Za-z_][\w]*/);
-    if (!m) return "";
-    let v = this.py.lookup(m[0]);
-    const rest = expr.slice(m[0].length);
-    for (const part of rest.matchAll(/\.(\w+)|\[(\d+|'[^']*'|"[^"]*")\]/g)) {
-      if (v === null || v === undefined) return "";
-      const k = part[1] ?? JSON.parse(part[2].replace(/^'|'$/g, '"'));
-      v = v instanceof PyDict ? v.get(k) : v[k];
-    }
-    return v ?? "";
-  }
-
-  private async say(node: Node, inMenu = false) {
-    const { char, name, mode } = this.characterFor(node);
-    if (node.attrs && char.image && this.renderer.isShown(char.image)) {
-      const img = this.resolveImage([char.image, ...node.attrs]);
-      if (img) this.renderer.show(img, char.image, []);
-    }
-    if (!inMenu) this.interactionStart();
-    if (node.with) await this.renderer.transition(this.transition(node.with));
-
-    let raw = this.interp(node.what);
-    raw = `${char.whatPrefix ?? ""}${raw}${char.whatSuffix ?? ""}`;
-    let prefixLen = 0;
-    if (mode === "extend" && this.lastSay) {
-      prefixLen = [...plainText(parseText(this.lastSay.text))].length;
-      raw = this.lastSay.text + raw;
-    }
-    const parsed = parseText(raw);
-    this.lastSay = { name, text: raw, color: char.color, char };
-    if (mode !== "extend") this.history.push({ name, text: plainText(parsed) });
-    else if (this.history.length) this.history[this.history.length - 1].text = plainText(parsed);
-    if (this.history.length > 300) this.history.shift();
-
-    let target: HTMLElement;
-    if (mode === "centered") {
-      this.textbox.classList.add("pg-hidden");
-      this.centeredEl.classList.remove("pg-hidden");
-      target = this.centeredEl;
-    } else if (mode === "nvl") {
-      this.textbox.classList.add("pg-hidden");
-      this.nvlEl.classList.remove("pg-hidden");
-      const line = el("div", "pg-nvl-line");
-      if (name) {
-        const who = el("span", "pg-nvl-name", name);
-        if (char.color) who.style.color = char.color;
-        line.append(who);
-      }
-      const what = el("span", "pg-nvl-what");
-      line.append(what);
-      this.nvlEl.append(line);
-      this.nvlLines.push(line);
-      target = what;
-    } else {
-      this.centeredEl.classList.add("pg-hidden");
-      this.nvlEl.classList.add("pg-hidden");
-      this.textbox.classList.remove("pg-hidden");
-      this.namebox.textContent = name;
-      this.namebox.classList.toggle("pg-hidden", !name);
-      this.namebox.style.color = char.color ?? "";
-      this.textEl.style.color = char.whatColor ?? "";
-      this.textEl.style.fontStyle = char.whatItalic ? "italic" : "";
-      this.textEl.style.fontWeight = char.whatBold ? "bold" : "";
-      target = this.textEl;
-    }
-
-    await this.typewrite(target, parsed, Math.max(prefixLen, fastPoint(parsed)), inMenu);
-    if (inMenu || node.interact === false) return;
-    if (!parsed.noWait) await this.waitAdvance(parsed.length);
-    this.audio.stop("voice");
-    this.centeredEl.classList.add("pg-hidden");
-  }
-
-  private async typewrite(target: HTMLElement, parsed: ReturnType<typeof parseText>, from: number, instant = false) {
-    this.ctc.remove();
-    const total = parsed.length;
-    const waits = waitPoints(parsed).filter((w) => w.at > from);
-    let shown = from;
-    const cps = this.settings.cps;
-    if (instant || cps <= 0 || this.skip) {
-      renderText(target, parsed, total, this.baseSize);
-      target.append(this.ctc);
-      return;
-    }
-    let completed = false;
-    const finishClick = () => {
-      completed = true;
-    };
-    this.onAdvance = finishClick;
-    try {
-      for (const stop of [...waits.map((w) => w.at), total]) {
-        let last = performance.now();
-        while (shown < stop && !completed && !this.skip) {
-          await this.frame();
-          const now = performance.now();
-          shown = Math.min(stop, shown + ((now - last) / 1000) * cps);
-          last = now;
-          renderText(target, parsed, Math.floor(shown), this.baseSize);
-        }
-        shown = completed || this.skip ? total : stop;
-        renderText(target, parsed, Math.floor(shown), this.baseSize);
-        if (completed || this.skip) break;
-        const w = waits.find((x) => x.at === stop);
-        if (w) {
-          if (w.seconds !== null) await this.pause(w.seconds);
-          else await this.waitAdvance(0);
-          this.onAdvance = finishClick;
-        }
-      }
-    } finally {
-      this.onAdvance = null;
-    }
-    target.append(this.ctc);
-  }
-
-  private frame(): Promise<void> {
-    return this.wait((done) => requestAnimationFrame(() => done()));
-  }
-
-  private onAdvance: (() => void) | null = null;
-
-  /** Wait for the player to advance (click/space), or skip/auto. */
-  private waitAdvance(chars: number): Promise<void> {
-    return this.wait((done) => {
-      let timer = 0;
-      const finish = () => {
-        clearTimeout(timer);
-        this.onAdvance = null;
-        this.skipTick = null;
-        done();
-      };
-      this.onAdvance = finish;
-      if (this.skip) timer = window.setTimeout(finish, 40);
-      else if (this.auto) timer = window.setTimeout(finish, (1 + chars / 20) * this.settings.autoDelay * 1000);
-      this.skipTick = () => {
-        clearTimeout(timer);
-        if (this.skip) timer = window.setTimeout(finish, 40);
-        else if (this.auto) timer = window.setTimeout(finish, 1000 * this.settings.autoDelay);
-      };
-    });
-  }
-
-  private skipTick: (() => void) | null = null;
-
-  private pause(seconds: number | null): Promise<void> {
-    if (seconds === null) {
-      this.interactionStart();
-      return this.waitAdvance(0);
-    }
-    if (this.skip) return Promise.resolve();
-    return this.wait((done) => {
-      const timer = window.setTimeout(() => {
-        this.onAdvance = null;
-        done();
-      }, seconds * 1000);
-      this.onAdvance = () => {
-        clearTimeout(timer);
-        this.onAdvance = null;
-        done();
-      };
-    });
-  }
-
-  private async menu(node: Node) {
-    this.interactionStart();
-    const chosen: string[] = node.set ? this.safeEval(node.set) ?? [] : [];
-    if (node.say) await this.say(node.say, true);
-    else if (!this.windowShown) this.textbox.classList.add("pg-hidden");
-    const items = node.items
-      .map((item: any, i: number) => ({ ...item, i }))
-      .filter((item: any) => (item.if === null || truthy(this.safeEval(item.if))) && !chosen.includes(item.text));
-    if (!items.length) {
-      this.advance();
-      return;
-    }
-    this.setSkip(false);
-    const index = await this.wait<number>((done) => {
-      this.menuEl.textContent = "";
-      for (const item of items) {
-        const b = el("button", "pg-choice");
-        renderText(b, parseText(this.interp(item.text)), Infinity, this.baseSize);
-        b.onclick = (ev) => {
-          ev.stopPropagation();
-          done(item.i);
-        };
-        this.menuEl.append(b);
-      }
-      this.menuEl.classList.remove("pg-hidden");
-    });
-    this.menuEl.classList.add("pg-hidden");
-    if (Array.isArray(chosen) && node.set) chosen.push(node.items[index].text);
-    this.history.push({ name: "", text: `→ ${plainText(parseText(this.interp(node.items[index].text)))}` });
-    this.enter(index);
-  }
-
-  private clearNvl() {
-    this.nvlLines.forEach((l) => l.remove());
-    this.nvlLines = [];
-    this.nvlEl.classList.add("pg-hidden");
-  }
-
-  private notify(msg: string) {
-    this.notifyEl.textContent = msg;
-    this.notifyEl.classList.remove("pg-hidden");
-    window.setTimeout(() => this.notifyEl.classList.add("pg-hidden"), 3000);
-  }
-
-  // --- session control --------------------------------------------------------------
-
-  private restart(setup: () => void) {
-    this.gen++;
-    this.wakeAll();
-    this.onAdvance = null;
-    this.skipTick = null;
-    this.closeScreen();
-    this.menuEl.classList.add("pg-hidden");
-    this.centeredEl.classList.add("pg-hidden");
-    this.clearNvl();
-    this.setSkip(false);
-    setup();
-    void this.loop();
-  }
-
-  start() {
-    this.showMainMenu();
-  }
-
-  private newGame() {
-    this.restart(() => {
-      this.audio.stopAll();
-      this.renderer.scene();
-      this.renderer.camera([]);
-      this.renderer.commit();
-      this.newStore();
-      this.stack = [];
-      this.history = [];
-      this.lastSay = null;
-      this.textbox.classList.add("pg-hidden");
-      this.cur = { label: this.game.entry, path: [0] };
-      this.markSeen(this.game.entry);
-      this.settle();
-    });
-  }
-
-  private snapshotState(): SaveData {
-    return {
-      v: 1,
-      cur: { label: this.cur.label, path: [...this.cur.path] },
-      stack: this.stack.map((f) => ({ label: f.label, path: [...f.path], saved: encodeValue(f.saved) })),
-      store: encodeValue(this.store),
-      scene: this.renderer.snapshot(),
-      music: this.audio.current("music"),
-      window: this.windowShown,
-      camera: this.renderer.cameraAt,
-      text: this.lastSay ? `${this.lastSay.name ? this.lastSay.name + ": " : ""}${plainText(parseText(this.lastSay.text))}` : "",
-    };
-  }
-
-  private async save(slot: string, silent = false) {
-    if (!this.running || !this.cur.label) return;
-    const data = this.snapshotState();
-    const title = (data.text ?? "").slice(0, 120) || this.cur.label;
-    try {
-      await this.saves.put(slot, title, data);
-      if (!silent) this.notify("Сохранено");
-    } catch (err) {
-      if (!silent) this.notify(`Не удалось сохранить: ${(err as Error).message}`);
-    }
-  }
-
-  private async load(slot: string) {
-    const data = await this.saves.get(slot);
-    if (!data) {
-      this.notify("Сохранение не найдено");
-      return;
-    }
-    if (!this.labels.has(data.cur.label)) {
-      this.notify("Сохранение не подходит к этой версии игры");
-      return;
-    }
-    this.restart(() => {
-      this.resetStore();
-      Object.assign(this.store, decodeValue(data.store));
-      this.renderer.scene();
-      for (const s of data.scene) {
-        const img = this.resolveImage(s.name);
-        if (img) this.renderer.show(img, s.tag, s.at, { zorder: s.zorder });
-      }
-      this.renderer.commit();
-      this.audio.stopAll();
-      if (data.music) this.audio.play("music", [data.music.file], { loop: data.music.loop, fadein: 0.5 });
-      this.windowShown = data.window;
-      this.renderer.camera(data.camera ?? []);
-      this.stack = data.stack.map((f) => ({ ...f, saved: decodeValue(f.saved) }));
-      this.cur = data.cur;
-      this.lastSay = null;
-      this.history = [];
-    });
-  }
-
-  private setSkip(on: boolean) {
-    this.skip = on;
-    this.renderer.fast = on;
-    this.quick?.querySelector("[data-act=skip]")?.classList.toggle("pg-on", on);
-    this.skipTick?.();
-  }
-
-  private setAuto(on: boolean) {
-    this.auto = on;
-    this.quick.querySelector("[data-act=auto]")?.classList.toggle("pg-on", on);
-    this.skipTick?.();
-  }
-
-  // --- UI -------------------------------------------------------------------------
-
-  private buildUI() {
-    const { ui } = this.game;
-    const [w, h] = this.game.resolution;
-    const stage = this.renderer.stage;
-    const px = (v: any, total: number, fallback: number) =>
-      typeof v === "number" ? (Number.isInteger(v) && v > 1 ? v : v * total) : fallback;
-    stage.style.setProperty("--pg-font", `${this.baseSize}px`);
-    stage.style.setProperty("--pg-name-font", `${Number(ui.name_text_size) || Math.round(this.baseSize * 1.2)}px`);
-    if (ui.accent_color) stage.style.setProperty("--pg-accent", ui.accent_color);
-    if (ui.text_color) stage.style.setProperty("--pg-text", ui.text_color);
-    this.loadFont("pg-game-font", ui.text_font);
-    this.loadFont("pg-game-name-font", ui.name_text_font ?? ui.text_font);
-
-    this.textbox = el("div", "pg-textbox pg-hidden");
-    const boxH = px(ui.textbox_height, h, Math.round(h * 0.257));
-    this.textbox.style.height = `${boxH}px`;
-    if (ui.textbox) {
-      const url = this.fileUrl(ui.textbox);
-      if (url) this.textbox.style.backgroundImage = `url("${url}")`;
-      this.textbox.classList.add("pg-textbox-image");
-    }
-    this.namebox = el("div", "pg-namebox");
-    this.namebox.style.left = `${px(ui.name_xpos, w, Math.round(w * 0.1875))}px`;
-    this.namebox.style.transform = "translateX(-50%)";
-    if (!ui.name_xpos) this.namebox.style.transform = "";
-    this.textEl = el("div", "pg-text");
-    this.textEl.style.left = `${px(ui.dialogue_xpos, w, Math.round(w * 0.21))}px`;
-    this.textEl.style.top = `${px(ui.dialogue_ypos, boxH, Math.round(boxH * 0.18))}px`;
-    this.textEl.style.width = `${px(ui.dialogue_width, w, Math.round(w * 0.58))}px`;
-    this.ctc = el("span", "pg-ctc", "▼");
-    this.textbox.append(this.namebox, this.textEl);
-
-    this.quick = el("div", "pg-quick");
-    const actions: [string, string, () => void][] = [
-      ["history", "История", () => this.openHistory()],
-      ["skip", "Пропуск", () => this.setSkip(!this.skip)],
-      ["auto", "Авто", () => this.setAuto(!this.auto)],
-      ["save", "Сохр.", () => this.openSaves("save")],
-      ["load", "Загр.", () => this.openSaves("load")],
-      ["qsave", "Б.Сохр.", () => void this.save("quick")],
-      ["qload", "Б.Загр.", () => void this.load("quick")],
-      ["prefs", "Настройки", () => this.openSettings()],
-      ["menu", "Меню", () => this.openGameMenu()],
-    ];
-    for (const [act, label, fn] of actions) {
-      const b = el("button", "", label);
-      b.dataset.act = act;
-      b.onclick = (ev) => {
-        ev.stopPropagation();
-        fn();
-      };
-      this.quick.append(b);
-    }
-    this.textbox.append(this.quick);
-
-    this.menuEl = el("div", "pg-menu pg-hidden");
-    this.nvlEl = el("div", "pg-nvl pg-hidden");
-    if (ui.nvl) {
-      const url = this.fileUrl(ui.nvl);
-      if (url) this.nvlEl.style.backgroundImage = `url("${url}")`;
-    }
-    this.centeredEl = el("div", "pg-centered pg-hidden");
-    this.screen = el("div", "pg-screen pg-hidden");
-    this.notifyEl = el("div", "pg-notify pg-hidden");
-    stage.append(this.nvlEl, this.textbox, this.centeredEl, this.menuEl, this.screen, this.notifyEl);
-
-    stage.addEventListener("click", (ev) => {
-      if (!this.screen.classList.contains("pg-hidden")) return;
-      if ((ev.target as HTMLElement).closest(".pg-menu, .pg-quick")) return;
-      this.advanceInput();
-    });
-    stage.addEventListener("wheel", (ev) => {
-      if (ev.deltaY < 0 && this.screen.classList.contains("pg-hidden") && this.running) this.openHistory();
-    }, { passive: true });
-  }
-
-  private loadFont(family: string, file?: string) {
-    const url = file ? this.fileUrl(file) : null;
-    if (!url) return;
-    const face = new FontFace(family, `url("${url}")`);
-    face.load().then((f) => {
-      document.fonts.add(f);
-      this.renderer.stage.classList.add(family);
-    }).catch(() => {});
-  }
-
-  private advanceInput() {
-    if (this.skip) {
-      this.setSkip(false);
-      return;
-    }
-    if (!this.textbox.classList.contains("pg-ui-hidden")) this.onAdvance?.();
-    this.textbox.classList.remove("pg-ui-hidden");
-  }
-
-  private onKey = (ev: KeyboardEvent) => {
-    if ((ev.target as HTMLElement)?.tagName === "INPUT") return;
-    const screenOpen = !this.screen.classList.contains("pg-hidden");
-    if (ev.key === "Escape") {
-      if (this.screen.classList.contains("pg-main")) return;
-      if (screenOpen) this.dismissScreen();
-      else if (this.running) this.openGameMenu();
-      return;
-    }
-    if (screenOpen) return;
-    if (ev.key === " " || ev.key === "Enter") {
-      ev.preventDefault();
-      this.advanceInput();
-    } else if (ev.key === "Control" && !this.skip) {
-      this.setSkip(true);
-    } else if (ev.key === "Tab") {
-      ev.preventDefault();
-      this.setSkip(!this.skip);
-    } else if (ev.key === "a" || ev.key === "ф") {
-      this.setAuto(!this.auto);
-    } else if (ev.key === "h" || ev.key === "р") {
-      this.textbox.classList.toggle("pg-ui-hidden");
-    }
-  };
-
-  private onKeyUp = (ev: KeyboardEvent) => {
-    if (ev.key === "Control") this.setSkip(false);
-  };
-
-  private screenOnClose: (() => void) | null = null;
-
-  private openScreen(title: string, build: (body: HTMLElement) => void, onClose?: () => void) {
-    this.screen.textContent = "";
-    this.screen.classList.remove("pg-main");
-    this.screen.style.backgroundImage = "";
-    this.screenOnClose = onClose ?? null;
-    const head = el("div", "pg-screen-head");
-    head.append(el("h2", "", title));
-    const close = el("button", "pg-close", "✕");
-    close.onclick = () => this.dismissScreen();
-    head.append(close);
-    const body = el("div", "pg-screen-body");
-    this.screen.append(head, body);
-    build(body);
-    this.screen.classList.remove("pg-hidden");
-  }
-
-  private dismissScreen() {
-    const fn = this.screenOnClose;
-    if (fn) fn();
-    else this.closeScreen();
-  }
-
-  private closeScreen() {
-    this.screenOnClose = null;
-    this.screen.classList.add("pg-hidden");
-    this.screen.classList.remove("pg-main");
-    this.screen.style.backgroundImage = "";
-  }
-
-  private showMainMenu() {
-    this.running = false;
-    this.gen++;
-    this.wakeAll();
-    this.audio.stopAll();
-    this.textbox.classList.add("pg-hidden");
-    this.menuEl.classList.add("pg-hidden");
-    this.clearNvl();
-    this.screen.textContent = "";
-    this.screen.classList.add("pg-main");
-    const bg = this.game.ui.mainMenu ? this.fileUrl(this.game.ui.mainMenu) : null;
-    if (bg) this.screen.style.backgroundImage = `url("${bg}")`;
-    const panel = el("div", "pg-main-panel");
-    panel.append(el("h1", "", this.game.title ?? "Новелла"));
-    const btn = (label: string, fn: () => void) => {
-      const b = el("button", "", label);
-      b.onclick = fn;
-      panel.append(b);
-      return b;
-    };
-    btn("Начать", () => this.newGame());
-    const cont = btn("Продолжить", () => void this.load("auto"));
-    cont.style.display = "none";
-    this.saves.list().then((list) => {
-      if (list.some((s) => s.slot === "auto")) cont.style.display = "";
-    }).catch(() => {});
-    btn("Загрузить", () => this.openSaves("load", true));
-    btn("Настройки", () => this.openSettings(true));
-    btn("В библиотеку", () => this.onExit());
-    this.screen.append(panel);
-    this.screen.classList.remove("pg-hidden");
-  }
-
-  private openGameMenu() {
-    this.openScreen("Меню", (body) => {
-      const list = el("div", "pg-menu-list");
-      const add = (label: string, fn: () => void) => {
-        const b = el("button", "", label);
-        b.onclick = fn;
-        list.append(b);
-      };
-      add("Вернуться", () => this.closeScreen());
-      add("Сохранить", () => this.openSaves("save"));
-      add("Загрузить", () => this.openSaves("load"));
-      add("Настройки", () => this.openSettings());
-      add("Главное меню", () => {
-        if (confirm("Выйти в главное меню? Несохранённый прогресс будет потерян.")) this.showMainMenu();
-      });
-      add("В библиотеку", () => this.onExit());
-      body.append(list);
-    });
-  }
-
-  private openHistory() {
-    this.openScreen("История", (body) => {
-      const list = el("div", "pg-history");
-      for (const h of this.history) {
-        const row = el("div", "pg-history-row");
-        if (h.name) row.append(el("b", "", h.name));
-        row.append(el("span", "", h.text));
-        list.append(row);
-      }
-      body.append(list);
-      requestAnimationFrame(() => (list.scrollTop = list.scrollHeight));
-    });
-  }
-
-  private openSaves(mode: "save" | "load", fromMain = false) {
-    this.openScreen(mode === "save" ? "Сохранить" : "Загрузить", (body) => {
-      const grid = el("div", "pg-slots");
-      body.append(grid);
-      const render = (list: SaveMeta[]) => {
-        grid.textContent = "";
-        const bySlot = new Map(list.map((s) => [s.slot, s]));
-        const slots = [...(mode === "load" ? ["auto", "quick"] : []),
-                       ...Array.from({ length: SLOTS }, (_, i) => String(i + 1))];
-        for (const slot of slots) {
-          const meta = bySlot.get(slot);
-          const card = el("button", "pg-slot");
-          const label = slot === "auto" ? "Авто" : slot === "quick" ? "Быстрое" : `Слот ${slot}`;
-          card.append(el("b", "", label));
-          card.append(el("span", "pg-slot-title", meta ? meta.title : "Пусто"));
-          if (meta) card.append(el("small", "", new Date(meta.updated_at).toLocaleString()));
-          card.disabled = mode === "load" && !meta;
-          card.onclick = async () => {
-            if (mode === "save") {
-              if (meta && !confirm("Перезаписать сохранение?")) return;
-              await this.save(slot);
-              render(await this.saves.list());
-            } else {
-              await this.load(slot);
-            }
-          };
-          grid.append(card);
-        }
-      };
-      this.saves.list().then(render).catch((e) => this.notify(String(e)));
-    }, fromMain ? () => this.showMainMenu() : undefined);
-  }
-
-  private openSettings(fromMain = false) {
-    this.openScreen("Настройки", (body) => {
-      const s = this.settings;
-      const row = (label: string, min: number, max: number, step: number, value: number,
-                   fmt: (v: number) => string, set: (v: number) => void) => {
-        const r = el("label", "pg-setting");
-        const out = el("span", "pg-setting-val", fmt(value));
-        const input = el("input");
-        Object.assign(input, { type: "range", min, max, step, value: String(value) });
-        input.oninput = () => {
-          set(Number(input.value));
-          out.textContent = fmt(Number(input.value));
-          saveJSON("pgvn:settings", this.settings);
-          this.audio.setVolumes(this.settings);
-        };
-        r.append(el("span", "", label), input, out);
-        body.append(r);
-      };
-      row("Скорость текста", 0, 150, 5, s.cps, (v) => (v === 0 ? "мгновенно" : `${v} симв/с`), (v) => (s.cps = v));
-      row("Задержка авто", 0.3, 4, 0.1, s.autoDelay, (v) => `${v.toFixed(1)} с`, (v) => (s.autoDelay = v));
-      row("Музыка", 0, 1, 0.05, s.music, (v) => `${Math.round(v * 100)}%`, (v) => (s.music = v));
-      row("Звуки", 0, 1, 0.05, s.sound, (v) => `${Math.round(v * 100)}%`, (v) => (s.sound = v));
-      row("Голос", 0, 1, 0.05, s.voice, (v) => `${Math.round(v * 100)}%`, (v) => (s.voice = v));
-      const fs = el("button", "pg-wide", "Полный экран");
-      fs.onclick = () => {
-        if (document.fullscreenElement) void document.exitFullscreen();
-        else void this.root.requestFullscreen();
-      };
-      body.append(fs);
-    }, fromMain ? () => this.showMainMenu() : undefined);
-  }
-}
-
-function childBlock(node: Node, branch: number): Node[] {
-  if (node.op === "if") return node.branches[branch].body;
-  if (node.op === "menu") return node.items[branch].body;
-  return node.body;
-}
-
-export type { ImageDef };
+// PGVN interpreter + in-game UI.
+
+import { AudioSystem, type Volumes } from "./audio";
+import { JumpSignal, PyDict, Python, decodeValue, encodeValue, pyStr, truthy, type Scope } from "./python";
+import { Renderer, type ResolvedImage } from "./renderer";
+import { fastPoint, interpolate, parseText, plainText, renderText, waitPoints } from "./text";
+import { languageName, rememberLanguage, type Translator } from "./i18n";
+import type {
+  CharacterDef, Expr, Frame, GameData, ImageDef, Label, Layer, Manifest, Node, SaveData, ScriptModule,
+} from "./types";
+
+export interface SaveMeta {
+  slot: string;
+  title: string;
+  updated_at: string;
+}
+
+export interface SaveApi {
+  list(): Promise<SaveMeta[]>;
+  get(slot: string): Promise<SaveData | null>;
+  put(slot: string, title: string, data: SaveData): Promise<void>;
+  remove(slot: string): Promise<void>;
+}
+
+interface Settings extends Volumes {
+  cps: number; // characters per second, 0 = instant
+  autoDelay: number; // seconds per 20 characters in auto mode
+}
+
+const DEFAULT_SETTINGS: Settings = { cps: 45, autoDelay: 1.2, music: 0.7, sound: 0.8, voice: 1 };
+const SLOTS = 12;
+
+interface LabelRef {
+  label: Label;
+  module: ScriptModule;
+  index: number;
+}
+
+class Restart extends Error {}
+
+function el<K extends keyof HTMLElementTagNameMap>(tag: K, cls = "", text = ""): HTMLElementTagNameMap[K] {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text) e.textContent = text;
+  return e;
+}
+
+function loadJSON<T>(key: string, fallback: T): T {
+  try {
+    const raw = localStorage.getItem(key);
+    return raw ? { ...fallback, ...JSON.parse(raw) } : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function saveJSON(key: string, value: unknown) {
+  try {
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch {
+    /* storage unavailable */
+  }
+}
+
+export class Engine {
+  private labels = new Map<string, LabelRef>();
+  private anchors = new Map<string, { label: string; path: number[]; params?: [string, Expr | null][] | null }>();
+  private imagesByTag = new Map<string, { attrs: string[]; key: string }[]>();
+  private store: Record<string, any> = {};
+  private builtins: Record<string, any> = {};
+  private persistent: Record<string, any>;
+  private py: Python;
+  private renderer: Renderer;
+  private audio: AudioSystem;
+  private settings: Settings;
+
+  private cur: Frame = { label: "", path: [0] };
+  private stack: Frame[] = [];
+  private gen = 0;
+  private waiters: (() => void)[] = [];
+  private running = false;
+
+  private skip = false;
+  private auto = false;
+  private windowShown = true;
+  private lastSay: { name: string; text: string; color?: string; char?: CharacterDef } | null = null;
+  private history: { name: string; text: string }[] = [];
+  private nvlLines: HTMLElement[] = [];
+  private interactions = 0;
+
+  // UI
+  private container: HTMLDivElement;
+  private textbox!: HTMLDivElement;
+  private namebox!: HTMLDivElement;
+  private textEl!: HTMLDivElement;
+  private ctc!: HTMLSpanElement;
+  private menuEl!: HTMLDivElement;
+  private nvlEl!: HTMLDivElement;
+  private centeredEl!: HTMLDivElement;
+  private quick!: HTMLDivElement;
+  private screen!: HTMLDivElement;
+  private notifyEl!: HTMLDivElement;
+  private baseSize: number;
+  private resizeObserver: ResizeObserver;
+
+  constructor(
+    private root: HTMLElement,
+    private game: GameData,
+    private manifest: Manifest,
+    modules: ScriptModule[],
+    private saves: SaveApi,
+    private persistentKey: string,
+    private onExit: () => void,
+    private tr: Translator,
+    private loadLocale: (lang: string) => Promise<Translator>,
+  ) {
+    for (const mod of modules) {
+      let global = "";
+      mod.labels.forEach((label, index) => {
+        if (label.name.startsWith(".")) label.name = global + label.name;
+        else global = label.name.split(".")[0];
+        this.labels.set(label.name, { label, module: mod, index });
+      });
+      for (const [name, anchor] of Object.entries(mod.anchors ?? {})) this.anchors.set(name, anchor);
+    }
+    for (const key of Object.keys(game.images)) {
+      const [tag, ...attrs] = key.split(" ");
+      if (!this.imagesByTag.has(tag)) this.imagesByTag.set(tag, []);
+      this.imagesByTag.get(tag)!.push({ attrs, key });
+    }
+
+    this.settings = loadJSON("pgvn:settings", DEFAULT_SETTINGS);
+    this.persistent = this.makePersistent();
+    const scope: Scope = {
+      get: (n) => (n in this.store ? this.store[n] : this.builtins[n]),
+      has: (n) => n in this.store || n in this.builtins,
+      set: (n, v) => void (this.store[n] = v),
+      del: (n) => void delete this.store[n],
+    };
+    this.py = new Python(scope);
+    this.builtins = this.makeBuiltins();
+
+    const [w, h] = game.resolution;
+    this.baseSize = Number(game.ui.text_size) || Math.round(h * 0.0306);
+    this.container = el("div", "pg-root");
+    root.append(this.container);
+    this.renderer = new Renderer(this.container, w, h, {
+      url: (f) => this.fileUrl(f),
+      resolveRef: (name) => this.resolveImage(name.split(" "))?.def ?? null,
+      evalCond: (c) => truthy(this.safeEval(c)),
+      transform: (name) => game.transforms[name] ?? null,
+      text: (e) => this.interp(this.tr.str(pyStr(this.safeEval(e)))),
+    });
+    this.audio = new AudioSystem(this.settings, (f) => this.fileUrl(f), game.channels ?? {});
+    this.buildUI();
+    this.resizeObserver = new ResizeObserver(() => this.renderer.fit(this.container));
+    this.resizeObserver.observe(this.container);
+    this.renderer.fit(this.container);
+    window.addEventListener("keydown", this.onKey);
+    window.addEventListener("keyup", this.onKeyUp);
+  }
+
+  destroy() {
+    this.gen++;
+    this.wakeAll();
+    this.audio.stopAll();
+    this.resizeObserver.disconnect();
+    window.removeEventListener("keydown", this.onKey);
+    window.removeEventListener("keyup", this.onKeyUp);
+    this.container.remove();
+  }
+
+  // --- files & images ----------------------------------------------------------
+
+  fileUrl(path: string): string | null {
+    const clean = path.replace(/^<[^>]*>/, "").replace(/\\/g, "/").replace(/^\/+/, "");
+    let logical: string | undefined = this.manifest.files[clean] ? clean : undefined;
+    if (!logical) {
+      const low = clean.toLowerCase();
+      for (const prefix of ["", "images/", "audio/", "music/", "sound/", "sounds/"]) {
+        logical = this.game.files[prefix + low];
+        if (logical) break;
+      }
+    }
+    const entry = logical ? this.manifest.files[logical] : undefined;
+    return entry ? `/blobs/${entry.hash}` : null;
+  }
+
+  private resolveImage(name: string[]): ResolvedImage | null {
+    const full = name.join(" ");
+    const [tag, ...attrs] = name;
+    const layered = this.game.images[tag];
+    if (layered?.layered) return this.resolveLayered(tag, layered, attrs);
+    if (this.game.images[full]) return { def: this.game.images[full], name };
+    const candidates = this.imagesByTag.get(tag) ?? [];
+    let best: { attrs: string[]; key: string } | null = null;
+    for (const c of candidates) {
+      if (attrs.every((a) => c.attrs.includes(a)) && (!best || c.attrs.length < best.attrs.length)) best = c;
+    }
+    if (!best && attrs.length) {
+      // keep attributes of the currently shown image that the new ones don't replace
+      const current = this.renderer.attrsOf(tag)?.slice(1) ?? [];
+      for (const c of candidates) {
+        if (attrs.every((a) => c.attrs.includes(a)) || !c.attrs.some((a) => attrs.includes(a))) continue;
+        const keeps = current.filter((a) => c.attrs.includes(a)).length;
+        if (!best || keeps > 0) best = c;
+      }
+    }
+    if (!best) return null;
+    return { def: this.game.images[best.key], name: best.key.split(" ") };
+  }
+
+  /** Attributes of a layeredimage: new ones replace current ones of the same group. */
+  private resolveLayered(tag: string, def: ImageDef, attrs: string[]): ResolvedImage {
+    const layers = def.layered!;
+    const groupOf = (a: string) => layers.find((l) => l.attr === a)?.group ?? null;
+    const removed = attrs.filter((a) => a.startsWith("-")).map((a) => a.slice(1));
+    const added = attrs.filter((a) => !a.startsWith("-"));
+    const current = (this.renderer.attrsOf(tag)?.slice(1) ?? []).filter((a) => {
+      if (removed.includes(a)) return false;
+      const g = groupOf(a);
+      return !added.some((n) => n === a || (g !== null && groupOf(n) === g));
+    });
+    const selected = [...current, ...added];
+    // `group x auto`: attributes backed by images named <tag>_<group>_<attr>
+    const extra: Layer[] = [];
+    for (const l of layers) {
+      if (!l.autoGroup) continue;
+      for (const a of selected) {
+        const ref = `${tag}_${l.autoGroup}_${a}`;
+        if (this.game.images[ref] && !layers.some((x) => x.attr === a))
+          extra.push({ attr: a, group: l.autoGroup, img: { ref } });
+      }
+    }
+    return { def: { ...def, layered: [...layers, ...extra], selected }, name: [tag, ...selected] };
+  }
+
+  private imageFromSpec(spec: any): ResolvedImage | null {
+    if (spec.name) return this.resolveImage(spec.name);
+    if (spec.text !== undefined) return { def: { text: spec.text }, name: ["text"] };
+    if (spec.textExpr) return { def: { textExpr: spec.textExpr }, name: ["text"] };
+    if (spec.expr) {
+      const v = this.safeEval(spec.expr);
+      if (typeof v !== "string") return null;
+      if (v.startsWith("#")) return { def: { color: v }, name: [v] };
+      if (v.includes(".")) return { def: { file: v }, name: [v.split("/").pop()!.split(".")[0]] };
+      return this.resolveImage(v.split(" "));
+    }
+    return null;
+  }
+
+  // --- python environment ----------------------------------------------------------
+
+  private safeEval(e: Expr | null | undefined): any {
+    try {
+      return this.py.eval(e);
+    } catch (err) {
+      if (err instanceof JumpSignal) throw err;
+      console.warn("[pgvn] ошибка выражения", err);
+      return null;
+    }
+  }
+
+  private makePersistent(): Record<string, any> {
+    const data = decodeValue(loadJSON<Record<string, any>>(this.persistentKey, {}));
+    const save = () => saveJSON(this.persistentKey, encodeValue(data));
+    return new Proxy(data, {
+      get: (t, k: string) => (k in t ? t[k] : k === "toJSON" ? undefined : null),
+      set: (t, k: string, v) => {
+        t[k] = v;
+        save();
+        return true;
+      },
+    });
+  }
+
+  private makeBuiltins(): Record<string, any> {
+    const kwless = (args: any[]) =>
+      args.length && args[args.length - 1]?.__kw ? args.slice(0, -1) : args;
+    const kwOf = (args: any[]) => (args.length && args[args.length - 1]?.__kw) || {};
+    const random = {
+      randint: (a: number, b: number) => a + Math.floor(Math.random() * (b - a + 1)),
+      random: () => Math.random(),
+      choice: (xs: any[]) => xs[Math.floor(Math.random() * xs.length)],
+      shuffle: (xs: any[]) => {
+        for (let i = xs.length - 1; i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [xs[i], xs[j]] = [xs[j], xs[i]];
+        }
+      },
+      uniform: (a: number, b: number) => a + Math.random() * (b - a),
+    };
+    const music = (ch: string) => ({
+      play: (...a: any[]) => {
+        const kw = kwOf(a);
+        const files = kwless(a)[0];
+        this.audio.play(kw.channel ?? ch, (Array.isArray(files) ? files : [files]).map(String),
+                        { loop: kw.loop, fadein: kw.fadein, fadeout: kw.fadeout });
+      },
+      queue: (...a: any[]) => {
+        const kw = kwOf(a);
+        const files = kwless(a)[0];
+        this.audio.queue(kw.channel ?? ch, (Array.isArray(files) ? files : [files]).map(String), kw.loop);
+      },
+      stop: (...a: any[]) => this.audio.stop(kwOf(a).channel ?? ch, kwOf(a).fadeout ?? 0),
+      set_volume: () => {},
+      get_playing: () => this.audio.current(ch)?.file ?? null,
+      is_playing: () => this.audio.current(ch) !== null,
+    });
+    const renpyImpl: Record<string, any> = {
+      random,
+      music: music("music"),
+      sound: music("sound"),
+      play: (f: string, ...a: any[]) => this.audio.play(kwOf(a).channel ?? "sound", [f], {}),
+      notify: (msg: any) => this.notify(pyStr(msg)),
+      jump: (label: string) => {
+        throw new JumpSignal("jump", label);
+      },
+      call: (label: string) => {
+        throw new JumpSignal("call", label);
+      },
+      input: (...a: any[]) => {
+        const [prompt, def] = kwless(a);
+        const kw = kwOf(a);
+        const v = window.prompt(pyStr(prompt ?? ""), pyStr(def ?? kw.default ?? ""));
+        return (v ?? pyStr(def ?? kw.default ?? "")).slice(0, kw.length ?? 1000);
+      },
+      has_label: (l: string) => this.labels.has(l),
+      seen_label: (l: string) => truthy(this.persistent._seen?.includes?.(l)),
+      showing: (tag: string) => this.renderer.isShown(String(tag).split(" ")[0]),
+      get_attributes: (tag: string) => this.renderer.attrsOf(tag)?.slice(1) ?? [],
+      full_restart: () => {
+        throw new JumpSignal("jump", "__main_menu__");
+      },
+      quit: () => {
+        throw new JumpSignal("jump", "__quit__");
+      },
+      version: () => "pgvn",
+    };
+    const renpy = new Proxy(renpyImpl, {
+      get: (t, k: string) => {
+        if (k in t) return t[k];
+        this.py.warnOnce(`renpy.${k} не поддерживается — пропущено`);
+        return () => null;
+      },
+    });
+    const num = (x: any) => (typeof x === "string" ? Number(x.trim()) : Number(x));
+    return {
+      renpy,
+      persistent: this.persistent,
+      config: {},
+      // games branch on the Ren'Py language name ("russian"); None means the source language
+      preferences: this.languagePrefs(),
+      _preferences: this.languagePrefs(),
+      gui: {},
+      store: new Proxy({}, { get: (_t, k: string) => this.store[k] ?? null,
+                             set: (_t, k: string, v) => ((this.store[k] = v), true) }),
+      audio: this.game.audio,
+      random,
+      math: { floor: Math.floor, ceil: Math.ceil, sqrt: Math.sqrt, pi: Math.PI, pow: Math.pow },
+      len: (x: any) => (x instanceof PyDict ? x.map.size : x?.length ?? 0),
+      str: (x: any) => pyStr(x),
+      int: (x: any) => Math.trunc(num(x)),
+      float: (x: any) => num(x),
+      bool: (x: any) => truthy(x),
+      abs: Math.abs,
+      round: (x: number, n = 0) => Math.round(x * 10 ** n) / 10 ** n,
+      min: (...a: any[]) => (a.length === 1 ? Math.min(...a[0]) : Math.min(...a)),
+      max: (...a: any[]) => (a.length === 1 ? Math.max(...a[0]) : Math.max(...a)),
+      sum: (xs: number[]) => xs.reduce((s, x) => s + x, 0),
+      any: (xs: any[]) => xs.some(truthy),
+      all: (xs: any[]) => xs.every(truthy),
+      range: (a: number, b?: number, step = 1) => {
+        const [lo, hi] = b === undefined ? [0, a] : [a, b];
+        const out: number[] = [];
+        for (let i = lo; step > 0 ? i < hi : i > hi; i += step) out.push(i);
+        return out;
+      },
+      list: (xs: any = []) => [...(xs instanceof PyDict ? xs.map.keys() : xs)],
+      tuple: (xs: any = []) => [...xs],
+      set: (xs: any = []) => [...new Set(xs)],
+      dict: (...a: any[]) => {
+        const d = new PyDict(Array.isArray(kwless(a)[0]) ? kwless(a)[0] : []);
+        for (const [k, v] of Object.entries(kwOf(a))) d.set(k, v);
+        return d;
+      },
+      sorted: (xs: any[]) => [...xs].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
+      reversed: (xs: any[]) => [...xs].reverse(),
+      enumerate: (xs: any[]) => [...xs].map((x, i) => [i, x]),
+      zip: (...lists: any[][]) => lists[0].map((_, i) => lists.map((l) => l[i])),
+      isinstance: () => false,
+      _: (s: string) => s,
+      __: (s: string) => this.tr.str(s),
+    };
+  }
+
+  private languagePrefs() {
+    const engine = this;
+    return {
+      get language() {
+        return engine.tr.renpyName;
+      },
+    };
+  }
+
+  private async setLanguage(lang: string) {
+    try {
+      this.tr = await this.loadLocale(lang);
+      rememberLanguage(lang);
+      this.notify(languageName(this.game, lang));
+    } catch (err) {
+      this.notify(`Не удалось загрузить язык: ${(err as Error).message}`);
+    }
+  }
+
+  private resetStore() {
+    this.store = {};
+    try {
+      this.py.exec(this.game.init);
+    } catch (err) {
+      console.warn("[pgvn] ошибка init", err);
+    }
+  }
+
+  private newStore() {
+    this.resetStore();
+    for (const [name, e] of this.game.defaults) {
+      if (!(name in this.store)) this.store[name] = this.safeEval(e);
+    }
+  }
+
+  // --- control flow ------------------------------------------------------------------
+
+  private blockFor(frame: Frame): Node[] {
+    let block = this.labels.get(frame.label)!.label.body;
+    for (let k = 0; k < frame.path.length - 1; k += 2) {
+      block = childBlock(block[frame.path[k]], frame.path[k + 1]);
+    }
+    return block;
+  }
+
+  private node(): Node | null {
+    if (!this.labels.has(this.cur.label)) return null;
+    return this.blockFor(this.cur)[this.cur.path[this.cur.path.length - 1]] ?? null;
+  }
+
+  /** After a path change, move past ended blocks (falling through labels / looping whiles). */
+  private settle() {
+    for (let guard = 0; guard < 10000; guard++) {
+      const p = this.cur.path;
+      if (!this.labels.has(this.cur.label)) return;
+      const block = this.blockFor(this.cur);
+      if (p[p.length - 1] < block.length) return;
+      if (p.length === 1) {
+        const ref = this.labels.get(this.cur.label)!;
+        const next = ref.module.labels[ref.index + 1];
+        if (next) {
+          this.cur = { label: next.name, path: [0] };
+          continue;
+        }
+        this.doReturn();
+        return;
+      }
+      const parent = p.slice(0, -2);
+      const parentNode = this.blockFor({ label: this.cur.label, path: parent })[parent[parent.length - 1]];
+      this.cur.path = parent;
+      if (parentNode.op !== "while") this.cur.path[parent.length - 1]++;
+    }
+  }
+
+  private advance() {
+    this.cur.path[this.cur.path.length - 1]++;
+    this.settle();
+  }
+
+  private enter(branch: number) {
+    this.cur.path.push(branch, 0);
+    this.settle();
+  }
+
+  private jump(target: string, args?: { a: any[]; kw: Record<string, any> }, frame?: Frame) {
+    if (target === "__main_menu__" || target === "__quit__") {
+      throw new Restart(target);
+    }
+    let name = target;
+    if (name.startsWith(".")) name = this.cur.label.split(".")[0] + name;
+    const anchor = this.labels.has(name) ? null : this.anchors.get(name);
+    if (!this.labels.has(name) && !anchor) {
+      this.notify(`Метка «${target}» не найдена`);
+      console.warn("[pgvn] нет метки", target);
+      if (frame) this.stack.pop();
+      this.advance();
+      return;
+    }
+    const params = anchor ? anchor.params : this.labels.get(name)!.label.params;
+    if (params?.length) this.bindParams(params, args, frame);
+    this.cur = anchor ? { label: anchor.label, path: [...anchor.path] } : { label: name, path: [0] };
+    this.markSeen(name);
+    this.settle();
+  }
+
+  /** Label parameters are dynamically scoped: a call restores old values on return. */
+  private bindParams(params: [string, Expr | null][], args?: { a: any[]; kw: Record<string, any> },
+                     frame?: Frame) {
+    const values: Record<string, any> = {};
+    params.forEach(([p, def], i) => {
+      if (args && i < args.a.length) values[p] = args.a[i];
+      else if (args && p in args.kw) values[p] = args.kw[p];
+      else values[p] = def ? this.safeEval(def) : null;
+    });
+    if (frame) {
+      frame.saved = {};
+      for (const p of Object.keys(values)) frame.saved[p] = { had: p in this.store, value: this.store[p] };
+    }
+    Object.assign(this.store, values);
+  }
+
+  private call(target: string, argExprs?: { a: Expr[]; kw: Record<string, Expr> }) {
+    // arguments are evaluated in the caller's scope, before parameters are bound
+    const args = argExprs && {
+      a: argExprs.a.map((e) => this.safeEval(e)),
+      kw: Object.fromEntries(Object.entries(argExprs.kw).map(([k, e]) => [k, this.safeEval(e)])),
+    };
+    const frame: Frame = { label: this.cur.label, path: [...this.cur.path] };
+    this.stack.push(frame);
+    this.jump(target, args, frame);
+  }
+
+  private doReturn() {
+    const frame = this.stack.pop();
+    if (!frame) {
+      this.cur = { label: "", path: [0] };
+      return;
+    }
+    for (const [p, old] of Object.entries(frame.saved ?? {})) {
+      if (old.had) this.store[p] = old.value;
+      else delete this.store[p];
+    }
+    this.cur = { label: frame.label, path: frame.path };
+    this.advance();
+  }
+
+  private markSeen(label: string) {
+    const seen: string[] = this.persistent._seen ?? [];
+    if (!seen.includes(label)) this.persistent._seen = [...seen, label];
+  }
+
+  // --- main loop --------------------------------------------------------------------
+
+  private wait<T = void>(setup: (done: (v: T) => void) => void): Promise<T> {
+    const gen = this.gen;
+    return new Promise<T>((resolve, reject) => {
+      const wake = () => reject(new Restart());
+      this.waiters.push(wake);
+      setup((v) => {
+        this.waiters = this.waiters.filter((w) => w !== wake);
+        if (gen === this.gen) resolve(v);
+        else reject(new Restart());
+      });
+    });
+  }
+
+  private wakeAll() {
+    const ws = this.waiters;
+    this.waiters = [];
+    ws.forEach((w) => w());
+  }
+
+  private async loop() {
+    const gen = this.gen;
+    this.running = true;
+    try {
+      while (gen === this.gen) {
+        if (!this.cur.label) {
+          this.showMainMenu();
+          return;
+        }
+        const node = this.node();
+        if (!node) {
+          this.settle();
+          if (!this.node()) {
+            this.cur = { label: "", path: [0] };
+          }
+          continue;
+        }
+        try {
+          await this.exec(node);
+        } catch (err) {
+          if (err instanceof JumpSignal) {
+            if (err.kind === "jump") this.jump(err.target);
+            else this.call(err.target);
+          } else throw err;
+        }
+      }
+    } catch (err) {
+      if (err instanceof Restart) {
+        if (err.message === "__main_menu__") this.showMainMenu();
+        if (err.message === "__quit__") this.onExit();
+        return;
+      }
+      console.error(err);
+      this.notify(`Ошибка плеера: ${(err as Error).message}`);
+    } finally {
+      if (gen === this.gen) this.running = false;
+    }
+  }
+
+  private async exec(node: Node) {
+    switch (node.op) {
+      case "say":
+        await this.say(node);
+        this.advance();
+        return;
+      case "scene":
+      case "show":
+      case "hide": {
+        if (node.with) this.renderer.commit();
+        if (node.op === "scene") {
+          this.renderer.scene();
+          this.clearNvl();
+        }
+        if (node.op === "hide") this.renderer.hide(node.tag);
+        else if (node.img) this.showNode(node);
+        if (node.with) await this.renderer.transition(this.transition(node.with));
+        this.advance();
+        return;
+      }
+      case "with":
+        await this.renderer.transition(this.transition(node.t));
+        this.advance();
+        return;
+      case "play":
+      case "queue": {
+        const files = node.files.map((f: Expr) => this.audioFile(f)).filter(Boolean) as string[];
+        if (files.length) {
+          if (node.op === "play")
+            this.audio.play(node.ch, files, { loop: node.loop, fadein: node.fadein, fadeout: node.fadeout,
+                                              ifChanged: node.ifChanged });
+          else this.audio.queue(node.ch, files, node.loop);
+        }
+        this.advance();
+        return;
+      }
+      case "stop":
+        this.audio.stop(node.ch, node.fadeout ?? 0);
+        this.advance();
+        return;
+      case "voice":
+        if (node.file) {
+          const f = this.audioFile(node.file);
+          if (f) this.audio.play("voice", [f], { loop: false });
+        }
+        this.advance();
+        return;
+      case "pause": {
+        const d = node.d ? Number(this.safeEval(node.d)) : null;
+        await this.pause(d);
+        this.advance();
+        return;
+      }
+      case "menu":
+        return this.menu(node);
+      case "if": {
+        const i = node.branches.findIndex((b: any) => b.c === null || truthy(this.safeEval(b.c)));
+        if (i >= 0) this.enter(i);
+        else this.advance();
+        return;
+      }
+      case "while":
+        if (truthy(this.safeEval(node.c))) this.enter(0);
+        else this.advance();
+        return;
+      case "jump":
+        return this.jump(node.target ?? pyStr(this.safeEval(node.expr)));
+      case "call":
+        return this.call(node.target ?? pyStr(this.safeEval(node.expr)), node.args);
+      case "camera":
+        this.renderer.camera(node.at ?? []);
+        this.advance();
+        return;
+      case "return":
+        this.doReturn();
+        return;
+      case "exec":
+        try {
+          this.py.exec(node.code);
+        } catch (err) {
+          if (err instanceof JumpSignal) throw err;
+          console.warn("[pgvn] ошибка python", err, node.code);
+        }
+        this.advance();
+        return;
+      case "window":
+        this.windowShown = node.mode !== "hide";
+        if (!this.windowShown) this.textbox.classList.add("pg-hidden");
+        this.advance();
+        return;
+      case "nvl":
+        if (node.a === "clear") this.clearNvl();
+        else this.nvlEl.classList.toggle("pg-hidden", node.a === "hide");
+        this.advance();
+        return;
+      default:
+        this.advance();
+    }
+  }
+
+  private showNode(node: Node) {
+    const img = this.imageFromSpec(node.img);
+    if (!img) {
+      console.warn("[pgvn] нет изображения", node.img);
+      return;
+    }
+    const tag = node.as ?? (node.img.name ? node.img.name[0] : img.name[0]);
+    const zorder = node.zorder ? Number(this.safeEval(node.zorder)) : undefined;
+    this.renderer.show(img, tag, node.at ?? [], { zorder, behind: node.behind });
+  }
+
+  private transition(t: any) {
+    if (t && t.t === "ref") return this.game.transitions[t.name] ?? { t: "dissolve", d: 0.5 };
+    return t;
+  }
+
+  private audioFile(e: Expr): string | null {
+    if (e.k === "name" && this.game.audio[e.id] && !(e.id in this.store)) return this.game.audio[e.id];
+    const v = this.safeEval(e);
+    if (typeof v !== "string") return null;
+    return this.game.audio[v] ?? v;
+  }
+
+  // --- interactions -----------------------------------------------------------------
+
+  private interactionStart() {
+    this.renderer.commit();
+    this.interactions++;
+    if (this.interactions % 15 === 0) void this.save("auto", true);
+    this.preloadAhead();
+  }
+
+  private preloadAhead() {
+    const block = this.labels.has(this.cur.label) ? this.blockFor(this.cur) : [];
+    const start = this.cur.path[this.cur.path.length - 1];
+    for (const n of block.slice(start + 1, start + 12)) {
+      if ((n.op === "show" || n.op === "scene") && n.img?.name) this.renderer.preload(this.resolveImage(n.img.name)?.def ?? null);
+    }
+  }
+
+  private characterFor(node: Node): { char: CharacterDef; name: string; mode: string } {
+    const who: string | undefined = node.who;
+    if (node.whoStr !== undefined) return { char: {}, name: this.interp(this.tr.str(node.whoStr)), mode: "adv" };
+    if (!who || who === "narrator") return { char: {}, name: "", mode: "adv" };
+    if (who === "centered" || who === "vcentered") return { char: {}, name: "", mode: "centered" };
+    if (who === "extend") return { char: this.lastSay?.char ?? {}, name: this.lastSay?.name ?? "", mode: "extend" };
+    if (who === "nvl") return { char: { nvl: true }, name: "", mode: "nvl" };
+    const char = this.game.characters[who];
+    if (!char) {
+      const v = this.store[who];
+      return { char: {}, name: typeof v === "string" ? v : who, mode: "adv" };
+    }
+    let name = this.tr.str(char.name ?? "");
+    if (char.nameExpr) name = this.tr.str(pyStr(this.safeEval(char.nameExpr)));
+    name = this.interp(name);
+    return { char, name: `${char.whoPrefix ?? ""}${name}${char.whoSuffix ?? ""}`, mode: char.nvl ? "nvl" : "adv" };
+  }
+
+  private interp(s: string): string {
+    return interpolate(s, (expr) => this.lookupPath(expr), (v) => this.tr.str(v));
+  }
+
+  private lookupPath(expr: string): any {
+    const m = expr.match(/^[A-Za-z_][\w]*/);
+    if (!m) return "";
+    let v = this.py.lookup(m[0]);
+    const rest = expr.slice(m[0].length);
+    for (const part of rest.matchAll(/\.(\w+)|\[(\d+|'[^']*'|"[^"]*")\]/g)) {
+      if (v === null || v === undefined) return "";
+      const k = part[1] ?? JSON.parse(part[2].replace(/^'|'$/g, '"'));
+      v = v instanceof PyDict ? v.get(k) : v[k];
+    }
+    return v ?? "";
+  }
+
+  private async say(node: Node, inMenu = false) {
+    const { char, name, mode } = this.characterFor(node);
+    if (node.attrs && char.image && this.renderer.isShown(char.image)) {
+      const img = this.resolveImage([char.image, ...node.attrs]);
+      if (img) this.renderer.show(img, char.image, []);
+    }
+    if (!inMenu) this.interactionStart();
+    if (node.with) await this.renderer.transition(this.transition(node.with));
+
+    let raw = this.interp(this.tr.line(node.tid, node.what));
+    raw = `${char.whatPrefix ?? ""}${raw}${char.whatSuffix ?? ""}`;
+    let prefixLen = 0;
+    if (mode === "extend" && this.lastSay) {
+      prefixLen = [...plainText(parseText(this.lastSay.text))].length;
+      raw = this.lastSay.text + raw;
+    }
+    const parsed = parseText(raw);
+    this.lastSay = { name, text: raw, color: char.color, char };
+    if (mode !== "extend") this.history.push({ name, text: plainText(parsed) });
+    else if (this.history.length) this.history[this.history.length - 1].text = plainText(parsed);
+    if (this.history.length > 300) this.history.shift();
+
+    let target: HTMLElement;
+    if (mode === "centered") {
+      this.textbox.classList.add("pg-hidden");
+      this.centeredEl.classList.remove("pg-hidden");
+      target = this.centeredEl;
+    } else if (mode === "nvl") {
+      this.textbox.classList.add("pg-hidden");
+      this.nvlEl.classList.remove("pg-hidden");
+      const line = el("div", "pg-nvl-line");
+      if (name) {
+        const who = el("span", "pg-nvl-name", name);
+        if (char.color) who.style.color = char.color;
+        line.append(who);
+      }
+      const what = el("span", "pg-nvl-what");
+      line.append(what);
+      this.nvlEl.append(line);
+      this.nvlLines.push(line);
+      target = what;
+    } else {
+      this.centeredEl.classList.add("pg-hidden");
+      this.nvlEl.classList.add("pg-hidden");
+      this.textbox.classList.remove("pg-hidden");
+      this.namebox.textContent = name;
+      this.namebox.classList.toggle("pg-hidden", !name);
+      this.namebox.style.color = char.color ?? "";
+      this.textEl.style.color = char.whatColor ?? "";
+      this.textEl.style.fontStyle = char.whatItalic ? "italic" : "";
+      this.textEl.style.fontWeight = char.whatBold ? "bold" : "";
+      target = this.textEl;
+    }
+
+    await this.typewrite(target, parsed, Math.max(prefixLen, fastPoint(parsed)), inMenu);
+    if (inMenu || node.interact === false) return;
+    if (!parsed.noWait) await this.waitAdvance(parsed.length);
+    this.audio.stop("voice");
+    this.centeredEl.classList.add("pg-hidden");
+  }
+
+  private async typewrite(target: HTMLElement, parsed: ReturnType<typeof parseText>, from: number, instant = false) {
+    this.ctc.remove();
+    const total = parsed.length;
+    const waits = waitPoints(parsed).filter((w) => w.at > from);
+    let shown = from;
+    const cps = this.settings.cps;
+    if (instant || cps <= 0 || this.skip) {
+      renderText(target, parsed, total, this.baseSize);
+      target.append(this.ctc);
+      return;
+    }
+    let completed = false;
+    const finishClick = () => {
+      completed = true;
+    };
+    this.onAdvance = finishClick;
+    try {
+      for (const stop of [...waits.map((w) => w.at), total]) {
+        let last = performance.now();
+        while (shown < stop && !completed && !this.skip) {
+          await this.frame();
+          const now = performance.now();
+          shown = Math.min(stop, shown + ((now - last) / 1000) * cps);
+          last = now;
+          renderText(target, parsed, Math.floor(shown), this.baseSize);
+        }
+        shown = completed || this.skip ? total : stop;
+        renderText(target, parsed, Math.floor(shown), this.baseSize);
+        if (completed || this.skip) break;
+        const w = waits.find((x) => x.at === stop);
+        if (w) {
+          if (w.seconds !== null) await this.pause(w.seconds);
+          else await this.waitAdvance(0);
+          this.onAdvance = finishClick;
+        }
+      }
+    } finally {
+      this.onAdvance = null;
+    }
+    target.append(this.ctc);
+  }
+
+  private frame(): Promise<void> {
+    return this.wait((done) => requestAnimationFrame(() => done()));
+  }
+
+  private onAdvance: (() => void) | null = null;
+
+  /** Wait for the player to advance (click/space), or skip/auto. */
+  private waitAdvance(chars: number): Promise<void> {
+    return this.wait((done) => {
+      let timer = 0;
+      const finish = () => {
+        clearTimeout(timer);
+        this.onAdvance = null;
+        this.skipTick = null;
+        done();
+      };
+      this.onAdvance = finish;
+      if (this.skip) timer = window.setTimeout(finish, 40);
+      else if (this.auto) timer = window.setTimeout(finish, (1 + chars / 20) * this.settings.autoDelay * 1000);
+      this.skipTick = () => {
+        clearTimeout(timer);
+        if (this.skip) timer = window.setTimeout(finish, 40);
+        else if (this.auto) timer = window.setTimeout(finish, 1000 * this.settings.autoDelay);
+      };
+    });
+  }
+
+  private skipTick: (() => void) | null = null;
+
+  private pause(seconds: number | null): Promise<void> {
+    if (seconds === null) {
+      this.interactionStart();
+      return this.waitAdvance(0);
+    }
+    if (this.skip) return Promise.resolve();
+    return this.wait((done) => {
+      const timer = window.setTimeout(() => {
+        this.onAdvance = null;
+        done();
+      }, seconds * 1000);
+      this.onAdvance = () => {
+        clearTimeout(timer);
+        this.onAdvance = null;
+        done();
+      };
+    });
+  }
+
+  private async menu(node: Node) {
+    this.interactionStart();
+    const chosen: string[] = node.set ? this.safeEval(node.set) ?? [] : [];
+    if (node.say) await this.say(node.say, true);
+    else if (!this.windowShown) this.textbox.classList.add("pg-hidden");
+    const items = node.items
+      .map((item: any, i: number) => ({ ...item, i }))
+      .filter((item: any) => (item.if === null || truthy(this.safeEval(item.if))) && !chosen.includes(item.text));
+    if (!items.length) {
+      this.advance();
+      return;
+    }
+    this.setSkip(false);
+    const index = await this.wait<number>((done) => {
+      this.menuEl.textContent = "";
+      for (const item of items) {
+        const b = el("button", "pg-choice");
+        renderText(b, parseText(this.interp(this.tr.str(item.text))), Infinity, this.baseSize);
+        b.onclick = (ev) => {
+          ev.stopPropagation();
+          done(item.i);
+        };
+        this.menuEl.append(b);
+      }
+      this.menuEl.classList.remove("pg-hidden");
+    });
+    this.menuEl.classList.add("pg-hidden");
+    if (Array.isArray(chosen) && node.set) chosen.push(node.items[index].text);
+    this.history.push({ name: "", text: `→ ${plainText(parseText(this.interp(this.tr.str(node.items[index].text))))}` });
+    this.enter(index);
+  }
+
+  private clearNvl() {
+    this.nvlLines.forEach((l) => l.remove());
+    this.nvlLines = [];
+    this.nvlEl.classList.add("pg-hidden");
+  }
+
+  private notify(msg: string) {
+    this.notifyEl.textContent = msg;
+    this.notifyEl.classList.remove("pg-hidden");
+    window.setTimeout(() => this.notifyEl.classList.add("pg-hidden"), 3000);
+  }
+
+  // --- session control --------------------------------------------------------------
+
+  private restart(setup: () => void) {
+    this.gen++;
+    this.wakeAll();
+    this.onAdvance = null;
+    this.skipTick = null;
+    this.closeScreen();
+    this.menuEl.classList.add("pg-hidden");
+    this.centeredEl.classList.add("pg-hidden");
+    this.clearNvl();
+    this.setSkip(false);
+    setup();
+    void this.loop();
+  }
+
+  start() {
+    this.showMainMenu();
+  }
+
+  private newGame() {
+    this.restart(() => {
+      this.audio.stopAll();
+      this.renderer.scene();
+      this.renderer.camera([]);
+      this.renderer.commit();
+      this.newStore();
+      this.stack = [];
+      this.history = [];
+      this.lastSay = null;
+      this.textbox.classList.add("pg-hidden");
+      this.cur = { label: this.game.entry, path: [0] };
+      this.markSeen(this.game.entry);
+      this.settle();
+    });
+  }
+
+  private snapshotState(): SaveData {
+    return {
+      v: 1,
+      cur: { label: this.cur.label, path: [...this.cur.path] },
+      stack: this.stack.map((f) => ({ label: f.label, path: [...f.path], saved: encodeValue(f.saved) })),
+      store: encodeValue(this.store),
+      scene: this.renderer.snapshot(),
+      music: this.audio.current("music"),
+      window: this.windowShown,
+      camera: this.renderer.cameraAt,
+      text: this.lastSay ? `${this.lastSay.name ? this.lastSay.name + ": " : ""}${plainText(parseText(this.lastSay.text))}` : "",
+    };
+  }
+
+  private async save(slot: string, silent = false) {
+    if (!this.running || !this.cur.label) return;
+    const data = this.snapshotState();
+    const title = (data.text ?? "").slice(0, 120) || this.cur.label;
+    try {
+      await this.saves.put(slot, title, data);
+      if (!silent) this.notify("Сохранено");
+    } catch (err) {
+      if (!silent) this.notify(`Не удалось сохранить: ${(err as Error).message}`);
+    }
+  }
+
+  private async load(slot: string) {
+    const data = await this.saves.get(slot);
+    if (!data) {
+      this.notify("Сохранение не найдено");
+      return;
+    }
+    if (!this.labels.has(data.cur.label)) {
+      this.notify("Сохранение не подходит к этой версии игры");
+      return;
+    }
+    this.restart(() => {
+      this.resetStore();
+      Object.assign(this.store, decodeValue(data.store));
+      this.renderer.scene();
+      for (const s of data.scene) {
+        const img = this.resolveImage(s.name);
+        if (img) this.renderer.show(img, s.tag, s.at, { zorder: s.zorder });
+      }
+      this.renderer.commit();
+      this.audio.stopAll();
+      if (data.music) this.audio.play("music", [data.music.file], { loop: data.music.loop, fadein: 0.5 });
+      this.windowShown = data.window;
+      this.renderer.camera(data.camera ?? []);
+      this.stack = data.stack.map((f) => ({ ...f, saved: decodeValue(f.saved) }));
+      this.cur = data.cur;
+      this.lastSay = null;
+      this.history = [];
+    });
+  }
+
+  private setSkip(on: boolean) {
+    this.skip = on;
+    this.renderer.fast = on;
+    this.quick?.querySelector("[data-act=skip]")?.classList.toggle("pg-on", on);
+    this.skipTick?.();
+  }
+
+  private setAuto(on: boolean) {
+    this.auto = on;
+    this.quick.querySelector("[data-act=auto]")?.classList.toggle("pg-on", on);
+    this.skipTick?.();
+  }
+
+  // --- UI -------------------------------------------------------------------------
+
+  private buildUI() {
+    const { ui } = this.game;
+    const [w, h] = this.game.resolution;
+    const stage = this.renderer.stage;
+    const px = (v: any, total: number, fallback: number) =>
+      typeof v === "number" ? (Number.isInteger(v) && v > 1 ? v : v * total) : fallback;
+    stage.style.setProperty("--pg-font", `${this.baseSize}px`);
+    stage.style.setProperty("--pg-name-font", `${Number(ui.name_text_size) || Math.round(this.baseSize * 1.2)}px`);
+    if (ui.accent_color) stage.style.setProperty("--pg-accent", ui.accent_color);
+    if (ui.text_color) stage.style.setProperty("--pg-text", ui.text_color);
+    this.loadFont("pg-game-font", ui.text_font);
+    this.loadFont("pg-game-name-font", ui.name_text_font ?? ui.text_font);
+
+    this.textbox = el("div", "pg-textbox pg-hidden");
+    const boxH = px(ui.textbox_height, h, Math.round(h * 0.257));
+    this.textbox.style.height = `${boxH}px`;
+    if (ui.textbox) {
+      const url = this.fileUrl(ui.textbox);
+      if (url) this.textbox.style.backgroundImage = `url("${url}")`;
+      this.textbox.classList.add("pg-textbox-image");
+    }
+    this.namebox = el("div", "pg-namebox");
+    this.namebox.style.left = `${px(ui.name_xpos, w, Math.round(w * 0.1875))}px`;
+    this.namebox.style.transform = "translateX(-50%)";
+    if (!ui.name_xpos) this.namebox.style.transform = "";
+    this.textEl = el("div", "pg-text");
+    this.textEl.style.left = `${px(ui.dialogue_xpos, w, Math.round(w * 0.21))}px`;
+    this.textEl.style.top = `${px(ui.dialogue_ypos, boxH, Math.round(boxH * 0.18))}px`;
+    this.textEl.style.width = `${px(ui.dialogue_width, w, Math.round(w * 0.58))}px`;
+    this.ctc = el("span", "pg-ctc", "▼");
+    this.textbox.append(this.namebox, this.textEl);
+
+    this.quick = el("div", "pg-quick");
+    const actions: [string, string, () => void][] = [
+      ["history", "История", () => this.openHistory()],
+      ["skip", "Пропуск", () => this.setSkip(!this.skip)],
+      ["auto", "Авто", () => this.setAuto(!this.auto)],
+      ["save", "Сохр.", () => this.openSaves("save")],
+      ["load", "Загр.", () => this.openSaves("load")],
+      ["qsave", "Б.Сохр.", () => void this.save("quick")],
+      ["qload", "Б.Загр.", () => void this.load("quick")],
+      ["prefs", "Настройки", () => this.openSettings()],
+      ["menu", "Меню", () => this.openGameMenu()],
+    ];
+    for (const [act, label, fn] of actions) {
+      const b = el("button", "", label);
+      b.dataset.act = act;
+      b.onclick = (ev) => {
+        ev.stopPropagation();
+        fn();
+      };
+      this.quick.append(b);
+    }
+    this.textbox.append(this.quick);
+
+    this.menuEl = el("div", "pg-menu pg-hidden");
+    this.nvlEl = el("div", "pg-nvl pg-hidden");
+    if (ui.nvl) {
+      const url = this.fileUrl(ui.nvl);
+      if (url) this.nvlEl.style.backgroundImage = `url("${url}")`;
+    }
+    this.centeredEl = el("div", "pg-centered pg-hidden");
+    this.screen = el("div", "pg-screen pg-hidden");
+    this.notifyEl = el("div", "pg-notify pg-hidden");
+    stage.append(this.nvlEl, this.textbox, this.centeredEl, this.menuEl, this.screen, this.notifyEl);
+
+    stage.addEventListener("click", (ev) => {
+      if (!this.screen.classList.contains("pg-hidden")) return;
+      if ((ev.target as HTMLElement).closest(".pg-menu, .pg-quick")) return;
+      this.advanceInput();
+    });
+    stage.addEventListener("wheel", (ev) => {
+      if (ev.deltaY < 0 && this.screen.classList.contains("pg-hidden") && this.running) this.openHistory();
+    }, { passive: true });
+  }
+
+  private loadFont(family: string, file?: string) {
+    const url = file ? this.fileUrl(file) : null;
+    if (!url) return;
+    const face = new FontFace(family, `url("${url}")`);
+    face.load().then((f) => {
+      document.fonts.add(f);
+      this.renderer.stage.classList.add(family);
+    }).catch(() => {});
+  }
+
+  private advanceInput() {
+    if (this.skip) {
+      this.setSkip(false);
+      return;
+    }
+    if (!this.textbox.classList.contains("pg-ui-hidden")) this.onAdvance?.();
+    this.textbox.classList.remove("pg-ui-hidden");
+  }
+
+  private onKey = (ev: KeyboardEvent) => {
+    if ((ev.target as HTMLElement)?.tagName === "INPUT") return;
+    const screenOpen = !this.screen.classList.contains("pg-hidden");
+    if (ev.key === "Escape") {
+      if (this.screen.classList.contains("pg-main")) return;
+      if (screenOpen) this.dismissScreen();
+      else if (this.running) this.openGameMenu();
+      return;
+    }
+    if (screenOpen) return;
+    if (ev.key === " " || ev.key === "Enter") {
+      ev.preventDefault();
+      this.advanceInput();
+    } else if (ev.key === "Control" && !this.skip) {
+      this.setSkip(true);
+    } else if (ev.key === "Tab") {
+      ev.preventDefault();
+      this.setSkip(!this.skip);
+    } else if (ev.key === "a" || ev.key === "ф") {
+      this.setAuto(!this.auto);
+    } else if (ev.key === "h" || ev.key === "р") {
+      this.textbox.classList.toggle("pg-ui-hidden");
+    }
+  };
+
+  private onKeyUp = (ev: KeyboardEvent) => {
+    if (ev.key === "Control") this.setSkip(false);
+  };
+
+  private screenOnClose: (() => void) | null = null;
+
+  private openScreen(title: string, build: (body: HTMLElement) => void, onClose?: () => void) {
+    this.screen.textContent = "";
+    this.screen.classList.remove("pg-main");
+    this.screen.style.backgroundImage = "";
+    this.screenOnClose = onClose ?? null;
+    const head = el("div", "pg-screen-head");
+    head.append(el("h2", "", title));
+    const close = el("button", "pg-close", "✕");
+    close.onclick = () => this.dismissScreen();
+    head.append(close);
+    const body = el("div", "pg-screen-body");
+    this.screen.append(head, body);
+    build(body);
+    this.screen.classList.remove("pg-hidden");
+  }
+
+  private dismissScreen() {
+    const fn = this.screenOnClose;
+    if (fn) fn();
+    else this.closeScreen();
+  }
+
+  private closeScreen() {
+    this.screenOnClose = null;
+    this.screen.classList.add("pg-hidden");
+    this.screen.classList.remove("pg-main");
+    this.screen.style.backgroundImage = "";
+  }
+
+  private showMainMenu() {
+    this.running = false;
+    this.gen++;
+    this.wakeAll();
+    this.audio.stopAll();
+    this.textbox.classList.add("pg-hidden");
+    this.menuEl.classList.add("pg-hidden");
+    this.clearNvl();
+    this.screen.textContent = "";
+    this.screen.classList.add("pg-main");
+    const bg = this.game.ui.mainMenu ? this.fileUrl(this.game.ui.mainMenu) : null;
+    if (bg) this.screen.style.backgroundImage = `url("${bg}")`;
+    const panel = el("div", "pg-main-panel");
+    panel.append(el("h1", "", this.game.title ?? "Новелла"));
+    const btn = (label: string, fn: () => void) => {
+      const b = el("button", "", label);
+      b.onclick = fn;
+      panel.append(b);
+      return b;
+    };
+    btn("Начать", () => this.newGame());
+    const cont = btn("Продолжить", () => void this.load("auto"));
+    cont.style.display = "none";
+    this.saves.list().then((list) => {
+      if (list.some((s) => s.slot === "auto")) cont.style.display = "";
+    }).catch(() => {});
+    btn("Загрузить", () => this.openSaves("load", true));
+    btn("Настройки", () => this.openSettings(true));
+    const langs = this.languages();
+    if (langs.length > 1) {
+      const select = this.languageSelect(langs, () => this.showMainMenu());
+      select.classList.add("pg-lang");
+      panel.append(select);
+    }
+    btn("В библиотеку", () => this.onExit());
+    this.screen.append(panel);
+    this.screen.classList.remove("pg-hidden");
+  }
+
+  private languages(): string[] {
+    return [this.game.sourceLang ?? "und", ...Object.keys(this.game.locales ?? {})];
+  }
+
+  private languageSelect(langs: string[], after: () => void): HTMLSelectElement {
+    const select = el("select", "pg-select");
+    for (const lang of langs) {
+      const o = el("option", "", languageName(this.game, lang) + progressLabel(this.game.locales?.[lang]?.progress));
+      o.value = lang;
+      o.selected = lang === this.tr.lang;
+      select.append(o);
+    }
+    select.onchange = () => void this.setLanguage(select.value).then(after);
+    return select;
+  }
+
+  private openGameMenu() {
+    this.openScreen("Меню", (body) => {
+      const list = el("div", "pg-menu-list");
+      const add = (label: string, fn: () => void) => {
+        const b = el("button", "", label);
+        b.onclick = fn;
+        list.append(b);
+      };
+      add("Вернуться", () => this.closeScreen());
+      add("Сохранить", () => this.openSaves("save"));
+      add("Загрузить", () => this.openSaves("load"));
+      add("Настройки", () => this.openSettings());
+      add("Главное меню", () => {
+        if (confirm("Выйти в главное меню? Несохранённый прогресс будет потерян.")) this.showMainMenu();
+      });
+      add("В библиотеку", () => this.onExit());
+      body.append(list);
+    });
+  }
+
+  private openHistory() {
+    this.openScreen("История", (body) => {
+      const list = el("div", "pg-history");
+      for (const h of this.history) {
+        const row = el("div", "pg-history-row");
+        if (h.name) row.append(el("b", "", h.name));
+        row.append(el("span", "", h.text));
+        list.append(row);
+      }
+      body.append(list);
+      requestAnimationFrame(() => (list.scrollTop = list.scrollHeight));
+    });
+  }
+
+  private openSaves(mode: "save" | "load", fromMain = false) {
+    this.openScreen(mode === "save" ? "Сохранить" : "Загрузить", (body) => {
+      const grid = el("div", "pg-slots");
+      body.append(grid);
+      const render = (list: SaveMeta[]) => {
+        grid.textContent = "";
+        const bySlot = new Map(list.map((s) => [s.slot, s]));
+        const slots = [...(mode === "load" ? ["auto", "quick"] : []),
+                       ...Array.from({ length: SLOTS }, (_, i) => String(i + 1))];
+        for (const slot of slots) {
+          const meta = bySlot.get(slot);
+          const card = el("button", "pg-slot");
+          const label = slot === "auto" ? "Авто" : slot === "quick" ? "Быстрое" : `Слот ${slot}`;
+          card.append(el("b", "", label));
+          card.append(el("span", "pg-slot-title", meta ? meta.title : "Пусто"));
+          if (meta) card.append(el("small", "", new Date(meta.updated_at).toLocaleString()));
+          card.disabled = mode === "load" && !meta;
+          card.onclick = async () => {
+            if (mode === "save") {
+              if (meta && !confirm("Перезаписать сохранение?")) return;
+              await this.save(slot);
+              render(await this.saves.list());
+            } else {
+              await this.load(slot);
+            }
+          };
+          grid.append(card);
+        }
+      };
+      this.saves.list().then(render).catch((e) => this.notify(String(e)));
+    }, fromMain ? () => this.showMainMenu() : undefined);
+  }
+
+  private openSettings(fromMain = false) {
+    this.openScreen("Настройки", (body) => {
+      const s = this.settings;
+      const row = (label: string, min: number, max: number, step: number, value: number,
+                   fmt: (v: number) => string, set: (v: number) => void) => {
+        const r = el("label", "pg-setting");
+        const out = el("span", "pg-setting-val", fmt(value));
+        const input = el("input");
+        Object.assign(input, { type: "range", min, max, step, value: String(value) });
+        input.oninput = () => {
+          set(Number(input.value));
+          out.textContent = fmt(Number(input.value));
+          saveJSON("pgvn:settings", this.settings);
+          this.audio.setVolumes(this.settings);
+        };
+        r.append(el("span", "", label), input, out);
+        body.append(r);
+      };
+      row("Скорость текста", 0, 150, 5, s.cps, (v) => (v === 0 ? "мгновенно" : `${v} симв/с`), (v) => (s.cps = v));
+      row("Задержка авто", 0.3, 4, 0.1, s.autoDelay, (v) => `${v.toFixed(1)} с`, (v) => (s.autoDelay = v));
+      row("Музыка", 0, 1, 0.05, s.music, (v) => `${Math.round(v * 100)}%`, (v) => (s.music = v));
+      row("Звуки", 0, 1, 0.05, s.sound, (v) => `${Math.round(v * 100)}%`, (v) => (s.sound = v));
+      row("Голос", 0, 1, 0.05, s.voice, (v) => `${Math.round(v * 100)}%`, (v) => (s.voice = v));
+      const langs = this.languages();
+      if (langs.length > 1) {
+        const r = el("label", "pg-setting");
+        r.append(el("span", "", "Язык"), this.languageSelect(langs, () => {}), el("span", ""));
+        body.append(r);
+      }
+      const fs = el("button", "pg-wide", "Полный экран");
+      fs.onclick = () => {
+        if (document.fullscreenElement) void document.exitFullscreen();
+        else void this.root.requestFullscreen();
+      };
+      body.append(fs);
+    }, fromMain ? () => this.showMainMenu() : undefined);
+  }
+}
+
+function progressLabel(p: number | undefined): string {
+  return p !== undefined && p < 0.995 ? ` — ${Math.round(p * 100)}%` : "";
+}
+
+function childBlock(node: Node, branch: number): Node[] {
+  if (node.op === "if") return node.branches[branch].body;
+  if (node.op === "menu") return node.items[branch].body;
+  return node.body;
+}
+
+export type { ImageDef };
diff --git a/frontend/src/player/i18n.ts b/frontend/src/player/i18n.ts
new file mode 100644
index 0000000..6be098e
--- /dev/null
+++ b/frontend/src/player/i18n.ts
@@ -0,0 +1,94 @@
+// Game localisation: per-language line tables (by tid) and a strings table (by source text).
+
+import type { GameData, Manifest } from "./types";
+
+export interface LocaleInfo {
+  name: string;
+  renpy: string;
+  modules: Record<string, string>;
+  strings: string;
+  lines: number;
+  progress: number;
+}
+
+interface Entry {
+  t: string;
+  state?: string;
+}
+
+const PREF_KEY = "pgvn:lang";
+
+export class Translator {
+  constructor(
+    public readonly lang: string, // BCP-47; equals sourceLang when untranslated
+    public readonly renpyName: string | null,
+    private lines: Map<string, string> = new Map(),
+    private strings: Map<string, string> = new Map(),
+  ) {}
+
+  static source(game: GameData) {
+    return new Translator(game.sourceLang ?? "und", null);
+  }
+
+  /** Dialogue line by translation id, falling back to the source text. */
+  line(tid: string | undefined, source: string): string {
+    return (tid && this.lines.get(tid)) || source;
+  }
+
+  /** Names, menu choices, `_()` strings: looked up by their source text. */
+  str(source: string): string {
+    return this.strings.get(source) ?? source;
+  }
+}
+
+export function preferredLanguage(game: GameData): string {
+  const available = [game.sourceLang ?? "und", ...Object.keys(game.locales ?? {})];
+  let saved: string | null = null;
+  try {
+    saved = localStorage.getItem(PREF_KEY);
+  } catch {
+    /* storage unavailable */
+  }
+  if (saved && available.includes(saved)) return saved;
+  // browser languages, matched exactly or by primary subtag (ru-RU -> ru)
+  for (const nav of navigator.languages ?? [navigator.language]) {
+    const hit = available.find((a) => a === nav) ?? available.find((a) => a.split("-")[0] === nav.split("-")[0]);
+    if (hit) return hit;
+  }
+  return game.sourceLang ?? "und";
+}
+
+export function rememberLanguage(lang: string) {
+  try {
+    localStorage.setItem(PREF_KEY, lang);
+  } catch {
+    /* storage unavailable */
+  }
+}
+
+export async function loadTranslator(game: GameData, manifest: Manifest, lang: string): Promise<Translator> {
+  const info = game.locales?.[lang];
+  if (!info) return Translator.source(game);
+  const blob = (path: string) => {
+    const f = manifest.files[path];
+    if (!f) throw new Error(`в версии нет файла ${path}`);
+    return fetch(`/blobs/${f.hash}`).then((r) => {
+      if (!r.ok) throw new Error(`${r.status} ${path}`);
+      return r.json() as Promise<Record<string, Entry>>;
+    });
+  };
+  const [strings, ...modules] = await Promise.all([blob(info.strings), ...Object.values(info.modules).map(blob)]);
+  const lines = new Map<string, string>();
+  for (const mod of modules) for (const [tid, e] of Object.entries(mod)) lines.set(tid, e.t);
+  return new Translator(lang, info.renpy, lines,
+                        new Map(Object.entries(strings).map(([k, e]) => [k, e.t])));
+}
+
+export function languageName(game: GameData, lang: string): string {
+  if (lang === game.sourceLang) {
+    const known: Record<string, string> = { en: "English", ru: "Русский", fr: "Français", de: "Deutsch",
+                                            es: "Español", ja: "日本語" };
+    return `${known[lang] ?? lang} (оригинал)`;
+  }
+  return game.locales?.[lang]?.name ?? lang;
+}
diff --git a/frontend/src/player/index.ts b/frontend/src/player/index.ts
index cf45750..79eb869 100644
--- a/frontend/src/player/index.ts
+++ b/frontend/src/player/index.ts
@@ -1,5 +1,6 @@
 import "./player.css";
 import { Engine, type SaveApi } from "./engine";
+import { loadTranslator, preferredLanguage } from "./i18n";
 import type { GameData, Manifest, SaveData, ScriptModule } from "./types";
 
 async function getJSON<T>(url: string): Promise<T> {
@@ -44,9 +45,14 @@ export async function launch(root: HTMLElement, versionId: number, onExit: () =>
   const manifest = await getJSON<Manifest>(`/api/versions/${versionId}/manifest`);
   const game = await getJSON<GameData>(blob(manifest, "game.json"));
   onProgress(`Загрузка скриптов (${game.scripts.length})`);
-  const modules = await Promise.all(game.scripts.map((s) => getJSON<ScriptModule>(blob(manifest, s))));
+  const lang = preferredLanguage(game);
+  const [modules, tr] = await Promise.all([
+    Promise.all(game.scripts.map((s) => getJSON<ScriptModule>(blob(manifest, s)))),
+    loadTranslator(game, manifest, lang),
+  ]);
   const engine = new Engine(root, game, manifest, modules, saveApi(versionId),
-                            `pgvn:persistent:${versionId}`, onExit);
+                            `pgvn:persistent:${versionId}`, onExit, tr,
+                            (code) => loadTranslator(game, manifest, code));
   engine.start();
   return engine;
 }
diff --git a/frontend/src/player/player.css b/frontend/src/player/player.css
index b654644..d7faace 100644
--- a/frontend/src/player/player.css
+++ b/frontend/src/player/player.css
@@ -193,3 +193,14 @@
 }
 .pg-main-panel h1 { margin: 0 0 0.5em; font-size: 1.6em; color: var(--pg-accent); }
 .pg-main-panel button { text-align: left; }
+.pg-select {
+  font: inherit;
+  font-size: 0.85em;
+  color: #fff;
+  background: rgba(255, 255, 255, 0.07);
+  border: 1px solid rgba(255, 255, 255, 0.15);
+  border-radius: 0.3em;
+  padding: 0.3em 0.6em;
+}
+.pg-select option { background: #151827; }
+.pg-lang { margin-top: 0.6em; }
diff --git a/frontend/src/player/renderer.ts b/frontend/src/player/renderer.ts
index 7182830..c0e946d 100644
--- a/frontend/src/player/renderer.ts
+++ b/frontend/src/player/renderer.ts
@@ -1,366 +1,366 @@
-// DOM renderer for the image layer: one absolutely positioned element per shown tag.
-// The stage has the game's native resolution and is scaled with a CSS transform.
-
-import type { AtSpec, ImageDef, ShownImage, Transition } from "./types";
-
-const POSITIONS: Record<string, Record<string, number>> = {
-  left: { xpos: 0, xanchor: 0, ypos: 1, yanchor: 1 },
-  right: { xpos: 1, xanchor: 1, ypos: 1, yanchor: 1 },
-  center: { xpos: 0.5, xanchor: 0.5, ypos: 1, yanchor: 1 },
-  default: { xpos: 0.5, xanchor: 0.5, ypos: 1, yanchor: 1 },
-  reset: { xpos: 0.5, xanchor: 0.5, ypos: 1, yanchor: 1 },
-  truecenter: { xpos: 0.5, xanchor: 0.5, ypos: 0.5, yanchor: 0.5 },
-  topleft: { xpos: 0, xanchor: 0, ypos: 0, yanchor: 0 },
-  topright: { xpos: 1, xanchor: 1, ypos: 0, yanchor: 0 },
-  top: { xpos: 0.5, xanchor: 0.5, ypos: 0, yanchor: 0 },
-  offscreenleft: { xpos: 0, xanchor: 1, ypos: 1, yanchor: 1 },
-  offscreenright: { xpos: 1, xanchor: 0, ypos: 1, yanchor: 1 },
-};
-
-export interface ResolvedImage {
-  def: ImageDef;
-  name: string[];
-}
-
-export interface RendererHost {
-  url(file: string): string | null;
-  resolveRef(name: string): ImageDef | null;
-  evalCond(e: any): boolean;
-  transform(name: string): Record<string, any> | null;
-  text(e: any): string;
-}
-
-interface Entry extends ShownImage {
-  el: HTMLElement;
-}
-
-export class Renderer {
-  readonly stage: HTMLDivElement;
-  readonly master: HTMLDivElement;
-  private overlay: HTMLDivElement;
-  private shown = new Map<string, Entry>();
-  private committed: HTMLElement | null = null;
-  fast = false;
-
-  constructor(parent: HTMLElement, public width: number, public height: number,
-              private host: RendererHost) {
-    this.stage = document.createElement("div");
-    this.stage.className = "pg-stage";
-    this.stage.style.width = `${width}px`;
-    this.stage.style.height = `${height}px`;
-    this.master = document.createElement("div");
-    this.master.className = "pg-layer";
-    this.overlay = document.createElement("div");
-    this.overlay.className = "pg-layer pg-transition";
-    this.stage.append(this.master, this.overlay);
-    parent.append(this.stage);
-  }
-
-  fit(container: HTMLElement) {
-    const s = Math.min(container.clientWidth / this.width, container.clientHeight / this.height);
-    this.stage.style.transform = `translate(-50%, -50%) scale(${s})`;
-  }
-
-  // --- scene state ---------------------------------------------------------
-
-  scene() {
-    for (const e of this.shown.values()) e.el.remove();
-    this.shown.clear();
-  }
-
-  show(img: ResolvedImage, tag: string, at: AtSpec[], opts: { zorder?: number; behind?: string[] } = {}) {
-    const prev = this.shown.get(tag);
-    const atSpecs = at.length ? at : prev?.at ?? [];
-    const el = this.build(img.def);
-    el.classList.add("pg-image");
-    this.place(el, img.def, atSpecs);
-    const entry: Entry = { tag, name: img.name, at: atSpecs, zorder: opts.zorder ?? prev?.zorder ?? 0, el };
-    if (prev) {
-      prev.el.replaceWith(el);
-    } else {
-      const behind = opts.behind?.map((t) => this.shown.get(t)?.el).find(Boolean);
-      const later = [...this.shown.values()].find((e) => e.zorder > entry.zorder)?.el;
-      this.master.insertBefore(el, behind ?? later ?? null);
-    }
-    this.shown.set(tag, entry);
-  }
-
-  hide(tag: string) {
-    const e = this.shown.get(tag);
-    if (!e) return;
-    e.el.remove();
-    this.shown.delete(tag);
-  }
-
-  isShown(tag: string) {
-    return this.shown.has(tag);
-  }
-
-  attrsOf(tag: string): string[] | null {
-    return this.shown.get(tag)?.name ?? null;
-  }
-
-  snapshot(): ShownImage[] {
-    return [...this.shown.values()].map(({ tag, name, at, zorder }) => ({ tag, name, at, zorder }));
-  }
-
-  // --- displayables ------------------------------------------------------------
-
-  private build(def: ImageDef, depth = 0): HTMLElement {
-    if (depth > 8) return document.createElement("div");
-    if (def.ref) {
-      const ref = this.host.resolveRef(def.ref);
-      if (ref) return this.build({ ...ref, props: { ...ref.props, ...def.props } }, depth + 1);
-    }
-    if (def.switch) {
-      const hit = def.switch.find(([c]) => this.host.evalCond(c));
-      if (hit) return this.build(hit[1], depth + 1);
-    }
-    if (def.color) {
-      const d = document.createElement("div");
-      d.style.background = def.color;
-      d.style.width = `${this.width}px`;
-      d.style.height = `${this.height}px`;
-      return d;
-    }
-    if (def.composite) {
-      const d = document.createElement("div");
-      d.style.position = "relative";
-      if (def.size) {
-        d.style.width = `${def.size[0]}px`;
-        d.style.height = `${def.size[1]}px`;
-      }
-      for (const layer of def.composite) {
-        const child = this.build(layer.img, depth + 1);
-        child.style.position = "absolute";
-        child.style.left = `${layer.pos[0]}px`;
-        child.style.top = `${layer.pos[1]}px`;
-        d.append(child);
-      }
-      return d;
-    }
-    if (def.movie) {
-      const v = document.createElement("video");
-      const src = this.host.url(def.movie);
-      if (src) v.src = src;
-      v.autoplay = true;
-      v.loop = true;
-      v.muted = true;
-      v.playsInline = true;
-      return v;
-    }
-    if (def.text !== undefined || def.textExpr) {
-      const d = document.createElement("div");
-      d.className = "pg-show-text";
-      d.textContent = def.textExpr ? this.host.text(def.textExpr) : def.text!;
-      return d;
-    }
-    if (def.frames?.length) return this.animated(def, depth);
-    if (def.layered) return this.layered(def, depth);
-    if (def.file) {
-      const img = document.createElement("img");
-      img.draggable = false;
-      img.decoding = "async";
-      const src = this.host.url(def.file);
-      if (src) img.src = src;
-      else console.warn("[pgvn] нет файла", def.file);
-      if (def.props?.size) {
-        img.style.width = `${def.props.size[0]}px`;
-        img.style.height = `${def.props.size[1]}px`;
-      }
-      return img;
-    }
-    return document.createElement("div");
-  }
-
-  /** Frame-by-frame ATL animation: swaps children on timers while attached. */
-  private animated(def: ImageDef, depth: number): HTMLElement {
-    const box = document.createElement("div");
-    box.style.position = "relative";
-    const frames = def.frames!;
-    let i = 0;
-    let started = false;
-    box.append(this.build(frames[0].img, depth + 1));
-    const tick = () => {
-      if (box.isConnected) started = true;
-      else if (started) return;
-      const d = frames[i].d ?? 0;
-      const last = i === frames.length - 1;
-      if (!d || (last && !def.repeat)) return;
-      window.setTimeout(() => {
-        if (started && !box.isConnected) return;
-        i = last ? 0 : i + 1;
-        box.replaceChildren(this.build(frames[i].img, depth + 1));
-        tick();
-      }, d * 1000);
-    };
-    tick();
-    return box;
-  }
-
-  /** layeredimage: stack the layers selected by the image's attributes. */
-  private layered(def: ImageDef, depth: number): HTMLElement {
-    const box = document.createElement("div");
-    box.style.position = "relative";
-    const sel = new Set(def.selected ?? []);
-    const groupsSelected = new Set(
-      def.layered!.filter((l) => l.attr && sel.has(l.attr) && l.group).map((l) => l.group));
-    const imgs: ImageDef[] = [];
-    for (const layer of def.layered!) {
-      if (layer.always) imgs.push(layer.always);
-      else if (layer.cond) {
-        const hit = layer.cond.find(([c]) => c === null || this.host.evalCond(c));
-        if (hit) imgs.push(hit[1]);
-      } else if (layer.attr !== undefined) {
-        const on = sel.has(layer.attr) || (!!layer.default && !(layer.group && groupsSelected.has(layer.group)));
-        if (!on || !layer.img || layer.null) continue;
-        if (layer.if_any && !layer.if_any.some((a) => sel.has(a))) continue;
-        if (layer.if_all && !layer.if_all.every((a) => sel.has(a))) continue;
-        if (layer.if_not && layer.if_not.some((a) => sel.has(a))) continue;
-        imgs.push(layer.img);
-      }
-    }
-    imgs.forEach((img, n) => {
-      const child = this.build(img, depth + 1);
-      if (n > 0) {
-        child.style.position = "absolute";
-        child.style.left = "0";
-        child.style.top = "0";
-      }
-      box.append(child);
-    });
-    return box;
-  }
-
-  camera(at: AtSpec[]) {
-    const p: Record<string, any> = {};
-    for (const spec of at) Object.assign(p, spec.props ?? {}, spec.name ? this.host.transform(spec.name) ?? {} : {});
-    const zoom = p.zoom ?? 1;
-    this.master.style.transformOrigin = "50% 50%";
-    this.master.style.transform = `translate(${p.xoffset ?? 0}px, ${p.yoffset ?? 0}px) scale(${zoom})`;
-    this.cameraAt = at;
-  }
-
-  cameraAt: AtSpec[] = [];
-
-  private place(el: HTMLElement, def: ImageDef, at: AtSpec[]) {
-    const p: Record<string, any> = { ...POSITIONS.default, ...(def.props ?? {}) };
-    for (const spec of [...(def.at ?? []), ...at]) {
-      if (spec.effect === "shake") {
-        const dist = spec.dist ?? 20;
-        el.animate([0, dist, -dist, dist * 0.6, -dist * 0.6, 0].map((x) => ({ translate: `${x}px 0` })),
-                   { duration: (spec.d ?? 0.5) * 1000 });
-        continue;
-      }
-      if (spec.pos) Object.assign(p, POSITIONS[spec.pos] ?? {});
-      if (spec.name && !spec.props) Object.assign(p, this.host.transform(spec.name) ?? POSITIONS[spec.name] ?? {});
-      if (spec.props) Object.assign(p, spec.props);
-    }
-    normalize(p);
-    const pos = (v: number, total: number) => (Number.isInteger(v) && Math.abs(v) > 1 ? `${v}px` : `${v * total}px`);
-    const anchor = (v: number) => (Number.isInteger(v) && Math.abs(v) > 1 ? `${v}px` : `${v * 100}%`);
-    el.style.left = `calc(${pos(p.xpos, this.width)} + ${p.xoffset ?? 0}px)`;
-    el.style.top = `calc(${pos(p.ypos, this.height)} + ${p.yoffset ?? 0}px)`;
-    const ax = anchor(p.xanchor);
-    const ay = anchor(p.yanchor);
-    el.style.transformOrigin = `${ax} ${ay}`;
-    const zx = (p.zoom ?? 1) * (p.xzoom ?? 1);
-    const zy = (p.zoom ?? 1) * (p.yzoom ?? 1);
-    el.style.transform = `translate(-${ax}, -${ay}) scale(${zx}, ${zy})` + (p.rotate ? ` rotate(${p.rotate}deg)` : "");
-    // translate(-%) must use the element box, so negative percentages of px anchors are written as is
-    if (ax.endsWith("px") || ay.endsWith("px"))
-      el.style.transform = `translate(calc(-1 * ${ax}), calc(-1 * ${ay})) scale(${zx}, ${zy})`;
-    if (p.alpha !== undefined) el.style.opacity = String(p.alpha);
-    if (p.filter) el.style.filter = `${p.filter}(1)`;
-  }
-
-  // --- transitions ---------------------------------------------------------------
-
-  /** Remember the current picture as the starting point of the next transition. */
-  commit() {
-    this.committed = this.master.cloneNode(true) as HTMLElement;
-  }
-
-  async transition(t: Transition | null | undefined): Promise<void> {
-    const before = this.committed;
-    this.commit();
-    if (!t || !before || this.fast) return;
-    if (t.t === "punch") return this.punch(t);
-    const old = before;
-    old.classList.add("pg-old");
-    this.overlay.append(old);
-    try {
-      if (t.t === "fade") {
-        const color = document.createElement("div");
-        color.className = "pg-fill";
-        color.style.background = t.color ?? "#000";
-        color.style.opacity = "0";
-        this.overlay.append(color);
-        await animate(color, [{ opacity: 0 }, { opacity: 1 }], t.out ?? 0.5);
-        old.remove();
-        if (t.hold) await sleep(t.hold);
-        await animate(color, [{ opacity: 1 }, { opacity: 0 }], t.in ?? 0.5);
-        color.remove();
-      } else if (t.t === "wipe") {
-        const dir = t.dir ?? "right";
-        const end = { left: "inset(0 100% 0 0)", right: "inset(0 0 0 100%)", up: "inset(0 0 100% 0)",
-                      down: "inset(100% 0 0 0)" }[dir] ?? "inset(0 0 0 100%)";
-        await animate(old, [{ clipPath: "inset(0 0 0 0)" }, { clipPath: end }], t.d ?? 1);
-      } else if (t.t === "slide") {
-        const dir = t.dir ?? "left";
-        const shift = { left: "-100%, 0", right: "100%, 0", top: "0, -100%", bottom: "0, 100%" }[dir];
-        await animate(old, [{ transform: "translate(0, 0)", opacity: 1 },
-                            { transform: `translate(${shift})`, opacity: 0 }], t.d ?? 0.5);
-      } else {
-        await animate(old, [{ opacity: 1 }, { opacity: 0 }], t.d ?? 0.5);
-      }
-    } finally {
-      old.remove();
-    }
-  }
-
-  private async punch(t: Transition) {
-    const axis = t.dir === "h" ? "X" : "Y";
-    await animate(this.master, [0, 12, -10, 8, -6, 3, 0].map((v) => ({ transform: `translate${axis}(${v}px)` })),
-                  t.d ?? 0.3);
-  }
-
-  preload(def: ImageDef | null) {
-    if (def?.file) {
-      const src = this.host.url(def.file);
-      if (src) new Image().src = src;
-    }
-  }
-}
-
-function normalize(p: Record<string, any>) {
-  if (p.align) [p.xalign, p.yalign] = p.align;
-  if (p.pos) [p.xpos, p.ypos] = p.pos;
-  if (p.anchor) [p.xanchor, p.yanchor] = p.anchor;
-  if (p.xalign !== undefined) p.xpos = p.xanchor = p.xalign;
-  if (p.yalign !== undefined) p.ypos = p.yanchor = p.yalign;
-  if (p.xcenter !== undefined) [p.xpos, p.xanchor] = [p.xcenter, 0.5];
-  if (p.ycenter !== undefined) [p.ypos, p.yanchor] = [p.ycenter, 0.5];
-  p.xanchor = asFloat(p.xanchor);
-  p.yanchor = asFloat(p.yanchor);
-  p.xpos = asFloat(p.xpos);
-  p.ypos = asFloat(p.ypos);
-}
-
-// Ren'Py: float means fraction, int means pixels — but 0 and 1 as ints are common in
-// ATL ("xalign 1") and still mean fractions there; renderer treats |v|<=1 as fraction.
-function asFloat(v: any): number {
-  return typeof v === "number" ? v : 0;
-}
-
-export function sleep(seconds: number) {
-  return new Promise<void>((r) => setTimeout(r, seconds * 1000));
-}
-
-function animate(el: HTMLElement, frames: Keyframe[], seconds: number): Promise<void> {
-  return new Promise((resolve) => {
-    const a = el.animate(frames, { duration: seconds * 1000, fill: "forwards", easing: "ease-in-out" });
-    a.onfinish = () => resolve();
-    a.oncancel = () => resolve();
-  });
-}
+// DOM renderer for the image layer: one absolutely positioned element per shown tag.
+// The stage has the game's native resolution and is scaled with a CSS transform.
+
+import type { AtSpec, ImageDef, ShownImage, Transition } from "./types";
+
+const POSITIONS: Record<string, Record<string, number>> = {
+  left: { xpos: 0, xanchor: 0, ypos: 1, yanchor: 1 },
+  right: { xpos: 1, xanchor: 1, ypos: 1, yanchor: 1 },
+  center: { xpos: 0.5, xanchor: 0.5, ypos: 1, yanchor: 1 },
+  default: { xpos: 0.5, xanchor: 0.5, ypos: 1, yanchor: 1 },
+  reset: { xpos: 0.5, xanchor: 0.5, ypos: 1, yanchor: 1 },
+  truecenter: { xpos: 0.5, xanchor: 0.5, ypos: 0.5, yanchor: 0.5 },
+  topleft: { xpos: 0, xanchor: 0, ypos: 0, yanchor: 0 },
+  topright: { xpos: 1, xanchor: 1, ypos: 0, yanchor: 0 },
+  top: { xpos: 0.5, xanchor: 0.5, ypos: 0, yanchor: 0 },
+  offscreenleft: { xpos: 0, xanchor: 1, ypos: 1, yanchor: 1 },
+  offscreenright: { xpos: 1, xanchor: 0, ypos: 1, yanchor: 1 },
+};
+
+export interface ResolvedImage {
+  def: ImageDef;
+  name: string[];
+}
+
+export interface RendererHost {
+  url(file: string): string | null;
+  resolveRef(name: string): ImageDef | null;
+  evalCond(e: any): boolean;
+  transform(name: string): Record<string, any> | null;
+  text(e: any): string;
+}
+
+interface Entry extends ShownImage {
+  el: HTMLElement;
+}
+
+export class Renderer {
+  readonly stage: HTMLDivElement;
+  readonly master: HTMLDivElement;
+  private overlay: HTMLDivElement;
+  private shown = new Map<string, Entry>();
+  private committed: HTMLElement | null = null;
+  fast = false;
+
+  constructor(parent: HTMLElement, public width: number, public height: number,
+              private host: RendererHost) {
+    this.stage = document.createElement("div");
+    this.stage.className = "pg-stage";
+    this.stage.style.width = `${width}px`;
+    this.stage.style.height = `${height}px`;
+    this.master = document.createElement("div");
+    this.master.className = "pg-layer";
+    this.overlay = document.createElement("div");
+    this.overlay.className = "pg-layer pg-transition";
+    this.stage.append(this.master, this.overlay);
+    parent.append(this.stage);
+  }
+
+  fit(container: HTMLElement) {
+    const s = Math.min(container.clientWidth / this.width, container.clientHeight / this.height);
+    this.stage.style.transform = `translate(-50%, -50%) scale(${s})`;
+  }
+
+  // --- scene state ---------------------------------------------------------
+
+  scene() {
+    for (const e of this.shown.values()) e.el.remove();
+    this.shown.clear();
+  }
+
+  show(img: ResolvedImage, tag: string, at: AtSpec[], opts: { zorder?: number; behind?: string[] } = {}) {
+    const prev = this.shown.get(tag);
+    const atSpecs = at.length ? at : prev?.at ?? [];
+    const el = this.build(img.def);
+    el.classList.add("pg-image");
+    this.place(el, img.def, atSpecs);
+    const entry: Entry = { tag, name: img.name, at: atSpecs, zorder: opts.zorder ?? prev?.zorder ?? 0, el };
+    if (prev) {
+      prev.el.replaceWith(el);
+    } else {
+      const behind = opts.behind?.map((t) => this.shown.get(t)?.el).find(Boolean);
+      const later = [...this.shown.values()].find((e) => e.zorder > entry.zorder)?.el;
+      this.master.insertBefore(el, behind ?? later ?? null);
+    }
+    this.shown.set(tag, entry);
+  }
+
+  hide(tag: string) {
+    const e = this.shown.get(tag);
+    if (!e) return;
+    e.el.remove();
+    this.shown.delete(tag);
+  }
+
+  isShown(tag: string) {
+    return this.shown.has(tag);
+  }
+
+  attrsOf(tag: string): string[] | null {
+    return this.shown.get(tag)?.name ?? null;
+  }
+
+  snapshot(): ShownImage[] {
+    return [...this.shown.values()].map(({ tag, name, at, zorder }) => ({ tag, name, at, zorder }));
+  }
+
+  // --- displayables ------------------------------------------------------------
+
+  private build(def: ImageDef, depth = 0): HTMLElement {
+    if (depth > 8) return document.createElement("div");
+    if (def.ref) {
+      const ref = this.host.resolveRef(def.ref);
+      if (ref) return this.build({ ...ref, props: { ...ref.props, ...def.props } }, depth + 1);
+    }
+    if (def.switch) {
+      const hit = def.switch.find(([c]) => this.host.evalCond(c));
+      if (hit) return this.build(hit[1], depth + 1);
+    }
+    if (def.color) {
+      const d = document.createElement("div");
+      d.style.background = def.color;
+      d.style.width = `${this.width}px`;
+      d.style.height = `${this.height}px`;
+      return d;
+    }
+    if (def.composite) {
+      const d = document.createElement("div");
+      d.style.position = "relative";
+      if (def.size) {
+        d.style.width = `${def.size[0]}px`;
+        d.style.height = `${def.size[1]}px`;
+      }
+      for (const layer of def.composite) {
+        const child = this.build(layer.img, depth + 1);
+        child.style.position = "absolute";
+        child.style.left = `${layer.pos[0]}px`;
+        child.style.top = `${layer.pos[1]}px`;
+        d.append(child);
+      }
+      return d;
+    }
+    if (def.movie) {
+      const v = document.createElement("video");
+      const src = this.host.url(def.movie);
+      if (src) v.src = src;
+      v.autoplay = true;
+      v.loop = true;
+      v.muted = true;
+      v.playsInline = true;
+      return v;
+    }
+    if (def.text !== undefined || def.textExpr) {
+      const d = document.createElement("div");
+      d.className = "pg-show-text";
+      d.textContent = this.host.text(def.textExpr ?? { k: "const", v: def.text });
+      return d;
+    }
+    if (def.frames?.length) return this.animated(def, depth);
+    if (def.layered) return this.layered(def, depth);
+    if (def.file) {
+      const img = document.createElement("img");
+      img.draggable = false;
+      img.decoding = "async";
+      const src = this.host.url(def.file);
+      if (src) img.src = src;
+      else console.warn("[pgvn] нет файла", def.file);
+      if (def.props?.size) {
+        img.style.width = `${def.props.size[0]}px`;
+        img.style.height = `${def.props.size[1]}px`;
+      }
+      return img;
+    }
+    return document.createElement("div");
+  }
+
+  /** Frame-by-frame ATL animation: swaps children on timers while attached. */
+  private animated(def: ImageDef, depth: number): HTMLElement {
+    const box = document.createElement("div");
+    box.style.position = "relative";
+    const frames = def.frames!;
+    let i = 0;
+    let started = false;
+    box.append(this.build(frames[0].img, depth + 1));
+    const tick = () => {
+      if (box.isConnected) started = true;
+      else if (started) return;
+      const d = frames[i].d ?? 0;
+      const last = i === frames.length - 1;
+      if (!d || (last && !def.repeat)) return;
+      window.setTimeout(() => {
+        if (started && !box.isConnected) return;
+        i = last ? 0 : i + 1;
+        box.replaceChildren(this.build(frames[i].img, depth + 1));
+        tick();
+      }, d * 1000);
+    };
+    tick();
+    return box;
+  }
+
+  /** layeredimage: stack the layers selected by the image's attributes. */
+  private layered(def: ImageDef, depth: number): HTMLElement {
+    const box = document.createElement("div");
+    box.style.position = "relative";
+    const sel = new Set(def.selected ?? []);
+    const groupsSelected = new Set(
+      def.layered!.filter((l) => l.attr && sel.has(l.attr) && l.group).map((l) => l.group));
+    const imgs: ImageDef[] = [];
+    for (const layer of def.layered!) {
+      if (layer.always) imgs.push(layer.always);
+      else if (layer.cond) {
+        const hit = layer.cond.find(([c]) => c === null || this.host.evalCond(c));
+        if (hit) imgs.push(hit[1]);
+      } else if (layer.attr !== undefined) {
+        const on = sel.has(layer.attr) || (!!layer.default && !(layer.group && groupsSelected.has(layer.group)));
+        if (!on || !layer.img || layer.null) continue;
+        if (layer.if_any && !layer.if_any.some((a) => sel.has(a))) continue;
+        if (layer.if_all && !layer.if_all.every((a) => sel.has(a))) continue;
+        if (layer.if_not && layer.if_not.some((a) => sel.has(a))) continue;
+        imgs.push(layer.img);
+      }
+    }
+    imgs.forEach((img, n) => {
+      const child = this.build(img, depth + 1);
+      if (n > 0) {
+        child.style.position = "absolute";
+        child.style.left = "0";
+        child.style.top = "0";
+      }
+      box.append(child);
+    });
+    return box;
+  }
+
+  camera(at: AtSpec[]) {
+    const p: Record<string, any> = {};
+    for (const spec of at) Object.assign(p, spec.props ?? {}, spec.name ? this.host.transform(spec.name) ?? {} : {});
+    const zoom = p.zoom ?? 1;
+    this.master.style.transformOrigin = "50% 50%";
+    this.master.style.transform = `translate(${p.xoffset ?? 0}px, ${p.yoffset ?? 0}px) scale(${zoom})`;
+    this.cameraAt = at;
+  }
+
+  cameraAt: AtSpec[] = [];
+
+  private place(el: HTMLElement, def: ImageDef, at: AtSpec[]) {
+    const p: Record<string, any> = { ...POSITIONS.default, ...(def.props ?? {}) };
+    for (const spec of [...(def.at ?? []), ...at]) {
+      if (spec.effect === "shake") {
+        const dist = spec.dist ?? 20;
+        el.animate([0, dist, -dist, dist * 0.6, -dist * 0.6, 0].map((x) => ({ translate: `${x}px 0` })),
+                   { duration: (spec.d ?? 0.5) * 1000 });
+        continue;
+      }
+      if (spec.pos) Object.assign(p, POSITIONS[spec.pos] ?? {});
+      if (spec.name && !spec.props) Object.assign(p, this.host.transform(spec.name) ?? POSITIONS[spec.name] ?? {});
+      if (spec.props) Object.assign(p, spec.props);
+    }
+    normalize(p);
+    const pos = (v: number, total: number) => (Number.isInteger(v) && Math.abs(v) > 1 ? `${v}px` : `${v * total}px`);
+    const anchor = (v: number) => (Number.isInteger(v) && Math.abs(v) > 1 ? `${v}px` : `${v * 100}%`);
+    el.style.left = `calc(${pos(p.xpos, this.width)} + ${p.xoffset ?? 0}px)`;
+    el.style.top = `calc(${pos(p.ypos, this.height)} + ${p.yoffset ?? 0}px)`;
+    const ax = anchor(p.xanchor);
+    const ay = anchor(p.yanchor);
+    el.style.transformOrigin = `${ax} ${ay}`;
+    const zx = (p.zoom ?? 1) * (p.xzoom ?? 1);
+    const zy = (p.zoom ?? 1) * (p.yzoom ?? 1);
+    el.style.transform = `translate(-${ax}, -${ay}) scale(${zx}, ${zy})` + (p.rotate ? ` rotate(${p.rotate}deg)` : "");
+    // translate(-%) must use the element box, so negative percentages of px anchors are written as is
+    if (ax.endsWith("px") || ay.endsWith("px"))
+      el.style.transform = `translate(calc(-1 * ${ax}), calc(-1 * ${ay})) scale(${zx}, ${zy})`;
+    if (p.alpha !== undefined) el.style.opacity = String(p.alpha);
+    if (p.filter) el.style.filter = `${p.filter}(1)`;
+  }
+
+  // --- transitions ---------------------------------------------------------------
+
+  /** Remember the current picture as the starting point of the next transition. */
+  commit() {
+    this.committed = this.master.cloneNode(true) as HTMLElement;
+  }
+
+  async transition(t: Transition | null | undefined): Promise<void> {
+    const before = this.committed;
+    this.commit();
+    if (!t || !before || this.fast) return;
+    if (t.t === "punch") return this.punch(t);
+    const old = before;
+    old.classList.add("pg-old");
+    this.overlay.append(old);
+    try {
+      if (t.t === "fade") {
+        const color = document.createElement("div");
+        color.className = "pg-fill";
+        color.style.background = t.color ?? "#000";
+        color.style.opacity = "0";
+        this.overlay.append(color);
+        await animate(color, [{ opacity: 0 }, { opacity: 1 }], t.out ?? 0.5);
+        old.remove();
+        if (t.hold) await sleep(t.hold);
+        await animate(color, [{ opacity: 1 }, { opacity: 0 }], t.in ?? 0.5);
+        color.remove();
+      } else if (t.t === "wipe") {
+        const dir = t.dir ?? "right";
+        const end = { left: "inset(0 100% 0 0)", right: "inset(0 0 0 100%)", up: "inset(0 0 100% 0)",
+                      down: "inset(100% 0 0 0)" }[dir] ?? "inset(0 0 0 100%)";
+        await animate(old, [{ clipPath: "inset(0 0 0 0)" }, { clipPath: end }], t.d ?? 1);
+      } else if (t.t === "slide") {
+        const dir = t.dir ?? "left";
+        const shift = { left: "-100%, 0", right: "100%, 0", top: "0, -100%", bottom: "0, 100%" }[dir];
+        await animate(old, [{ transform: "translate(0, 0)", opacity: 1 },
+                            { transform: `translate(${shift})`, opacity: 0 }], t.d ?? 0.5);
+      } else {
+        await animate(old, [{ opacity: 1 }, { opacity: 0 }], t.d ?? 0.5);
+      }
+    } finally {
+      old.remove();
+    }
+  }
+
+  private async punch(t: Transition) {
+    const axis = t.dir === "h" ? "X" : "Y";
+    await animate(this.master, [0, 12, -10, 8, -6, 3, 0].map((v) => ({ transform: `translate${axis}(${v}px)` })),
+                  t.d ?? 0.3);
+  }
+
+  preload(def: ImageDef | null) {
+    if (def?.file) {
+      const src = this.host.url(def.file);
+      if (src) new Image().src = src;
+    }
+  }
+}
+
+function normalize(p: Record<string, any>) {
+  if (p.align) [p.xalign, p.yalign] = p.align;
+  if (p.pos) [p.xpos, p.ypos] = p.pos;
+  if (p.anchor) [p.xanchor, p.yanchor] = p.anchor;
+  if (p.xalign !== undefined) p.xpos = p.xanchor = p.xalign;
+  if (p.yalign !== undefined) p.ypos = p.yanchor = p.yalign;
+  if (p.xcenter !== undefined) [p.xpos, p.xanchor] = [p.xcenter, 0.5];
+  if (p.ycenter !== undefined) [p.ypos, p.yanchor] = [p.ycenter, 0.5];
+  p.xanchor = asFloat(p.xanchor);
+  p.yanchor = asFloat(p.yanchor);
+  p.xpos = asFloat(p.xpos);
+  p.ypos = asFloat(p.ypos);
+}
+
+// Ren'Py: float means fraction, int means pixels — but 0 and 1 as ints are common in
+// ATL ("xalign 1") and still mean fractions there; renderer treats |v|<=1 as fraction.
+function asFloat(v: any): number {
+  return typeof v === "number" ? v : 0;
+}
+
+export function sleep(seconds: number) {
+  return new Promise<void>((r) => setTimeout(r, seconds * 1000));
+}
+
+function animate(el: HTMLElement, frames: Keyframe[], seconds: number): Promise<void> {
+  return new Promise((resolve) => {
+    const a = el.animate(frames, { duration: seconds * 1000, fill: "forwards", easing: "ease-in-out" });
+    a.onfinish = () => resolve();
+    a.oncancel = () => resolve();
+  });
+}
diff --git a/frontend/src/player/text.ts b/frontend/src/player/text.ts
index 8e60273..6abce36 100644
--- a/frontend/src/player/text.ts
+++ b/frontend/src/player/text.ts
@@ -22,7 +22,8 @@ export interface ParsedText {
   length: number; // number of visible characters
 }
 
-export function interpolate(text: string, lookup: (expr: string) => any): string {
+export function interpolate(text: string, lookup: (expr: string) => any,
+                            translate: (s: string) => string = (s) => s): string {
   return text.replace(/\[\[|\[([^\[\]]+)\]/g, (m, expr: string | undefined) => {
     if (m === "[[") return "[";
     let src = expr!.trim();
@@ -33,6 +34,7 @@ export function interpolate(text: string, lookup: (expr: string) => any): string
       src = src.slice(0, bang);
     }
     let v = pyStr(lookup(src));
+    if (flags.includes("t")) v = translate(v);
     if (flags.includes("u")) v = v.toUpperCase();
     if (flags.includes("l")) v = v.toLowerCase();
     if (flags.includes("c")) v = v.charAt(0).toUpperCase() + v.slice(1);
diff --git a/frontend/src/player/types.ts b/frontend/src/player/types.ts
index e895d84..69862d7 100644
--- a/frontend/src/player/types.ts
+++ b/frontend/src/player/types.ts
@@ -1,143 +1,145 @@
-// PGVN v1 — the format produced by the backend converter (see docs/ARCHITECTURE.md).
-
-export type Expr = { k: string; [key: string]: any };
-export type PyStmt = { op: string; [key: string]: any };
-
-export interface Transition {
-  t: "dissolve" | "fade" | "move" | "punch" | "wipe" | "slide" | "ref";
-  d?: number;
-  out?: number;
-  hold?: number;
-  in?: number;
-  color?: string;
-  dir?: string;
-  name?: string;
-}
-
-export interface ImageDef {
-  file?: string;
-  color?: string;
-  ref?: string;
-  movie?: string;
-  expr?: Expr;
-  switch?: [Expr, ImageDef][];
-  composite?: { pos: [number, number]; img: ImageDef }[];
-  size?: [number, number] | null;
-  text?: string;
-  textExpr?: Expr;
-  props?: Record<string, any>;
-  frames?: { img: ImageDef; d?: number }[];
-  repeat?: boolean;
-  layered?: Layer[];
-  at?: AtSpec[];
-  selected?: string[]; // attributes chosen for a layered image (set by the engine)
-}
-
-export interface Layer {
-  always?: ImageDef;
-  attr?: string;
-  group?: string | null;
-  default?: boolean;
-  null?: boolean;
-  img?: ImageDef;
-  if_any?: string[];
-  if_all?: string[];
-  if_not?: string[];
-  cond?: [Expr | null, ImageDef][];
-  autoGroup?: string;
-}
-
-export interface AtSpec {
-  pos?: string;
-  name?: string;
-  props?: Record<string, any>;
-  effect?: "shake";
-  d?: number;
-  dist?: number;
-}
-
-export interface CharacterDef {
-  name?: string | null;
-  nameExpr?: Expr;
-  color?: string;
-  whatColor?: string;
-  whatPrefix?: string;
-  whatSuffix?: string;
-  whoPrefix?: string;
-  whoSuffix?: string;
-  image?: string;
-  nvl?: boolean;
-  whatItalic?: boolean;
-  whatBold?: boolean;
-}
-
-export type Node = { op: string; [key: string]: any };
-
-export interface Label {
-  name: string;
-  body: Node[];
-  params?: [string, Expr | null][];
-}
-
-export interface Anchor {
-  label: string;
-  path: number[];
-  params?: [string, Expr | null][] | null;
-}
-
-export interface ScriptModule {
-  file: string;
-  labels: Label[];
-  anchors?: Record<string, Anchor>;
-}
-
-export interface GameData {
-  format: string;
-  title: string | null;
-  resolution: [number, number];
-  entry: string;
-  scripts: string[];
-  characters: Record<string, CharacterDef>;
-  images: Record<string, ImageDef>;
-  transforms: Record<string, Record<string, any>>;
-  transitions: Record<string, Transition | null>;
-  audio: Record<string, string>;
-  channels?: Record<string, { mixer: string; loop: boolean }>;
-  files: Record<string, string>;
-  defaults: [string, Expr][];
-  init: PyStmt[];
-  ui: Record<string, any>;
-}
-
-export interface Manifest {
-  format: string;
-  files: Record<string, { hash: string; size: number }>;
-}
-
-export interface Frame {
-  label: string;
-  path: number[];
-  // values of label parameters shadowed by a call, restored on return
-  saved?: Record<string, { had: boolean; value: any }>;
-}
-
-export interface ShownImage {
-  tag: string;
-  name: string[];
-  at: AtSpec[];
-  zorder: number;
-  layer?: string;
-}
-
-export interface SaveData {
-  v: 1;
-  cur: Frame;
-  stack: Frame[];
-  store: any;
-  scene: ShownImage[];
-  music: { file: string; loop: boolean } | null;
-  window: boolean;
-  camera?: AtSpec[];
-  menuSeen?: string[];
-  text?: string;
-}
+// PGVN v1 — the format produced by the backend converter (see docs/ARCHITECTURE.md).
+
+export type Expr = { k: string; [key: string]: any };
+export type PyStmt = { op: string; [key: string]: any };
+
+export interface Transition {
+  t: "dissolve" | "fade" | "move" | "punch" | "wipe" | "slide" | "ref";
+  d?: number;
+  out?: number;
+  hold?: number;
+  in?: number;
+  color?: string;
+  dir?: string;
+  name?: string;
+}
+
+export interface ImageDef {
+  file?: string;
+  color?: string;
+  ref?: string;
+  movie?: string;
+  expr?: Expr;
+  switch?: [Expr, ImageDef][];
+  composite?: { pos: [number, number]; img: ImageDef }[];
+  size?: [number, number] | null;
+  text?: string;
+  textExpr?: Expr;
+  props?: Record<string, any>;
+  frames?: { img: ImageDef; d?: number }[];
+  repeat?: boolean;
+  layered?: Layer[];
+  at?: AtSpec[];
+  selected?: string[]; // attributes chosen for a layered image (set by the engine)
+}
+
+export interface Layer {
+  always?: ImageDef;
+  attr?: string;
+  group?: string | null;
+  default?: boolean;
+  null?: boolean;
+  img?: ImageDef;
+  if_any?: string[];
+  if_all?: string[];
+  if_not?: string[];
+  cond?: [Expr | null, ImageDef][];
+  autoGroup?: string;
+}
+
+export interface AtSpec {
+  pos?: string;
+  name?: string;
+  props?: Record<string, any>;
+  effect?: "shake";
+  d?: number;
+  dist?: number;
+}
+
+export interface CharacterDef {
+  name?: string | null;
+  nameExpr?: Expr;
+  color?: string;
+  whatColor?: string;
+  whatPrefix?: string;
+  whatSuffix?: string;
+  whoPrefix?: string;
+  whoSuffix?: string;
+  image?: string;
+  nvl?: boolean;
+  whatItalic?: boolean;
+  whatBold?: boolean;
+}
+
+export type Node = { op: string; [key: string]: any };
+
+export interface Label {
+  name: string;
+  body: Node[];
+  params?: [string, Expr | null][];
+}
+
+export interface Anchor {
+  label: string;
+  path: number[];
+  params?: [string, Expr | null][] | null;
+}
+
+export interface ScriptModule {
+  file: string;
+  labels: Label[];
+  anchors?: Record<string, Anchor>;
+}
+
+export interface GameData {
+  format: string;
+  title: string | null;
+  resolution: [number, number];
+  entry: string;
+  scripts: string[];
+  characters: Record<string, CharacterDef>;
+  images: Record<string, ImageDef>;
+  transforms: Record<string, Record<string, any>>;
+  transitions: Record<string, Transition | null>;
+  audio: Record<string, string>;
+  channels?: Record<string, { mixer: string; loop: boolean }>;
+  files: Record<string, string>;
+  defaults: [string, Expr][];
+  init: PyStmt[];
+  ui: Record<string, any>;
+  sourceLang?: string;
+  locales?: Record<string, import("./i18n").LocaleInfo>;
+}
+
+export interface Manifest {
+  format: string;
+  files: Record<string, { hash: string; size: number }>;
+}
+
+export interface Frame {
+  label: string;
+  path: number[];
+  // values of label parameters shadowed by a call, restored on return
+  saved?: Record<string, { had: boolean; value: any }>;
+}
+
+export interface ShownImage {
+  tag: string;
+  name: string[];
+  at: AtSpec[];
+  zorder: number;
+  layer?: string;
+}
+
+export interface SaveData {
+  v: 1;
+  cur: Frame;
+  stack: Frame[];
+  store: any;
+  scene: ShownImage[];
+  music: { file: string; loop: boolean } | null;
+  window: boolean;
+  camera?: AtSpec[];
+  menuSeen?: string[];
+  text?: string;
+}