diff --git a/tests/test_upload_module.py b/tests/test_upload_module.py
new file mode 100644
index 0000000..aa5f82a
--- /dev/null
+++ b/tests/test_upload_module.py
@@ -0,0 +1,269 @@
+"""Тесты переиспользуемого модуля upload (backend): session, safe_name, blueprint.
+
+Запуск:
+    python3 tests/test_upload_module.py
+    pytest tests/test_upload_module.py
+"""
+
+import os
+import sys
+
+# Корень проекта — для импорта пакета upload
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from flask import Flask
+
+from upload.backend.session import (
+    create_session, add_file, get_files, file_count,
+    store_result, get_result, store_csv, get_csv,
+    cleanup, request_cancel, get_cancel_event,
+)
+from upload.backend.upload_refs import safe_name, create_upload_refs_blueprint
+
+VM_PREFIX = "https://contracts.kube5s.ru/drhider-upload/"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# session
+# ═══════════════════════════════════════════════════════════════════════════
+
+def test_create_session():
+    sid = create_session()
+    assert len(sid) == 32  # uuid4().hex
+
+
+def test_add_file_and_get():
+    sid = create_session()
+    assert add_file(sid, "a.txt", b"hello") is True
+    assert get_files(sid) == [("a.txt", b"hello")]
+    assert file_count(sid) == 1
+
+
+def test_add_file_missing_session():
+    assert add_file("nonexistent", "a.txt", b"x") is False
+    assert get_files("nonexistent") is None
+
+
+def test_session_limit(monkeypatch):
+    # importlib: `import ...session.add_file as m` затеняется одноимённой функцией
+    import importlib
+    add_file_mod = importlib.import_module("upload.backend.session.add_file")
+    old = add_file_mod.MAX_SESSION_BYTES
+    add_file_mod.MAX_SESSION_BYTES = 10
+    try:
+        sid = create_session()
+        assert add_file(sid, "a", b"12345") is True
+        # суммарно уже 5; +6 = 11 > 10 → False
+        assert add_file(sid, "b", b"123456") is False
+        assert file_count(sid) == 1
+    finally:
+        add_file_mod.MAX_SESSION_BYTES = old
+
+
+def test_store_result_and_csv():
+    sid = create_session()
+    assert store_result(sid, b"zip") is True
+    assert get_result(sid) == b"zip"
+    assert store_csv(sid, "a,b") is True
+    assert get_csv(sid) == "a,b"
+
+
+def test_cleanup():
+    sid = create_session()
+    cleanup(sid)
+    assert get_files(sid) is None
+
+
+def test_cancel():
+    sid = create_session()
+    assert request_cancel(sid) is True
+    ev = get_cancel_event(sid)
+    assert ev is not None and ev.is_set()
+    assert request_cancel("nonexistent") is False
+    assert get_cancel_event("nonexistent") is None
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# safe_name
+# ═══════════════════════════════════════════════════════════════════════════
+
+def test_safe_name():
+    assert safe_name("a.txt") == "a.txt"
+    assert safe_name("dir/sub/a.txt") == "dir/sub/a.txt"
+    assert safe_name("dir\\sub\\a.txt") == "dir/sub/a.txt"
+    assert safe_name("../etc/passwd") == ""
+    assert safe_name("a/../../b") == ""
+    assert safe_name("") == ""
+    assert safe_name("./a.txt") == "a.txt"
+    assert safe_name("/etc/passwd") == "etc/passwd"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# blueprint upload_refs
+# ═══════════════════════════════════════════════════════════════════════════
+
+class _FakeStream:
+    def __init__(self, payload=b"", status=200, exc=None):
+        self._payload = payload
+        self._status = status
+        self._exc = exc
+
+    def __enter__(self):
+        if self._exc:
+            raise self._exc
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+    def raise_for_status(self):
+        if self._status >= 400:
+            raise RuntimeError("HTTP %d" % self._status)
+
+    def iter_bytes(self):
+        yield self._payload
+
+
+class _FakeClient:
+    """Имитация httpx.Client: stream/delete без сети.
+
+    behavior: dict url -> "ok" | {"payload": bytes} | {"exc": Exception}
+    """
+
+    def __init__(self, behavior):
+        self._behavior = behavior
+        self.deleted = []
+        self.streams = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+    def stream(self, method, url):
+        self.streams.append((method, url))
+        b = self._behavior.get(url)
+        if isinstance(b, dict) and "payload" in b:
+            return _FakeStream(payload=b["payload"])
+        if isinstance(b, dict) and "exc" in b:
+            return _FakeStream(exc=b["exc"])
+        if b == "ok":
+            return _FakeStream()
+        return _FakeStream(status=500)
+
+    def delete(self, url):
+        self.deleted.append(url)
+
+
+def _make_client(behavior, cfg=None, monkeypatch=None):
+    import upload.backend.upload_refs.blueprint as bp_mod
+    monkeypatch.setattr(bp_mod.httpx, "Client", lambda **kw: _FakeClient(behavior))
+    app = Flask(__name__)
+    app.register_blueprint(create_upload_refs_blueprint(cfg or {}))
+    return app.test_client()
+
+
+def test_upload_refs_no_files(monkeypatch):
+    c = _make_client({}, monkeypatch=monkeypatch)
+    rv = c.post("/api/upload_refs", json={"session": "", "files": []})
+    assert rv.status_code == 400
+
+
+def test_upload_refs_ok(monkeypatch):
+    url = VM_PREFIX + "tok_0"
+    c = _make_client({url: {"payload": b"hello"}}, monkeypatch=monkeypatch)
+    rv = c.post("/api/upload_refs", json={
+        "session": "",
+        "files": [{"name": "a.txt", "size": 5, "url": url}],
+    })
+    assert rv.status_code == 200
+    data = rv.get_json()
+    assert data["ok"] is True
+    assert data["count"] == 1
+    files = get_files(data["session"])
+    assert files == [("a.txt", b"hello")]
+
+
+def test_upload_refs_ssrf(monkeypatch):
+    c = _make_client({}, monkeypatch=monkeypatch)
+    rv = c.post("/api/upload_refs", json={
+        "session": "",
+        "files": [{"name": "evil.txt", "size": 5, "url": "https://evil.example/x"}],
+    })
+    assert rv.status_code == 200
+    data = rv.get_json()
+    assert data["ok"] is True
+    assert data["count"] == 0  # unsafe URL пропущен
+
+
+def test_upload_refs_too_large(monkeypatch):
+    url = VM_PREFIX + "tok_0"
+    c = _make_client({}, monkeypatch=monkeypatch)
+    rv = c.post("/api/upload_refs", json={
+        "session": "",
+        "files": [{"name": "big.bin", "size": 60 * 1024 * 1024, "url": url}],
+    })
+    assert rv.status_code == 200
+    assert rv.get_json()["count"] == 0  # сверх 50МБ → skip+delete
+
+
+def test_upload_refs_session_not_found(monkeypatch):
+    url = VM_PREFIX + "tok_0"
+    c = _make_client({url: {"payload": b"x"}}, monkeypatch=monkeypatch)
+    rv = c.post("/api/upload_refs", json={
+        "session": "no-such-session",
+        "files": [{"name": "a.txt", "size": 1, "url": url}],
+    })
+    assert rv.status_code == 404
+    assert rv.get_json()["error"] == "Session not found"
+
+
+def test_upload_refs_pull_failed(monkeypatch):
+    url = VM_PREFIX + "tok_0"
+    behavior = {url: {"exc": RuntimeError("dns fail")}}
+    c = _make_client(behavior, cfg={"pullRetryDelay": 0}, monkeypatch=monkeypatch)
+    rv = c.post("/api/upload_refs", json={
+        "session": "",
+        "files": [{"name": "a.txt", "size": 1, "url": url}],
+    })
+    assert rv.status_code == 502  # все ретраи провалились
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# main (запуск без pytest)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def main():
+    """Прогнать все test_* функции без pytest."""
+    import inspect
+    import traceback
+    fns = [(k, v) for k, v in sorted(globals().items()) if k.startswith("test_")]
+    mp = _FakeMonkeyPatch()
+    failed = 0
+    for name, fn in fns:
+        try:
+            if "monkeypatch" in inspect.signature(fn).parameters:
+                fn(monkeypatch=mp)
+            else:
+                fn()
+            print("PASS %s" % name)
+        except Exception:
+            failed += 1
+            print("FAIL %s" % name)
+            traceback.print_exc()
+    if failed:
+        print("%d тестов упало" % failed)
+        sys.exit(1)
+    print("Все тесты прошли")
+
+
+class _FakeMonkeyPatch:
+    """Мини-monkeypatch: setattr, работает до конца вызова (без undo)."""
+
+    def setattr(self, target, name, value):
+        setattr(target, name, value)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/upload/README.md b/upload/README.md
new file mode 100644
index 0000000..1fc450f
--- /dev/null
+++ b/upload/README.md
@@ -0,0 +1,123 @@
+# upload — переиспользуемые слои загрузки через ВМ
+
+Два самодостаточных слоя для выноса в любой другой проект БЕЗ изменения кода
+(меняется только конфиг). Поведение 1:1 с drhider v0.0.75.
+
+```
+upload/
+  frontend/
+    zip/       # распаковка ZIP (чистые функции)
+    table/     # слой 1: выбор файлов/папки/архива, дедуп, статусы, таблица
+    upload/    # слой 2 (фронт): PUT на ВМ + POST /api/upload_refs
+  backend/
+    upload_refs/  # слой 2 (бэк): Blueprint upload_refs (SSRF, _safe_name, ретраи)
+    session/      # in-memory сессия с TTL и лимитами
+  config.example.json
+```
+
+## Что это
+
+| Слой | Где | Ответственность |
+|---|---|---|
+| **1. Выбор файлов** | фронт | таблица, дедуп, раскрытие ZIP, путь, статусы, кнопки |
+| **2. Закачка через ВМ** | фронт + бэк | PUT на ВМ-буфер (фронт) → `upload_refs` pull (бэк) → сессия |
+| **3. Логика приложения** | — | у каждого приложения своя (обфускация, SSE и т.п.). В модуле её НЕТ |
+
+Паттерн (зачем ВМ): шлюз managed-кластера рвёт тела >64КБ, egress не ограничен.
+Поэтому: браузер → `PUT` на ВМ-буфер → Flask `POST /api/upload_refs` → egress `GET` → сессия.
+
+---
+
+## Подключение фронта
+
+Подключить ES-модули (`<script type="module">`) и собрать слой 1:
+
+```js
+import { initUploadTable } from './upload/frontend/table/init_upload_table.js';
+import { uploadViaVM } from './upload/frontend/upload/upload_via_vm.js';
+
+const cfg = {
+  allowedExt: ['.pdf', '.doc', '.docx', '.txt', '.md'],
+  maxFileBytes: 50 * 1024 * 1024,
+  maxSessionBytes: 500 * 1024 * 1024,
+  estMbSec: 12,
+};
+
+const table = initUploadTable(cfg, {
+  fileInput: document.getElementById('fileInput'),     // <input type="file" multiple>
+  folderInput: document.getElementById('folderInput'), // <input webkitdirectory>
+  tableBody: document.getElementById('fileList'),      // <tbody>
+  countEl: document.getElementById('fileCount'),
+  uploadBtnEl: document.getElementById('uploadBtn'),
+  onStatus(cls, text) { /* сообщения (cls: ''|'progress'|'done'|'error') */ },
+});
+
+// Слой 2 — закачка учитываемых файлов на ВМ:
+const res = await uploadViaVM(table.getFiles(), cfg.vmUploadUrl, {
+  session: currentSid,
+  onStatus(k, html) { table.setStatus(idxInSf[k], html); }, // маппинг idx → строка таблицы
+  onUploadStatus(text) { /* статусная строка */ },
+});
+// res = {ok:true, session, count} | {ok:false, error}
+// После этого у вас в сессии res.session лежат файлы — запускайте СВОЮ обработку.
+```
+
+API слоя 1 (`initUploadTable(cfg, els)` → `table`):
+- `addFiles(File[])` — дедуп + раскрытие ZIP + фильтр + лимиты;
+- `getFiles()` → `[{name, size, file}]` — **только учитываемые** (без сверхлимитных);
+- `getOverNames()` → `Set` — имена сверх лимита;
+- `setStatus(idx, html)` — статус в ячейке таблицы;
+- `render()` — перерисовать таблицу;
+- `clear()` — очистить список;
+- `setBusy(bool)` — заблокировать список на время загрузки/обработки;
+- `state` — доступ к состоянию (для слоя 3: установить `state.proc` для 3-секционной таблицы).
+
+---
+
+## Подключение бэка
+
+```python
+from flask import Flask
+from upload.backend.upload_refs import create_upload_refs_blueprint
+from upload.backend.session import create_session, add_file, get_files
+
+app = Flask(__name__)
+app.register_blueprint(create_upload_refs_blueprint({
+    "apiPrefix": "/api",                       # префикс эндпоинтов
+    "vmUploadPrefix": "https://.../drhider-upload/",  # доверенный префикс (SSRF)
+    "maxFileBytes": 50 * 1024 * 1024,
+    "pullRetries": 3,
+    "pullRetryDelay": 2,
+}))
+```
+
+Эндпоинт: `POST {apiPrefix}/upload_refs` — принимает JSON
+`{"session": "...", "files": [{"name", "size", "url"}]}`, тянет каждый файл с ВМ
+(SSRF-валидация по `vmUploadPrefix`, `_safe_name`, ретраи), кладёт в сессию.
+Возвращает `{"ok": true, "session", "count"}`.
+
+Сессия: `create_session()` → sid; `add_file(sid, name, content)` (лимит 500МБ);
+`get_files(sid)` → `[(name, bytes), ...]` или `None`. TTL 30 мин (таймер в фоне).
+
+---
+
+## Конфиг (слой 0)
+
+Всё drhider-специфичное задаётся конфигом, а не кодом слоёв:
+
+| Поле | Назначение |
+|---|---|
+| `vmUploadUrl` | базовый URL ВМ-буфера для PUT (фронт) |
+| `vmUploadPrefix` | тот же префикс для SSRF-валидации (бэк) |
+| `allowedExt` | расширения документов из папки/архивов |
+| `maxFileBytes` / `maxSessionBytes` | лимиты 50 МБ / 500 МБ |
+| `apiPrefix` | префикс Blueprint `/api` |
+| `pullRetries` / `pullRetryDelay` | ретраи pull (3 × 2с) |
+| `estMbSec` | оценка времени обработки, сек/МБ (только UI) |
+
+---
+
+## Что НЕ трогать
+
+- Слой 3 — логика приложения (обработка файлов из сессии, SSE-прогресс) у каждого своя.
+- CORS на ВМ-буфере — если домен приложения другой, правится nginx на ВМ, а не код модуля.
diff --git a/upload/__init__.py b/upload/__init__.py
new file mode 100644
index 0000000..b66945a
--- /dev/null
+++ b/upload/__init__.py
@@ -0,0 +1,8 @@
+"""Переиспользуемый модуль загрузки через ВМ (2 слоя).
+
+Структура:
+- frontend/  — слой 1 (выбор файлов) + слой 2 (закачка через ВМ), JS.
+- backend/   — слой 2 (бэк): Blueprint upload_refs + in-memory сессия, Python.
+
+Подключение в новый проект — см. README.md.
+"""
diff --git a/upload/backend/__init__.py b/upload/backend/__init__.py
new file mode 100644
index 0000000..0cdaa2f
--- /dev/null
+++ b/upload/backend/__init__.py
@@ -0,0 +1 @@
+"""Backend переиспользуемого модуля загрузки: upload_refs + session."""
diff --git a/upload/backend/session/__init__.py b/upload/backend/session/__init__.py
new file mode 100644
index 0000000..6bb30ed
--- /dev/null
+++ b/upload/backend/session/__init__.py
@@ -0,0 +1,37 @@
+"""In-memory хранилище сессий с TTL и лимитами.
+
+Каждая операция — в отдельном файле (см. ниже), общее состояние — в state.py.
+Импорт как единый пакет:
+
+    from upload.backend.session import create_session, add_file, get_files
+"""
+
+from .create_session import create_session
+from .add_file import add_file
+from .get_files import get_files, file_count
+from .store_result import store_result, get_result
+from .store_csv import store_csv, get_csv
+from .ttl import touch, pause_ttl, resume_ttl
+from .cancel import request_cancel, get_cancel_event
+from .cleanup import cleanup
+from .state import TTL_SECONDS, MAX_FILE_BYTES, MAX_SESSION_BYTES
+
+__all__ = [
+    "create_session",
+    "add_file",
+    "get_files",
+    "file_count",
+    "store_result",
+    "get_result",
+    "store_csv",
+    "get_csv",
+    "touch",
+    "pause_ttl",
+    "resume_ttl",
+    "request_cancel",
+    "get_cancel_event",
+    "cleanup",
+    "TTL_SECONDS",
+    "MAX_FILE_BYTES",
+    "MAX_SESSION_BYTES",
+]
diff --git a/upload/backend/session/add_file.py b/upload/backend/session/add_file.py
new file mode 100644
index 0000000..1aa1e0a
--- /dev/null
+++ b/upload/backend/session/add_file.py
@@ -0,0 +1,25 @@
+"""add_file — добавить файл в сессию (с проверкой суммарного лимита)."""
+
+from .state import _sessions, _lock, MAX_SESSION_BYTES
+
+
+def add_file(sid: str, filename: str, content: bytes) -> bool:
+    """Добавить файл в сессию.
+
+    Args:
+        sid: Идентификатор сессии
+        filename: Имя файла
+        content: Бинарное содержимое
+
+    Returns:
+        True если добавлено; False если сессии нет или превышен лимит сессии.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        if not s:
+            return False
+        total = sum(len(c) for _, c in s["files"])
+        if total + len(content) > MAX_SESSION_BYTES:
+            return False  # превышен суммарный лимит сессии
+        s["files"].append((filename, content))
+        return True
diff --git a/upload/backend/session/cancel.py b/upload/backend/session/cancel.py
new file mode 100644
index 0000000..ad39d8a
--- /dev/null
+++ b/upload/backend/session/cancel.py
@@ -0,0 +1,27 @@
+"""request_cancel / get_cancel_event — мягкое прерывание обработки сессии."""
+
+import threading
+from typing import Optional
+
+from .state import _sessions, _lock
+
+
+def request_cancel(sid: str) -> bool:
+    """Запросить мягкое прерывание обработки сессии.
+
+    Returns:
+        True если сессия существует и отмена запрошена, False если нет.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        if not s:
+            return False
+        s["cancel"].set()
+        return True
+
+
+def get_cancel_event(sid: str) -> Optional[threading.Event]:
+    """Получить событие отмены сессии (или None, если сессии нет)."""
+    with _lock:
+        s = _sessions.get(sid)
+        return s["cancel"] if s else None
diff --git a/upload/backend/session/cleanup.py b/upload/backend/session/cleanup.py
new file mode 100644
index 0000000..be0d8f2
--- /dev/null
+++ b/upload/backend/session/cleanup.py
@@ -0,0 +1,11 @@
+"""cleanup — удалить сессию."""
+
+from .state import _sessions, _lock
+
+
+def cleanup(sid: str):
+    """Удалить сессию и остановить её TTL-таймер."""
+    with _lock:
+        s = _sessions.pop(sid, None)
+        if s and s.get("timer"):
+            s["timer"].cancel()
diff --git a/upload/backend/session/create_session.py b/upload/backend/session/create_session.py
new file mode 100644
index 0000000..6c29d8a
--- /dev/null
+++ b/upload/backend/session/create_session.py
@@ -0,0 +1,23 @@
+"""create_session — создать новую сессию."""
+
+import threading
+import uuid
+
+from .state import _sessions, _lock, _start_timer
+
+
+def create_session() -> str:
+    """Создать новую сессию.
+
+    Returns:
+        Уникальный идентификатор сессии (UUID).
+    """
+    sid = uuid.uuid4().hex
+    with _lock:
+        _sessions[sid] = {
+            "files": [],
+            "result": None,
+            "cancel": threading.Event(),
+            "timer": _start_timer(sid),
+        }
+    return sid
diff --git a/upload/backend/session/get_files.py b/upload/backend/session/get_files.py
new file mode 100644
index 0000000..74a6bca
--- /dev/null
+++ b/upload/backend/session/get_files.py
@@ -0,0 +1,23 @@
+"""get_files / file_count — чтение файлов сессии."""
+
+from typing import List, Optional, Tuple
+
+from .state import _sessions, _lock
+
+
+def get_files(sid: str) -> Optional[List[Tuple[str, bytes]]]:
+    """Получить все файлы сессии.
+
+    Returns:
+        [(filename, content), ...] или None если сессия не найдена.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        return list(s["files"]) if s else None
+
+
+def file_count(sid: str) -> int:
+    """Количество файлов в сессии."""
+    with _lock:
+        s = _sessions.get(sid)
+        return len(s["files"]) if s else 0
diff --git a/upload/backend/session/state.py b/upload/backend/session/state.py
new file mode 100644
index 0000000..633b3c7
--- /dev/null
+++ b/upload/backend/session/state.py
@@ -0,0 +1,30 @@
+"""Общее состояние сессий: хранилище, блокировка, константы, TTL-таймер.
+
+Единая точка хранения состояния — все операции импортируют её.
+Дробить state.py на файл-на-переменную не нужно: это данные, а не функции.
+"""
+
+import threading
+
+# TTL сессии: 30 минут
+TTL_SECONDS = 30 * 60
+
+# Максимальный объём одного файла и суммарный объём файлов в сессии (защита памяти)
+MAX_FILE_BYTES = 50 * 1024 * 1024  # 50 MB на один файл
+MAX_SESSION_BYTES = 500 * 1024 * 1024  # 500 MB суммарно на сессию
+
+_sessions: dict = {}
+_lock = threading.Lock()
+
+
+def _start_timer(sid: str) -> threading.Timer:
+    """Запустить таймер автоочистки сессии через TTL."""
+
+    def _clean():
+        with _lock:
+            _sessions.pop(sid, None)
+
+    timer = threading.Timer(TTL_SECONDS, _clean)
+    timer.daemon = True
+    timer.start()
+    return timer
diff --git a/upload/backend/session/store_csv.py b/upload/backend/session/store_csv.py
new file mode 100644
index 0000000..f7b6d4a
--- /dev/null
+++ b/upload/backend/session/store_csv.py
@@ -0,0 +1,30 @@
+"""store_csv / get_csv — сохранение и чтение CSV с таблицей замен."""
+
+from typing import Optional
+
+from .state import _sessions, _lock
+
+
+def store_csv(sid: str, csv_str: str) -> bool:
+    """Сохранить CSV с таблицей замен.
+
+    Returns:
+        True если сохранено, False если сессии нет.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        if not s:
+            return False
+        s["csv"] = csv_str
+        return True
+
+
+def get_csv(sid: str) -> Optional[str]:
+    """Получить CSV с таблицей замен.
+
+    Returns:
+        Строка CSV или None если нет.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        return s.get("csv") if s else None
diff --git a/upload/backend/session/store_result.py b/upload/backend/session/store_result.py
new file mode 100644
index 0000000..e39542a
--- /dev/null
+++ b/upload/backend/session/store_result.py
@@ -0,0 +1,30 @@
+"""store_result / get_result — сохранение и чтение результата обработки."""
+
+from typing import Optional
+
+from .state import _sessions, _lock
+
+
+def store_result(sid: str, zip_data: bytes) -> bool:
+    """Сохранить результат обработки (ZIP-архив).
+
+    Returns:
+        True если сохранено, False если сессии нет.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        if not s:
+            return False
+        s["result"] = zip_data
+        return True
+
+
+def get_result(sid: str) -> Optional[bytes]:
+    """Получить результат обработки.
+
+    Returns:
+        ZIP-архив или None если сессия не найдена/результат не готов.
+    """
+    with _lock:
+        s = _sessions.get(sid)
+        return s["result"] if s else None
diff --git a/upload/backend/session/ttl.py b/upload/backend/session/ttl.py
new file mode 100644
index 0000000..06abb9a
--- /dev/null
+++ b/upload/backend/session/ttl.py
@@ -0,0 +1,34 @@
+"""touch / pause_ttl / resume_ttl — управление TTL-таймером сессии."""
+
+from .state import _sessions, _lock, _start_timer
+
+
+def touch(sid: str):
+    """Продлить жизнь сессии: перезапустить TTL-таймер (если сессия существует)."""
+    with _lock:
+        s = _sessions.get(sid)
+        if not s:
+            return
+        if s.get("timer"):
+            s["timer"].cancel()
+        s["timer"] = _start_timer(sid)
+
+
+def pause_ttl(sid: str):
+    """Приостановить TTL сессии (во время обработки): сессия живёт, пока идёт воркер."""
+    with _lock:
+        s = _sessions.get(sid)
+        if s and s.get("timer"):
+            s["timer"].cancel()
+            s["timer"] = None
+
+
+def resume_ttl(sid: str):
+    """Возобновить TTL сессии (после завершения обработки): результат доступен ещё TTL."""
+    with _lock:
+        s = _sessions.get(sid)
+        if not s:
+            return
+        if s.get("timer"):
+            s["timer"].cancel()
+        s["timer"] = _start_timer(sid)
diff --git a/upload/backend/upload_refs/__init__.py b/upload/backend/upload_refs/__init__.py
new file mode 100644
index 0000000..149f7bb
--- /dev/null
+++ b/upload/backend/upload_refs/__init__.py
@@ -0,0 +1,20 @@
+"""Слой 2 (бэк): переиспользуемый Blueprint закачки через ВМ.
+
+Использование:
+    from upload.backend.upload_refs import create_upload_refs_blueprint
+    app.register_blueprint(create_upload_refs_blueprint(cfg))
+"""
+
+from .blueprint import create_upload_refs_blueprint
+from .safe_name import safe_name
+from .pull_file import pull_file
+from .config import PULL_RETRIES, PULL_RETRY_DELAY, VM_UPLOAD_PREFIX
+
+__all__ = [
+    "create_upload_refs_blueprint",
+    "safe_name",
+    "pull_file",
+    "PULL_RETRIES",
+    "PULL_RETRY_DELAY",
+    "VM_UPLOAD_PREFIX",
+]
diff --git a/upload/backend/upload_refs/blueprint.py b/upload/backend/upload_refs/blueprint.py
new file mode 100644
index 0000000..efb4a03
--- /dev/null
+++ b/upload/backend/upload_refs/blueprint.py
@@ -0,0 +1,110 @@
+"""Переиспользуемый Blueprint слоя 2: POST /upload_refs (pull с ВМ-буфера в сессию).
+
+Поведение 1:1 с drhider v0.0.75 (site/routes/api_bp.py):
+- _safe_name (path traversal)
+- SSRF-валидация url.startswith(VM_UPLOAD_PREFIX)
+- лимит на один файл -> delete+skip
+- pull с ретраями
+- лимит сессии -> skip; отсутствие сессии -> 404
+- delete url с ВМ (best-effort)
+"""
+
+import httpx
+import logging
+from flask import Blueprint, request, jsonify
+
+from ..session import (create_session, add_file, get_files, file_count,
+                       MAX_FILE_BYTES)
+from .config import PULL_RETRIES, PULL_RETRY_DELAY, VM_UPLOAD_PREFIX
+from .safe_name import safe_name
+from .pull_file import pull_file
+
+log = logging.getLogger("upload.upload_refs")
+
+
+def create_upload_refs_blueprint(cfg: dict) -> Blueprint:
+    """Создать Blueprint с эндпоинтом upload_refs.
+
+    cfg (все ключи опциональны, есть дефолты):
+        apiPrefix (str)      — префикс Blueprint, по умолчанию "/api"
+        vmUploadPrefix (str) — доверенный префикс ВМ-буфера (SSRF-валидация)
+        maxFileBytes (int)   — лимит на один файл
+        pullRetries (int)    — ретраи pull
+        pullRetryDelay (int) — пауза между ретраями
+    """
+    prefix = cfg.get("apiPrefix", "/api")
+    vm_prefix = cfg.get("vmUploadPrefix", VM_UPLOAD_PREFIX)
+    max_file_bytes = cfg.get("maxFileBytes", MAX_FILE_BYTES)
+
+    bp = Blueprint("upload_refs", __name__, url_prefix=prefix)
+
+    @bp.route("/upload_refs", methods=["POST"])
+    def upload_refs():
+        """Принять ссылки на файлы (загружены на ВМ-буфер), забрать по egress.
+
+        Вход: JSON {"session": "...", "files": [{"name": str, "size": int, "url": str}]}.
+        Каждый файл тянется ИСХОДЯЩИМ GET'ом с ВМ (egress не ограничен шлюзом),
+        читается по частям (stream), кладётся в сессию. После успешного pull файл
+        удаляется с ВМ (best-effort; TTL-чистка на ВМ тоже есть).
+        """
+        data = request.get_json(silent=True) or {}
+        sid = data.get("session") or create_session()
+        refs = data.get("files") or []
+        if not refs:
+            log.warning("upload_refs: no files, sid=%s", sid)
+            return jsonify({"ok": False, "error": "No files"}), 400
+        added = 0
+        try:
+            with httpx.Client(timeout=120, follow_redirects=True) as client:
+                for ref in refs:
+                    name = safe_name(ref.get("name") or "")
+                    url = ref.get("url")
+                    if not name or not url:
+                        continue
+                    # SSRF-защита: тянуть можно ТОЛЬКО с доверенного ВМ-буфера
+                    if not url.startswith(vm_prefix):
+                        log.warning("upload_refs: unsafe URL, skip sid=%s url=%r", sid, url)
+                        continue
+                    # Лимит на один файл: сверх лимита — пропускаем (не участвует)
+                    if (ref.get("size") or 0) > max_file_bytes:
+                        log.warning("upload_refs: file exceeds %dMB, skip sid=%s file=%r size=%s",
+                                    max_file_bytes // (1024 * 1024), sid, name, ref.get("size"))
+                        try:
+                            client.delete(url)
+                        except Exception:
+                            pass
+                        continue
+                    # Pull с ретраями: разовые DNS/сетевые сбои не роняют всю загрузку
+                    content = pull_file(client, url)  # бросает при неудаче всех попыток
+                    log.info("upload_refs: pulled sid=%s file=%r size=%d", sid, name, len(content))
+                    if len(content) > max_file_bytes:
+                        log.warning("upload_refs: pulled file exceeds %dMB, skip sid=%s file=%r size=%d",
+                                    max_file_bytes // (1024 * 1024), sid, name, len(content))
+                        try:
+                            client.delete(url)
+                        except Exception:
+                            pass
+                        continue
+                    if not add_file(sid, name, content):
+                        # Различить: сессия исчезла vs превышен суммарный лимит сессии
+                        if get_files(sid) is None:
+                            log.warning("upload_refs: session not found, sid=%s file=%r", sid, name)
+                            return jsonify({"ok": False, "error": "Session not found"}), 404
+                        log.warning("upload_refs: session limit exceeded, skip sid=%s file=%r", sid, name)
+                        try:
+                            client.delete(url)
+                        except Exception:
+                            pass
+                        continue
+                    try:
+                        client.delete(url)  # убрать файл с ВМ после загрузки
+                    except Exception:
+                        pass
+                    added += 1
+        except Exception as e:
+            log.error("upload_refs: pull error sid=%s: %r", sid, e)
+            return jsonify({"ok": False, "error": "Pull failed: %s" % e}), 502
+        log.info("upload_refs: done sid=%s added=%d total=%d", sid, added, file_count(sid))
+        return jsonify({"ok": True, "session": sid, "count": file_count(sid)})
+
+    return bp
diff --git a/upload/backend/upload_refs/config.py b/upload/backend/upload_refs/config.py
new file mode 100644
index 0000000..1a6dae4
--- /dev/null
+++ b/upload/backend/upload_refs/config.py
@@ -0,0 +1,11 @@
+"""Параметры слоя 2 (бэк) по умолчанию.
+
+Переопределяются из конфига приложения через create_upload_refs_blueprint(cfg).
+"""
+
+# Ретраи pull из ВМ-буфера: защита от разовых DNS/сетевых сбоев (gaierror -5 и т.п.)
+PULL_RETRIES = 3
+PULL_RETRY_DELAY = 2  # секунды между попытками
+
+# Доверенный префикс ВМ-буфера — валидация URL при pull (защита от SSRF)
+VM_UPLOAD_PREFIX = "https://contracts.kube5s.ru/drhider-upload/"
diff --git a/upload/backend/upload_refs/pull_file.py b/upload/backend/upload_refs/pull_file.py
new file mode 100644
index 0000000..583ce02
--- /dev/null
+++ b/upload/backend/upload_refs/pull_file.py
@@ -0,0 +1,35 @@
+"""pull_file — вытащить файл с ВМ-буфера исходящим GET с ретраями."""
+
+import logging
+import time
+
+from .config import PULL_RETRIES, PULL_RETRY_DELAY
+
+log = logging.getLogger("upload.upload_refs.pull")
+
+
+def pull_file(client, url: str) -> bytes:
+    """GET url с ретраями; читает по частям (stream).
+
+    Args:
+        client: httpx.Client
+        url: URL файла на ВМ-буфере.
+
+    Returns:
+        Содержимое файла (bytes).
+
+    Raises:
+        Последнюю ошибку попытки, если все ретраи не удались.
+    """
+    last_err = None
+    for attempt in range(PULL_RETRIES):
+        try:
+            with client.stream("GET", url) as resp:
+                resp.raise_for_status()
+                return b"".join(resp.iter_bytes())
+        except Exception as e:
+            last_err = e
+            log.warning("pull: attempt %d/%d failed url=%r: %r",
+                        attempt + 1, PULL_RETRIES, url, e)
+            time.sleep(PULL_RETRY_DELAY)
+    raise last_err if last_err else RuntimeError("pull failed")
diff --git a/upload/backend/upload_refs/safe_name.py b/upload/backend/upload_refs/safe_name.py
new file mode 100644
index 0000000..8eca581
--- /dev/null
+++ b/upload/backend/upload_refs/safe_name.py
@@ -0,0 +1,16 @@
+"""safe_name — санитизация имени файла (защита от path traversal)."""
+
+
+def safe_name(name: str) -> str:
+    """Санитизировать имя файла: защита от path traversal, сохраняя подпапки.
+
+    Запрещает '..' и абсолютные пути; нормализует слэши. Возвращает "" если
+    имя пустое или небезопасное.
+    """
+    if not name:
+        return ""
+    name = name.replace("\\", "/")
+    parts = [p for p in name.split("/") if p and p != "."]
+    if not parts or any(p == ".." for p in parts):
+        return ""
+    return "/".join(parts)
diff --git a/upload/config.example.json b/upload/config.example.json
new file mode 100644
index 0000000..fa74e39
--- /dev/null
+++ b/upload/config.example.json
@@ -0,0 +1,11 @@
+{
+  "vmUploadUrl": "https://contracts.kube5s.ru/drhider-upload/",
+  "allowedExt": [".pdf", ".doc", ".docx", ".txt", ".md"],
+  "maxFileBytes": 52428800,
+  "maxSessionBytes": 524288000,
+  "apiPrefix": "/api",
+  "vmUploadPrefix": "https://contracts.kube5s.ru/drhider-upload/",
+  "pullRetries": 3,
+  "pullRetryDelay": 2,
+  "estMbSec": 12
+}
diff --git a/upload/frontend/package.json b/upload/frontend/package.json
new file mode 100644
index 0000000..994410c
--- /dev/null
+++ b/upload/frontend/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "upload-frontend",
+  "private": true,
+  "type": "module",
+  "description": "Переиспользуемый фронт слоёв 1 и 2 (выбор файлов + закачка через ВМ). Модули ES — подключаются в браузере через <script type=\"module\">; Node-режим нужен для юнит-тестов zip."
+}
diff --git a/upload/frontend/table/add_file_with_dedup.js b/upload/frontend/table/add_file_with_dedup.js
new file mode 100644
index 0000000..801c0c9
--- /dev/null
+++ b/upload/frontend/table/add_file_with_dedup.js
@@ -0,0 +1,47 @@
+// addFileWithDedup — дедуп «имя+размер», суффиксы _2/_3, лимиты (over).
+// Мутирует state. Возвращает true если файл добавлен (или переведён в over),
+// false если это дедуп (обновлена только дата).
+
+export function addFileWithDedup(state, file, cfg) {
+  const size = file.size;
+  const mtime = file.lastModified;
+  let name = file.name;
+  const maxFileBytes = cfg.maxFileBytes;
+  const maxSessionBytes = cfg.maxSessionBytes;
+
+  if (state.fileMeta.has(name)) {
+    const e = state.fileMeta.get(name);
+    if (e.size === size) {
+      // Тот же файл (имя+размер) — дедуп. Дату не сравниваем: файл могли пересохранить
+      // с тем же содержимым. Оставляем более свежий по дате.
+      if (mtime > e.mtime) {
+        e.mtime = mtime;
+        const idx = state.files.findIndex(f => f.name === name);
+        if (idx >= 0) state.files[idx] = new File([file], name, { lastModified: mtime });
+      }
+      return false;  // дедуп: файл не добавлен (обновлена только дата)
+    }
+    // Имя то же, размер другой — добавить с суффиксом _2, _3...
+    const dot = name.lastIndexOf('.');
+    const base = dot > 0 ? name.slice(0, dot) : name;
+    const ext = dot > 0 ? name.slice(dot) : '';
+    let n = 2;
+    while (state.fileMeta.has(base + '_' + n + ext)) n++;
+    name = base + '_' + n + ext;
+  }
+  state.fileMeta.set(name, { size, mtime });
+
+  // Определяем, превышает ли файл лимит (по размеру файла или суммарный) — не участвует в обфускации
+  let over = false;
+  if (size > maxFileBytes) over = true;  // лимит на один файл
+  const sum = state.files.reduce((s, f) => s + (state.overNames.has(f.name) ? 0 : f.size), 0);
+  if (sum + size > maxSessionBytes) over = true;  // суммарный лимит сессии
+
+  if (over) {
+    state.overNames.add(name);
+    state.files.push(new File([file], name, { lastModified: mtime }));
+    return true;
+  }
+  state.files.push(new File([file], name, { lastModified: mtime }));
+  return true;
+}
diff --git a/upload/frontend/table/esc.js b/upload/frontend/table/esc.js
new file mode 100644
index 0000000..f844893
--- /dev/null
+++ b/upload/frontend/table/esc.js
@@ -0,0 +1,5 @@
+// esc — экранирование HTML (защита от self-XSS именами файлов).
+
+export function esc(s) {
+  return String(s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+}
diff --git a/upload/frontend/table/est_for_file.js b/upload/frontend/table/est_for_file.js
new file mode 100644
index 0000000..54c5c8a
--- /dev/null
+++ b/upload/frontend/table/est_for_file.js
@@ -0,0 +1,8 @@
+// estForFile — эмпирическая оценка времени обработки файла: сек/МБ (ориентировочно, до старта).
+
+export const DEFAULT_EST_MB_SEC = 12;
+
+export function estForFile(f, estMbSec) {
+  const k = estMbSec || DEFAULT_EST_MB_SEC;
+  return f ? Math.max(1, Math.round(f.size / 1048576 * k)) : 0;
+}
diff --git a/upload/frontend/table/fmt_sec.js b/upload/frontend/table/fmt_sec.js
new file mode 100644
index 0000000..01b8111
--- /dev/null
+++ b/upload/frontend/table/fmt_sec.js
@@ -0,0 +1,6 @@
+// fmtSec — формат секунд: "Nс" / "Nм Nс".
+
+export function fmtSec(s) {
+  s = Math.max(0, Math.round(s));
+  return s >= 60 ? Math.floor(s / 60) + 'м ' + (s % 60) + 'с' : s + 'с';
+}
diff --git a/upload/frontend/table/fs.js b/upload/frontend/table/fs.js
new file mode 100644
index 0000000..f1cc546
--- /dev/null
+++ b/upload/frontend/table/fs.js
@@ -0,0 +1,7 @@
+// fs — формат размера: B / KB / MB.
+
+export function fs(b) {
+  return b < 1024 ? b + ' B'
+    : b < 1048576 ? (b / 1024).toFixed(1) + ' KB'
+    : (b / 1048576).toFixed(1) + ' MB';
+}
diff --git a/upload/frontend/table/init_upload_table.js b/upload/frontend/table/init_upload_table.js
new file mode 100644
index 0000000..2cc560e
--- /dev/null
+++ b/upload/frontend/table/init_upload_table.js
@@ -0,0 +1,57 @@
+// initUploadTable — сборка слоя 1 (выбор файлов/папки/архива).
+// Состояние (files/fileMeta/overNames) живёт внутри модуля.
+
+import { addFiles as addFilesToState } from './on_files_change.js';
+import { makeFilesChangeHandler } from './on_files_change.js';
+import { makeFolderChangeHandler } from './on_folder_change.js';
+import { render } from './render.js';
+import { setStatus } from './set_status.js';
+import { rmFile } from './rm_file.js';
+
+// cfg: {allowedExt, maxFileBytes, maxSessionBytes, estMbSec}
+// els: {fileInput, folderInput, tableBody, countEl, uploadBtnEl, onStatus(cls, text)}
+// returns api (см. README.md)
+export function initUploadTable(cfg, els) {
+  const state = {
+    files: [],              // File[]
+    fileMeta: new Map(),    // имя -> {size, mtime} для дедупа/суффиксов
+    overNames: new Set(),   // имена файлов сверх лимита (не участвуют)
+    busy: false,            // идёт загрузка/обработка — список заблокирован
+    proc: null,             // {phase, procState, procExtractRate} — задаёт слой 3
+  };
+
+  const onFilesChange = makeFilesChangeHandler({ state, cfg, els });
+  const onFolderChange = makeFolderChangeHandler({ state, cfg, els });
+
+  els.fileInput.addEventListener('change', onFilesChange);
+  els.folderInput.addEventListener('change', onFolderChange);
+  // Делегирование кликов по кнопкам «✕» (удалить строку)
+  els.tableBody.addEventListener('click', e => {
+    const btn = e.target.closest('.remove-btn');
+    if (btn) rmFile(state, els, cfg, Number(btn.dataset.idx));
+  });
+
+  return {
+    state,                        // доступ для слоя 3 (установить state.proc для render)
+    addFiles(files) { return addFilesToState(state, cfg, files, els, els.onStatus); },
+    getFiles() {                  // ТОЛЬКО учитываемые (без over): [{name, size, file}]
+      return state.files.filter(f => !state.overNames.has(f.name))
+        .map(f => ({ name: f.name, size: f.size, file: f }));
+    },
+    getOverNames() { return state.overNames; },
+    setStatus(idx, html) { setStatus(idx, html); },
+    render() { render(state, els, cfg); },
+    clear() {
+      state.files = [];
+      state.fileMeta = new Map();
+      state.overNames = new Set();
+      if (els.fileInput) els.fileInput.value = '';
+      render(state, els, cfg);
+    },
+    setBusy(b) {
+      state.busy = b;
+      if (els.fileInput) els.fileInput.disabled = b;
+    },
+    _rm(i) { rmFile(state, els, cfg, i); },
+  };
+}
diff --git a/upload/frontend/table/on_files_change.js b/upload/frontend/table/on_files_change.js
new file mode 100644
index 0000000..a115d3a
--- /dev/null
+++ b/upload/frontend/table/on_files_change.js
@@ -0,0 +1,56 @@
+// Обработчик <input type="file" multiple> change: дедуп + раскрытие ZIP + фильтр.
+// Экспортируется и чистая логика добавления массива файлов (addFiles),
+// и фабрика обработчика для input (makeFilesChangeHandler).
+
+import { listZipFiles } from '../zip/list_zip_files.js';
+import { addFileWithDedup } from './add_file_with_dedup.js';
+import { render } from './render.js';
+
+// Добавить массив файлов в список (дедуп + раскрытие ZIP + лимиты).
+// files: File[]. els.fileInput — для синхронизации input.files (DataTransfer),
+// чтобы повторный выбор того же файла сработал. onStatus(cls, text) — колбэк сообщений.
+export async function addFiles(state, cfg, files, els, onStatus) {
+  const incoming = Array.from(files);
+  const hasZip = incoming.some(f => f.name.toLowerCase().endsWith('.zip'));
+  if (hasZip) {
+    document.body.style.cursor = 'wait';
+    if (onStatus) onStatus('progress', 'Разбираю архивы…');
+  }
+  try {
+    for (const f of incoming) {
+      if (f.name.toLowerCase().endsWith('.zip')) {
+        try {
+          const nested = await listZipFiles(f, cfg.allowedExt);
+          if (nested.length) nested.forEach(x => addFileWithDedup(state, x, cfg));
+          else addFileWithDedup(state, f, cfg);  // в архиве нет документов — архив как есть
+        } catch (err) {
+          addFileWithDedup(state, f, cfg);  // не удалось распаковать — zip как есть
+        }
+      } else {
+        addFileWithDedup(state, f, cfg);
+      }
+    }
+  } finally {
+    if (hasZip) {
+      document.body.style.cursor = '';
+      if (onStatus) onStatus('', '');
+    }
+  }
+  // Синхронизировать input.files — чтобы повторный выбор того же файла сработал
+  if (els && els.fileInput && els.fileInput.files) {
+    const d = new DataTransfer();
+    state.files.forEach(f => d.items.add(f));
+    els.fileInput.files = d.files;
+  }
+  render(state, els, cfg);
+}
+
+// Фабрика обработчика change для <input type="file">.
+// ctx = { state, cfg, els, onStatus }
+export function makeFilesChangeHandler(ctx) {
+  const { state, cfg, els, onStatus } = ctx;
+  return () => {
+    if (state.busy) return;  // во время загрузки/обработки менять список нельзя
+    addFiles(state, cfg, els.fileInput.files, els, onStatus);
+  };
+}
diff --git a/upload/frontend/table/on_folder_change.js b/upload/frontend/table/on_folder_change.js
new file mode 100644
index 0000000..847e192
--- /dev/null
+++ b/upload/frontend/table/on_folder_change.js
@@ -0,0 +1,58 @@
+// Обработчик <input webkitdirectory> change: выбор целой папки, рекурсивно,
+// относительный путь сохраняется (верхняя папка отбрасывается).
+
+import { listZipFiles } from '../zip/list_zip_files.js';
+import { addFileWithDedup } from './add_file_with_dedup.js';
+import { render } from './render.js';
+
+// Фабрика обработчика change для input выбора папки.
+// ctx = { state, cfg, els, onStatus }
+export function makeFolderChangeHandler(ctx) {
+  const { state, cfg, els, onStatus } = ctx;
+  return async () => {
+    if (state.busy) return;  // во время загрузки/обработки менять список нельзя
+    const incoming = Array.from(els.folderInput.files);
+    if (!incoming.length) return;
+    document.body.style.cursor = 'wait';
+    if (onStatus) onStatus('progress', 'Разбираю папку…');
+    let added = 0;
+    try {
+      for (const f of incoming) {
+        // webkitRelativePath: "TopFolder/Подпапка/file.pdf" — отбрасываем верхнюю папку
+        const parts = (f.webkitRelativePath || f.name).split('/');
+        const rel = parts.slice(1).join('/') || f.name;
+        const low = rel.toLowerCase();
+        const slashIdx = rel.lastIndexOf('/');
+        const relDir = slashIdx >= 0 ? rel.slice(0, slashIdx) : '';
+        if (low.endsWith('.zip')) {
+          try {
+            const nested = await listZipFiles(f, cfg.allowedExt);
+            if (nested.length) {
+              for (const nf of nested) {
+                const nm = relDir ? relDir + '/' + nf.name : nf.name;
+                if (addFileWithDedup(state, new File([nf], nm, { lastModified: nf.lastModified }), cfg)) added++;
+              }
+            } else {
+              // в архиве нет документов — добавить архив как есть, чтобы не терялся
+              if (addFileWithDedup(state, new File([f], rel, { lastModified: f.lastModified }), cfg)) added++;
+            }
+          } catch (err) {
+            if (addFileWithDedup(state, new File([f], rel, { lastModified: f.lastModified }), cfg)) added++;  // zip как есть
+          }
+        } else if (cfg.allowedExt.some(e => low.endsWith(e))) {
+          if (addFileWithDedup(state, new File([f], rel, { lastModified: f.lastModified }), cfg)) added++;
+        }
+        // иначе — не документ, пропускаем
+      }
+    } finally {
+      document.body.style.cursor = '';
+    }
+    els.folderInput.value = '';  // чтобы повторный выбор той же папки сработал
+    render(state, els, cfg);
+    if (added && onStatus) {
+      const n = added;
+      const w = (n % 10 === 1 && n % 100 !== 11) ? 'файл' : (n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % 100 > 14)) ? 'файла' : 'файлов';
+      onStatus('done', '✅ Добавлено из папки: ' + n + ' ' + w);
+    }
+  };
+}
diff --git a/upload/frontend/table/proc_row.js b/upload/frontend/table/proc_row.js
new file mode 100644
index 0000000..79ff3d5
--- /dev/null
+++ b/upload/frontend/table/proc_row.js
@@ -0,0 +1,13 @@
+// procRow — строка таблицы обработки (3-секционная).
+
+import { esc } from './esc.js';
+import { fs } from './fs.js';
+
+export function procRow(state, i, stTxt) {
+  const f = state.files[i];
+  const over = state.overNames.has(f.name);
+  const p = state.proc && state.proc.procState ? state.proc.procState[i] : null;
+  const cls = (p && p.st === 'current') ? ' class="row-current"'
+    : (over ? ' class="row-over"' : '');
+  return '<tr' + cls + '><td class="name-cell">' + esc(f.name) + '</td><td class="num-cell">' + fs(f.size) + '</td><td class="num-cell" style="font-size:12px;">' + stTxt + '</td><td></td></tr>';
+}
diff --git a/upload/frontend/table/render.js b/upload/frontend/table/render.js
new file mode 100644
index 0000000..00a2db9
--- /dev/null
+++ b/upload/frontend/table/render.js
@@ -0,0 +1,29 @@
+// render — рендер таблицы выбора файлов (обычная).
+// Если идёт обработка (state.proc.phase === 'processing') — 3-секционная.
+
+import { esc } from './esc.js';
+import { fs } from './fs.js';
+import { fmtSec } from './fmt_sec.js';
+import { estForFile } from './est_for_file.js';
+import { renderProcTable } from './render_proc_table.js';
+
+export function render(state, els, cfg) {
+  if (state.proc && state.proc.phase === 'processing') { renderProcTable(state, els, cfg); return; }
+  if (state.files.length === 0) {
+    els.tableBody.innerHTML = '<tr class="empty-row"><td colspan="4">Нет выбранных файлов</td></tr>';
+  } else {
+    els.tableBody.innerHTML = state.files.map((f, i) => {
+      const over = state.overNames.has(f.name);
+      const rowCls = over ? ' class="row-over"' : '';
+      const stTxt = over ? '<span style="color:#c0392b;">🔥 не учитывается</span>'
+        : '<span style="color:#7d3c98;">~' + fmtSec(estForFile(f, cfg.estMbSec)) + '</span>';
+      return '<tr id="row-' + i + '"' + rowCls + '><td class="name-cell">' + esc(f.name) + '</td><td class="num-cell">' + fs(f.size) + '</td><td class="num-cell" id="st-' + i + '" style="font-size:12px;">' + stTxt + '</td><td><button class="remove-btn" data-idx="' + i + '">✕</button></td></tr>';
+    }).join('');
+  }
+  const overCount = state.files.filter(f => state.overNames.has(f.name)).length;
+  const totalSize = state.files.reduce((s, f) => s + (state.overNames.has(f.name) ? 0 : f.size), 0);
+  const cntMain = state.files.length - overCount;
+  const totEst = state.files.reduce((s, f) => s + (state.overNames.has(f.name) ? 0 : estForFile(f, cfg.estMbSec)), 0);
+  els.countEl.textContent = (overCount ? cntMain + ' учитываются + ' + overCount + ' свыше лимита' : state.files.length) + ' файлов · ' + fs(totalSize) + ' · ~' + fmtSec(totEst);
+  els.uploadBtnEl.disabled = cntMain === 0;
+}
diff --git a/upload/frontend/table/render_proc_table.js b/upload/frontend/table/render_proc_table.js
new file mode 100644
index 0000000..d0aa362
--- /dev/null
+++ b/upload/frontend/table/render_proc_table.js
@@ -0,0 +1,74 @@
+// renderProcTable — 3-секционная таблица во время обработки
+// (готово / текущий / ожидают / пропущены сверх лимита).
+
+import { fmtSec } from './fmt_sec.js';
+import { estForFile, DEFAULT_EST_MB_SEC } from './est_for_file.js';
+import { procRow } from './proc_row.js';
+
+export function renderProcTable(state, els, cfg) {
+  const procState = state.proc.procState;
+  const groups = { done: [], current: [], pending: [], over: [] };
+  for (let i = 0; i < state.files.length; i++) {
+    if (state.overNames.has(state.files[i].name)) { groups.over.push(i); continue; }
+    const st = procState[i] ? procState[i].st : 'pending';
+    if (st === 'done' || st === 'skipped') groups.done.push(i);
+    else if (st === 'current') groups.current.push(i);
+    else groups.pending.push(i);
+  }
+  // Оценка скорости из текущего файла (сек/символ) — для «ожидающих»
+  let rate = null;
+  for (const i of groups.current) {
+    const p = procState[i];
+    const cur = (performance.now() - p.t0) / 1000;
+    const total = cur + (p.eta != null ? p.eta : 0);
+    if (p.chars > 0 && total > 0) rate = total / p.chars;
+  }
+  const rows = [];
+  if (groups.done.length) {
+    rows.push('<tr class="grp-row"><td colspan="4">✓ Обработанные (' + groups.done.length + ')</td></tr>');
+    for (const i of groups.done) {
+      const p = procState[i];
+      const txt = p.st === 'skipped'
+        ? '<span style="color:#c0392b;" title="Не удалось прочитать файл: пустой, повреждённый или скан без текста">не извлечён</span>'
+        : '<span style="color:#22c55e;">✓ ' + (p.elapsed ? p.elapsed.toFixed(1) : '0.0') + 'с</span>';
+      rows.push(procRow(state, i, txt));
+    }
+  }
+  if (groups.over.length) {
+    rows.push('<tr class="grp-row"><td colspan="4">⛔ Пропущены (сверх лимита) (' + groups.over.length + ')</td></tr>');
+    for (const i of groups.over) {
+      rows.push(procRow(state, i, '<span style="color:#c0392b;">пропущен (лимит)</span>'));
+    }
+  }
+  if (groups.current.length) {
+    rows.push('<tr class="grp-row"><td colspan="4">▶ Текущий файл</td></tr>');
+    for (const i of groups.current) {
+      const p = procState[i];
+      const cur = ((performance.now() - p.t0) / 1000).toFixed(1);
+      const eta = (p.eta != null) ? ' / ~' + fmtSec(p.eta) : '';
+      rows.push(procRow(state, i, '<span style="color:#2563eb;">⏳ ' + cur + 'с' + eta + '</span>'));
+    }
+  }
+  if (groups.pending.length) {
+    rows.push('<tr class="grp-row"><td colspan="4">○ Ожидают обработки (' + groups.pending.length + ')</td></tr>');
+    for (const i of groups.pending) {
+      const p = procState[i] || {};
+      // Оценка: LLM (chars x rate) если известна; иначе грубая по размеру/скорости извлечения
+      if (rate && !p.est && p.chars > 0) p.est = p.chars * rate;
+      if (!p.est) {
+        const szMB = (state.files[i] ? state.files[i].size : 0) / 1048576;
+        const k = (state.proc && state.proc.procExtractRate) || cfg.estMbSec || DEFAULT_EST_MB_SEC;  // сек/МБ
+        p.est = Math.max(1, Math.round(szMB * k));
+      }
+      let txt;
+      if (p.st === 'analyzed') txt = '<span style="color:#7d3c98;">анализ ✓</span>';
+      else if (p.st === 'current') txt = '<span style="color:#2563eb;">⏳</span>';
+      else if (p.est != null) txt = '<span style="color:#999;">~' + fmtSec(p.est) + '</span>';
+      else txt = '<span style="color:#999;">—</span>';
+      rows.push(procRow(state, i, txt));
+    }
+  }
+  els.tableBody.innerHTML = rows.join('');
+  const cntDone = groups.done.length;
+  els.countEl.textContent = 'Готово ' + cntDone + ' / ' + state.files.length + ' файлов';
+}
diff --git a/upload/frontend/table/rm_file.js b/upload/frontend/table/rm_file.js
new file mode 100644
index 0000000..4b5ab33
--- /dev/null
+++ b/upload/frontend/table/rm_file.js
@@ -0,0 +1,19 @@
+// rmFile — удалить файл из списка (если не busy).
+
+import { render } from './render.js';
+
+export function rmFile(state, els, cfg, i) {
+  if (state.busy) return;
+  const nm = state.files[i].name;
+  state.overNames.delete(nm);
+  state.fileMeta.delete(nm);
+  state.files.splice(i, 1);
+  // Синхронизировать input.files (DataTransfer) — чтобы повторный выбор того же
+  // файла сработал (change не сработает, если files не обновлён).
+  if (els.fileInput && els.fileInput.files) {
+    const d = new DataTransfer();
+    state.files.forEach(f => d.items.add(f));
+    els.fileInput.files = d.files;
+  }
+  render(state, els, cfg);
+}
diff --git a/upload/frontend/table/set_status.js b/upload/frontend/table/set_status.js
new file mode 100644
index 0000000..3df8d90
--- /dev/null
+++ b/upload/frontend/table/set_status.js
@@ -0,0 +1,6 @@
+// setStatus — записать HTML-статус в ячейку таблицы (st-<idx>).
+
+export function setStatus(idx, html) {
+  const e = document.getElementById('st-' + idx);
+  if (e) e.innerHTML = html;
+}
diff --git a/upload/frontend/test_upload_frontend.mjs b/upload/frontend/test_upload_frontend.mjs
new file mode 100644
index 0000000..efbced6
--- /dev/null
+++ b/upload/frontend/test_upload_frontend.mjs
@@ -0,0 +1,213 @@
+// Юнит-тесты фронта модуля upload: zip (кириллица, вложенный zip, не-doc) + дедуп/лимиты.
+// Запуск: node upload/frontend/test_upload_frontend.mjs
+
+import assert from 'node:assert/strict';
+
+// ── Полифилл File (Node 18 не имеет global File) ──
+if (typeof globalThis.File === 'undefined') {
+  globalThis.File = class File extends Blob {
+    constructor(parts, name, opts) {
+      super(parts, opts);
+      this.name = name;
+      this.lastModified = (opts && opts.lastModified) || Date.now();
+    }
+  };
+}
+
+import { listZipFiles } from './zip/list_zip_files.js';
+import { parseZip } from './zip/parse_zip.js';
+import { decodeZipName } from './zip/decode_zip_name.js';
+import { addFileWithDedup } from './table/add_file_with_dedup.js';
+
+const ALLOWED = ['.pdf', '.doc', '.docx', '.txt', '.md'];
+
+// ── CRC32 (для сборки тестовых ZIP) ──
+const CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+// ── Сборка минимального ZIP (method 0, UTF-8-флаг) ──
+function makeZip(entries) {
+  const enc = new TextEncoder();
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  const utf8Flag = 0x0800;
+  for (const e of entries) {
+    const nameB = enc.encode(e.name);
+    const dataB = typeof e.data === 'string' ? enc.encode(e.data) : e.data;
+    const crc = crc32(dataB);
+
+    const lh = new DataView(new ArrayBuffer(30));
+    lh.setUint32(0, 0x04034b50, true);
+    lh.setUint16(4, 20, true);
+    lh.setUint16(6, utf8Flag, true);
+    lh.setUint16(8, 0, true);
+    lh.setUint16(10, 0, true);
+    lh.setUint16(12, 0x21, true);
+    lh.setUint32(14, crc, true);
+    lh.setUint32(18, dataB.length, true);
+    lh.setUint32(22, dataB.length, true);
+    lh.setUint16(26, nameB.length, true);
+    lh.setUint16(28, 0, true);
+    chunks.push(Buffer.from(lh.buffer), Buffer.from(nameB), Buffer.from(dataB));
+
+    const cd = new DataView(new ArrayBuffer(46));
+    cd.setUint32(0, 0x02014b50, true);
+    cd.setUint16(4, 20, true);
+    cd.setUint16(6, 20, true);
+    cd.setUint16(8, utf8Flag, true);
+    cd.setUint16(10, 0, true);
+    cd.setUint16(12, 0, true);
+    cd.setUint16(14, 0x21, true);
+    cd.setUint32(16, crc, true);
+    cd.setUint32(20, dataB.length, true);
+    cd.setUint32(24, dataB.length, true);
+    cd.setUint16(28, nameB.length, true);
+    cd.setUint16(30, 0, true);
+    cd.setUint16(32, 0, true);
+    cd.setUint16(34, 0, true);
+    cd.setUint16(36, 0, true);
+    cd.setUint32(38, 0, true);
+    cd.setUint32(42, offset, true);
+    central.push(Buffer.from(cd.buffer), Buffer.from(nameB));
+    offset += 30 + nameB.length + dataB.length;
+  }
+
+  const cdSize = central.reduce((s, x) => s + x.byteLength, 0);
+  const cdStart = offset;
+  const eocd = new DataView(new ArrayBuffer(22));
+  eocd.setUint32(0, 0x06054b50, true);
+  eocd.setUint16(4, 0, true);
+  eocd.setUint16(6, 0, true);
+  eocd.setUint16(8, entries.length, true);
+  eocd.setUint16(10, entries.length, true);
+  eocd.setUint32(12, cdSize, true);
+  eocd.setUint32(16, cdStart, true);
+  eocd.setUint16(20, 0, true);
+  chunks.push(...central, Buffer.from(eocd.buffer));
+  return Buffer.concat(chunks);
+}
+
+// ── Тесты decodeZipName ──
+function testDecodeZipName() {
+  const utf8 = new TextEncoder().encode('договор.pdf');
+  assert.equal(decodeZipName(utf8, true), 'договор.pdf');
+  // Без UTF-8-флага, но байты — валидный UTF-8 с кириллицей → эвристика берёт как есть
+  assert.equal(decodeZipName(utf8, false), 'договор.pdf');
+  console.log('  decodeZipName: ok');
+}
+
+// ── Тесты listZipFiles ──
+async function testZipCyrillic() {
+  const zip = makeZip([{ name: 'договор.pdf', data: '%PDF-1.4 fake' }]);
+  const files = await listZipFiles(new File([zip], 'a.zip'), ALLOWED);
+  assert.equal(files.length, 1);
+  assert.equal(files[0].name, 'договор.pdf');
+  console.log('  zip кириллица: ok');
+}
+
+async function testZipNested() {
+  const inner = makeZip([{ name: 'inner.txt', data: 'hi' }]);
+  const outer = makeZip([
+    { name: 'inner.zip', data: inner },
+    { name: 'skip.txt', data: 'x' },
+  ]);
+  const files = await listZipFiles(new File([outer], 'outer.zip'), ALLOWED);
+  const names = files.map(f => f.name).sort();
+  assert.deepEqual(names, ['inner.txt', 'skip.txt']);
+  console.log('  вложенный zip: ok');
+}
+
+async function testZipNonDoc() {
+  const zip = makeZip([
+    { name: 'doc.pdf', data: 'pdf' },
+    { name: 'img.png', data: 'png' },
+    { name: 'readme.txt', data: 'readme' },
+  ]);
+  const files = await listZipFiles(new File([zip], 'a.zip'), ALLOWED);
+  const names = files.map(f => f.name).sort();
+  assert.deepEqual(names, ['doc.pdf', 'readme.txt']);
+  console.log('  не-doc фильтр: ok');
+}
+
+async function testParseZipNotZip() {
+  await assert.rejects(() => parseZip(new Uint8Array([1, 2, 3])), /Не ZIP/);
+  console.log('  не-ZIP бросок: ok');
+}
+
+// ── Тесты addFileWithDedup ──
+function newState() {
+  return { files: [], fileMeta: new Map(), overNames: new Set(), busy: false, proc: null };
+}
+
+function testDedup() {
+  const st = newState();
+  const c = { maxFileBytes: 100, maxSessionBytes: 300 };
+  // одинаковое имя+размер → дедуп (false), список не растёт
+  assert.equal(addFileWithDedup(st, new File(['aaa'], 'a.txt'), c), true);
+  assert.equal(st.files.length, 1);
+  assert.equal(addFileWithDedup(st, new File(['aaa'], 'a.txt'), c), false);
+  assert.equal(st.files.length, 1);
+  // имя то же, размер другой → суффикс _2
+  assert.equal(addFileWithDedup(st, new File(['bbbb'], 'a.txt'), c), true);
+  assert.equal(st.files.length, 2);
+  assert.equal(st.files[1].name, 'a_2.txt');
+  console.log('  дедуп/суффиксы: ok');
+}
+
+function testLimits() {
+  // лимит на один файл
+  const st = newState();
+  const c = { maxFileBytes: 100, maxSessionBytes: 300 };
+  addFileWithDedup(st, new File([new Uint8Array(150)], 'big.bin'), c);
+  assert.ok(st.overNames.has('big.bin'));
+  assert.equal(st.files.length, 1);
+  // суммарный лимит сессии
+  const st2 = newState();
+  const c2 = { maxFileBytes: 1000, maxSessionBytes: 200 };
+  addFileWithDedup(st2, new File([new Uint8Array(150)], 'f1.bin'), c2);
+  addFileWithDedup(st2, new File([new Uint8Array(60)], 'f2.bin'), c2);  // 150+60=210 > 200 → over
+  assert.ok(st2.overNames.has('f2.bin'));
+  console.log('  лимиты over: ok');
+}
+
+// ── Прогон ──
+const TESTS = [
+  ['decodeZipName', testDecodeZipName],
+  ['zip кириллица', testZipCyrillic],
+  ['вложенный zip', testZipNested],
+  ['не-doc фильтр', testZipNonDoc],
+  ['не-ZIP бросок', testParseZipNotZip],
+  ['дедуп/суффиксы', testDedup],
+  ['лимиты over', testLimits],
+];
+
+let failed = 0;
+for (const [name, fn] of TESTS) {
+  try {
+    await fn();
+    console.log('PASS ' + name);
+  } catch (err) {
+    failed++;
+    console.error('FAIL ' + name + ': ' + err.message);
+  }
+}
+
+if (failed) {
+  console.error(failed + ' тестов упало');
+  process.exit(1);
+}
+console.log('Все фронт-тесты прошли');
diff --git a/upload/frontend/upload/put_to_vm.js b/upload/frontend/upload/put_to_vm.js
new file mode 100644
index 0000000..c4c3b36
--- /dev/null
+++ b/upload/frontend/upload/put_to_vm.js
@@ -0,0 +1,22 @@
+// putToVm — PUT одного файла на ВМ-буфер (XHR, сырое тело).
+// onProgress(pct) — прогресс загрузки. Разрешается при HTTP 2xx.
+
+export function putToVm(file, url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('PUT', url);
+    xhr.timeout = options.timeoutMs || 300000;  // 300с: большие файлы
+    xhr.upload.onprogress = function(e) {
+      if (e.lengthComputable && options.onProgress) {
+        options.onProgress(Math.round(e.loaded / e.total * 100));
+      }
+    };
+    xhr.onload = function() {
+      if (xhr.status >= 200 && xhr.status < 300) resolve();
+      else reject(new Error('ВМ: HTTP ' + xhr.status));
+    };
+    xhr.onerror = function() { reject(new Error('Сеть (ВМ)')); };
+    xhr.ontimeout = function() { reject(new Error('Таймаут 300с (ВМ)')); };
+    xhr.send(file);  // сырое тело файла
+  });
+}
diff --git a/upload/frontend/upload/upload_via_vm.js b/upload/frontend/upload/upload_via_vm.js
new file mode 100644
index 0000000..b7c9b2e
--- /dev/null
+++ b/upload/frontend/upload/upload_via_vm.js
@@ -0,0 +1,58 @@
+// uploadViaVM — слой 2 (фронт): закачать файлы через ВМ-буфер.
+// Шаг 1: PUT каждого файла на ВМ (token-ключ в URL). Шаг 2: POST /api/upload_refs.
+//
+// files: File[] — ТОЛЬКО учитываемые (без сверхлимитных).
+// vmUploadUrl: базовый URL ВМ-буфера (напр. "https://.../drhider-upload/").
+// options: {
+//   session,        // текущий sid (или '')
+//   apiBase,        // базовый путь бэка, по умолчанию '' (тот же origin)
+//   onUploadStatus, // (text) — сообщение статуса
+//   onStatus,       // (k, html) — статус в таблице для k-го файла
+// }
+// Returns: Promise<{ok, session, count} | {ok:false, error}>
+
+import { putToVm } from './put_to_vm.js';
+import { fs } from '../table/fs.js';
+
+export async function uploadViaVM(files, vmUploadUrl, options = {}) {
+  const token = crypto.randomUUID();
+  const refs = [];  // {name, size, url} — для POST /api/upload_refs
+  const total = files.length;
+  for (let k = 0; k < total; k++) {
+    const f = files[k];
+    const vmUrl = vmUploadUrl + token + '_' + k;  // имя файла в URL не несём (токен-ключ)
+    if (options.onUploadStatus) {
+      options.onUploadStatus('Загрузка на ВМ (этап 1/2) ' + (k + 1) + '/' + total + ': ' + f.name);
+    }
+    try {
+      const t0 = performance.now();
+      await putToVm(f, vmUrl, {
+        onProgress(pct) {
+          if (options.onStatus) options.onStatus(k, '<span style="color:#2563eb">⏳ ' + pct + '%</span>');
+        },
+      });
+      const elapsed = (performance.now() - t0) / 1000;
+      const speed = f.size / elapsed;
+      if (options.onStatus) options.onStatus(k, '<span style="color:#22c55e">✓ ' + fs(speed) + '/s</span>');
+      refs.push({ name: f.name, size: f.size, url: vmUrl });
+    } catch (err) {
+      if (options.onStatus) options.onStatus(k, '<span style="color:#ef4444">✗</span>');
+      return { ok: false, error: 'Ошибка загрузки на ВМ: ' + err.message };
+    }
+  }
+
+  // Шаг 1b: один маленький POST во Flask со ссылками на файлы ВМ (<64КБ)
+  if (options.onUploadStatus) options.onUploadStatus('Передача ссылок в сервис…');
+  try {
+    const resp = await fetch((options.apiBase || '') + '/api/upload_refs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ session: options.session || '', files: refs })
+    });
+    const data = await resp.json();
+    if (!data.ok) throw new Error(data.error || 'HTTP ' + resp.status);
+    return { ok: true, session: data.session, count: data.count || refs.length };
+  } catch (err) {
+    return { ok: false, error: 'Ошибка передачи ссылок: ' + err.message };
+  }
+}
diff --git a/upload/frontend/zip/decode_zip_name.js b/upload/frontend/zip/decode_zip_name.js
new file mode 100644
index 0000000..1d7e028
--- /dev/null
+++ b/upload/frontend/zip/decode_zip_name.js
@@ -0,0 +1,22 @@
+// decodeZipName — декодирование имени из ZIP: UTF-8-флаг / эвристика (UTF-8 → CP437 → CP866).
+
+export function decodeZipName(bytes, isUtf8) {
+  if (isUtf8) return new TextDecoder('utf-8').decode(bytes);
+  // Многие архиваторы пишут имя в UTF-8, но НЕ выставляют UTF-8-флаг (bit 11).
+  // Сначала строго пробуем UTF-8: если байты — валидный UTF-8 с кириллицей/текстом,
+  // берём их как есть (иначе декодирование CP437→CP866 превратит их в «╨╣…»-мусор).
+  try {
+    const s = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    // Кириллица — точно UTF-8; либо чистый печатаемый текст без управляющих символов.
+    if (/[\u0400-\u04FF]/.test(s) || !/[^\u0020-\u007e]/.test(s)) return s;
+  } catch (e) { /* не UTF-8 — legacy (CP437/CP866) */ }
+  let name;
+  try { name = new TextDecoder('ibm437').decode(bytes); }
+  catch (e) { name = new TextDecoder('utf-8').decode(bytes); }
+  // Кириллица из 1С (CP866) — перекодировать, если имя пришло как CP437-мусор
+  if (/[^\x00-\x7f]/.test(name)) {
+    try { name = new TextDecoder('ibm866').decode(bytes); }
+    catch (e) { /* оставить как есть */ }
+  }
+  return name;
+}
diff --git a/upload/frontend/zip/dos_to_ms.js b/upload/frontend/zip/dos_to_ms.js
new file mode 100644
index 0000000..37a4905
--- /dev/null
+++ b/upload/frontend/zip/dos_to_ms.js
@@ -0,0 +1,11 @@
+// dosToMs — преобразование DOS-даты/времени (ZIP) в миллисекунды (unix epoch).
+
+export function dosToMs(date, time) {
+  const year = 1980 + ((date >> 9) & 0x7f);
+  const month = (date >> 5) & 0x0f;
+  const day = date & 0x1f;
+  const hour = (time >> 11) & 0x1f;
+  const min = (time >> 5) & 0x3f;
+  const sec = (time & 0x1f) * 2;
+  return new Date(year, month - 1, day, hour, min, sec).getTime();
+}
diff --git a/upload/frontend/zip/inflate_raw.js b/upload/frontend/zip/inflate_raw.js
new file mode 100644
index 0000000..6df8d65
--- /dev/null
+++ b/upload/frontend/zip/inflate_raw.js
@@ -0,0 +1,8 @@
+// inflateRaw — распаковка deflate-raw (метод 8) через нативный DecompressionStream.
+
+export async function inflateRaw(bytes) {
+  const ds = new DecompressionStream('deflate-raw');
+  const stream = new Blob([bytes]).stream().pipeThrough(ds);
+  const ab = await new Response(stream).arrayBuffer();
+  return new Uint8Array(ab);
+}
diff --git a/upload/frontend/zip/list_zip_files.js b/upload/frontend/zip/list_zip_files.js
new file mode 100644
index 0000000..5ae0cf3
--- /dev/null
+++ b/upload/frontend/zip/list_zip_files.js
@@ -0,0 +1,22 @@
+// listZipFiles — рекурсивно достать из ZIP только документы (вложенные zip — разворачиваются).
+
+import { parseZip } from './parse_zip.js';
+
+export async function listZipFiles(file, allowedExt) {
+  const buf = new Uint8Array(await file.arrayBuffer());
+  const entries = await parseZip(buf);
+  const out = [];
+  // Из ZIP вытаскиваем только документы. Всё прочее (изображения и т.п.) пропускаем.
+  for (const e of entries) {
+    if (e.isDir) continue;
+    const low = e.name.toLowerCase();
+    if (low.endsWith('.zip')) {
+      const sub = new File([e.data], e.name, { lastModified: e.dosMs });
+      out.push(...(await listZipFiles(sub, allowedExt)));
+    } else if (allowedExt.some(ext => low.endsWith(ext))) {
+      out.push(new File([e.data], e.name, { lastModified: e.dosMs }));
+    }
+    // иначе — не документ, пропускаем
+  }
+  return out;
+}
diff --git a/upload/frontend/zip/parse_zip.js b/upload/frontend/zip/parse_zip.js
new file mode 100644
index 0000000..742c7fc
--- /dev/null
+++ b/upload/frontend/zip/parse_zip.js
@@ -0,0 +1,50 @@
+// parseZip — разбор ZIP: центральный каталог → записи {name, data, dosMs, isDir}.
+// Поддерживаются методы 0 (store) и 8 (deflate). Без внешних библиотек.
+
+import { decodeZipName } from './decode_zip_name.js';
+import { inflateRaw } from './inflate_raw.js';
+import { dosToMs } from './dos_to_ms.js';
+
+export async function parseZip(buf) {
+  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= 0; i--) {
+    if (dv.getUint32(i, true) === 0x06054b50) { eocd = i; break; }
+  }
+  if (eocd < 0) throw new Error('Не ZIP');
+  const cdSize = dv.getUint32(eocd + 12, true);
+  const cdOffset = dv.getUint32(eocd + 16, true);
+
+  const entries = [];
+  let pos = cdOffset;
+  const cdEnd = cdOffset + cdSize;
+  while (pos < cdEnd) {
+    if (dv.getUint32(pos, true) !== 0x02014b50) break;
+    const flags = dv.getUint16(pos + 8, true);
+    const method = dv.getUint16(pos + 10, true);
+    const modTime = dv.getUint16(pos + 12, true);
+    const modDate = dv.getUint16(pos + 14, true);
+    const compSize = dv.getUint32(pos + 20, true);
+    const nameLen = dv.getUint16(pos + 28, true);
+    const extraLen = dv.getUint16(pos + 30, true);
+    const commentLen = dv.getUint16(pos + 32, true);
+    const localOffset = dv.getUint32(pos + 42, true);
+
+    const nameBytes = buf.slice(pos + 46, pos + 46 + nameLen);
+    const name = decodeZipName(nameBytes, (flags & 0x800) !== 0);
+
+    const lhNameLen = dv.getUint16(localOffset + 26, true);
+    const lhExtraLen = dv.getUint16(localOffset + 28, true);
+    const dataStart = localOffset + 30 + lhNameLen + lhExtraLen;
+    const comp = buf.slice(dataStart, dataStart + compSize);
+
+    let data;
+    if (method === 0) data = comp;
+    else if (method === 8) data = await inflateRaw(comp);
+    else throw new Error('Метод сжатия ' + method + ' не поддерживается');
+
+    entries.push({ name, data, dosMs: dosToMs(modDate, modTime), isDir: name.endsWith('/') });
+    pos += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}