Record full-suite failure deleting an unowned member-files temp

Validation: ./build.sh --no-gui -j4 and make check -j4 passed; 186 tests, no failures.

.gitignore

@@ -2,7 +2,9 @@
 /build/
 build-win/
 tools/chatgui/build/
+tools/chatgui/rlottie_build/
 tools/chatgui/ffmpeg/ffmpeg_build/
+tools/lightsout/build/
 
 # Build outputs
 *.o
@@ -11,6 +13,8 @@ tools/chatgui/ffmpeg/ffmpeg_build/
 *.a
 *.so
 *.so.*
+# Prebuilt native runtime для Android VAD (onnxruntime) — коммитим несмотря на *.so
+!tools/chatgui-android/app/src/main/jniLibs/*/libonnxruntime.so
 /utun
 /src/utun
 test_serialize
@@ -28,6 +32,7 @@ index.html
 *.exe
 
 # Autotools
+/.utun-build-state*
 Makefile
 !tools/etcpmon/Makefile
 Makefile.in
@@ -80,6 +85,7 @@ logs/
 tests/test_*
 !tests/test_*.c
 !tests/test_*.h
+!tests/test_*.py
 !tests/test_*.conf
 !tests/test_*.json
 tests/bench_*
@@ -108,6 +114,7 @@ tools/proxy/udp_proxy
 
 # Reference projects (not part of utun)
 tools/tdesktop-dev/
+/hardware/
 
 # Debug/temp artifacts
 *.bak

AGENTS.md

@@ -25,12 +25,24 @@ This file contains essential information for AI coding agents working in the uTu
 При поиске багов всегда проверяй достаточно ли отладочной информации. Если не достаточно - фокусируйся на том чтобы добавить нужную информацию в вывод.
 Помни что отладка управляется фильтрами по категормяи, которые нужно проверить и при необходимости правильно настроить (в конфиге или в коде).
 
+Для поиска выстараивай информативные логи. По которым максимально чётко понятно что происходит. Если какие-то места которые могут иметь отношение к ошибке в логах пропущены - это повод доработать логи и прогнать еще раз.
+Всегда отладку выстраивай через доработку логов, пока точно и однозначно не будет видно в каком точно месте проблема.
+
+По хорошей диагностике сразу должно быть понятно что происходит, в том числе точную причину проблемы. Если приходится догадываться или плохо понятно - это значит что надо улучшать диагностику.
+
+Доствп на узел colo2: ssh -p44322 logs@colo2
+
+Структура .h файлов:
+- в начале краткое и понятное описание: что делает модуль, как пользоваться.
+- поля структур также кратко описываем - что, для его, если есть нюансы/значения
+- для функций: описываем назначение, как пользоваться, описание аргументов, возврата. кратко но понятно.
+
 ## Quick Reference
 
-**Repository:** uTun - Secure VPN tunnel with ETCP protocol
+**Repository:** uTun — общее сетевое ядро ETCP, независимо запускаемые UTUN и P2P-чат
 **Language:** C (C99)
 **Build System:** GNU Autotools (autoconf/automake)
-**Cryptography:** OpenSSL (AES-CCM, X25519, SHA256)
+**Cryptography:** OpenSSL (AES-CCM, X25519, Ed25519, SHA256)
 
 ## Build Commands
 
@@ -44,9 +56,19 @@ This file contains essential information for AI coding agents working in the uTu
 powershell build_full.bat       # запускает bash build.sh --full через MSYS2 UCRT64
 ```
 
+### Build (FreeBSD)
+```sh
+# Первичная установка инструментов от root:
+pkg install -y bash gmake autoconf automake libtool pkgconf openssl python3
+./build.sh -j4                 # общий скрипт; автоматически выбирает gmake и Clang
+./build_bsd_full.sh -j4        # полная сборка через общий скрипт
+```
+Python 3 нужен для проверок скрипта сборки. SHA-256 берётся из базовой системы FreeBSD.
+
 ### Incremental Build
 ```bash
-./build.sh -j4                 # make с авто-конфигурацией если надо
+./build.sh -j4                 # инкрементальная сборка, конфигурация и очистка при необходимости
+./build.sh --no-gui -j4        # только ядро и тесты, без отдельной сборки GUI
 ```
 ```powershell
 powershell -Command ".\build.bat" 2>&1   # Windows, логи: build_win.log
@@ -61,9 +83,10 @@ make distclean                 # Clean everything including configure files
 
 ### Partial Builds
 ```bash
-cd lib && make                 # Build only the library (libuasync.a)
-cd src && make                 # Build only the main program
-cd tests && make               # Build only tests
+make -C lib                    # базовые библиотеки
+make -C lib/libopus            # встроенный Opus
+make -C src                    # основной бинарник src/utun (библиотеки уже должны быть собраны)
+make -C tests                  # тесты (используют объекты src/)
 ```
 
 ### Direct Build (Windows, без autotools)
@@ -79,7 +102,7 @@ python3 tools/chatcli members <ch_id>              # мемберы с полн
 python3 tools/chatcli messages <ch_id> [count]     # последние сообщения
 python3 tools/chatcli send <ch_id> "text"          # отправить сообщение
 python3 tools/chatcli invite <ch_id>               # создать invite-ссылку
-python3 tools/chatcli connect <utun://...>         # join по ссылке
+python3 tools/chatcli connect 'utun://...'         # join по ссылке
 python3 tools/chatcli create "Name"                # создать канал
 python3 tools/chatcli listen                       # слушать события (Ctrl+C выход)
 ```
@@ -87,13 +110,14 @@ python3 tools/chatcli listen                       # слушать событи
 
 ### ASAN Build (AddressSanitizer, Linux)
 ```bash
-./build.sh --asan -j4           # lib/ + src/ only (tests not ASAN-compatible)
+./build.sh --asan -j4           # собирает lib/ + src/; тесты этот режим скрипта пропускает
 ```
 Запуск с ASAN (detect_leaks отключены чтобы не спамить при shutdown):
 ```bash
-ASAN_OPTIONS=detect_leaks=0:halt_on_error=0 ./src/utun -f -p /tmp/utun.pid -l /tmp/utun.log
+ASAN_OPTIONS=detect_leaks=0:halt_on_error=0:log_path=/tmp/utun_asan ./src/utun -f -p /tmp/utun.pid -l /tmp/utun.log
 ```
-Краш-логи ASAN пишутся в `/tmp/utun_asan.<pid>`.
+В этом примере отчёты ASAN пишутся в `/tmp/utun_asan.<pid>` благодаря `log_path`.
+Для отдельного теста нужно собирать его зависимости с теми же sanitizer-флагами; обычные и ASAN-объекты не смешивать.
 
 ## Test Commands
 
@@ -111,13 +135,14 @@ cd tests/
 ./test_etcp_two_instances
 ```
 
-### Run Single Test with Debug Info
+### Build and Run a Single Test
 ```bash
-cd tests/
-gcc -I../src -I../lib -I../tinycrypt/lib/include \
-    -o my_test test_file.c ../src/*.c ../lib/*.c ../tinycrypt/lib/source/*.c
-./my_test
+make -C tests test_services
+cd tests && ./test_services
 ```
+Использовать цель из `tests/Makefile.am`: ручная компиляция `src/*.c` пропускает подкаталоги и добавляет лишний `main`.
+Уровни и категории диагностики настраиваются в самом тесте через `debug_set_level` / `debug_set_category_level`.
+Проверки самого скрипта сборки запускаются отдельно: `make -C tests check-build-script` (нужен Python 3); в `./check.sh` они не входят.
 
 ## Code Style Guidelines
 
@@ -130,7 +155,7 @@ gcc -I../src -I../lib -I../tinycrypt/lib/include \
 
 ### Formatting
 - **Indentation:** 4 spaces, no tabs
-- **Braces:** Same line for functions, new line for control structures:
+- **Braces:** Открывающая скобка на строке функции или условия:
   ```c
   int function(void) {
       if (condition) {
@@ -138,7 +163,7 @@ gcc -I../src -I../lib -I../tinycrypt/lib/include \
       }
   }
   ```
-- **Comments:** Primary language is Russian for business logic, English for API docs
+- **Comments:** Краткие описания на русском; сохранять принятые имена API и протокольных полей.
 - **Line Length:** Aim for 80-100 characters, but can go up to 150 if logically coherent
 
 ### Include Order
@@ -194,7 +219,7 @@ sc_context_t ctx;
 sc_init_ctx(&ctx, &my_keys);
 
 // 2. Set peer public key (for key exchange)
-sc_set_peer_public_key(&ctx, peer_public_key, SC_PEER_PUBKEY_HEX); // 0=bin, 1=hex
+sc_set_peer_public_key(&ctx, peer_public_key_bin, SC_PEER_PUBKEY_BIN); // 32 бинарных байта; HEX — для hex-строки
 
 // 3. Ready for encrypt/decrypt
 sc_encrypt(&ctx, plaintext, plaintext_len, ciphertext, &ciphertext_len);
@@ -216,134 +241,254 @@ sc_obfuscate_pubkey(salt, peer_pubkey_bin, my_pubkey_bin, obfuscated_output);
 ### Debug Levels
 `none < error < warn < info < debug < trace`
 trace - логируем заходы в функции и важные ветвления внутри функций
-debug - всё что нужно для понимание сути происходящего (состояний, важных переменных) алгоритма. тоесть по уровню debug мы должны видеть все важные внутреннии нюансы работы функции включая состояния и переменные.
+debug - отладка: всё что нужно для понимание сути происходящего (состояний, важных переменных) алгоритма. тоесть по уровню debug мы должны видеть все важные внутреннии нюансы работы функции включая состояния и переменные.
 info - сообщения для пользователя о работе. мы должны видеть в читаемом виде понятные и осмысленные сообщения о каких-либо значимых действиях с точки зрения логики работы модуля или приложения
 warn / error - ошибки и предупреждения (аномалии). должны быть во всех ошибочных ветках. Молча вываливаться с ошибкой нельзя, все ошибки и предупреждения должны логироваться.
 
-### Debug Categories (28 категорий)
-```
-NONE=0, UASYNC=1, LL_QUEUE=2, CONNECTION=3, ETCP=4, CRYPTO=5, MEMORY=6,
-TIMING=7, CONFIG=8, TUN=9, ROUTING=10, TIMERS=11, NORMALIZER=12, BGP=13,
-SOCKET=14, CONTROL=15, DUMP=16, TRAFFIC=17, DEBUG=18, GENERAL=19, NAT=20,
-KEEPALIVE=21, ETCPROUTE=22, BBR=23, ETCP_DUMP=24, CONNECTIVITY=25, DB_SYNC=26,
-MEMBER_SYNC=27
-```
+### Debug Categories
+Актуальные имена и константы — в `lib/debug_config.h`, текстовые имена — в `lib/debug_config.c`.
+Основные: `sys`, `connection`, `etcp`, `crypto`, `config`, `tun`, `routing`, `timers`, `bgp`,
+`socket`, `control`, `dump`, `traffic`, `debug`, `general`, `nat`, `keepalive`, `etcp_route`,
+`media`, `etcp_dump`, `chat`, `chat_sync`, `member_sync`, `proxy`, `video`, `reality`, `dm`, `call`, `radio`, `vad`, `aec`.
+UASYNC/LL_QUEUE/MEMORY/TIMING объединены в SYS, NORMALIZER/BBR — в ETCP; старые числовые списки не использовать.
 
 ### Настройка отладки
-- В конфиге: `debug = etcp=trace,config=info` (формат: `категория=уровень,...`)
+- В INI-конфиге: секция `[debug]`, каждая категория отдельной строкой (`etcp=trace`, `config=info`).
+- Строку `etcp=trace,config=info` принимает `debug_parse_config()`; GUI хранит её в `[gui] debug_categories`.
 - В коде: глобальный уровень и per-category уровни из `debug_config_t g_debug_config`
 - Макросы: `DEBUG_ERROR(cat,fmt,...)` `DEBUG_WARN` `DEBUG_INFO` `DEBUG_DEBUG` `DEBUG_TRACE`
-- `log_dump(prefix, data, len)` — hex dump в лог
+- `log_dump(level, category, prefix, data, len)` — hex dump в лог
 
 ### Dual Output
-- Консоль и файл настраиваются раздельно (`debug_set_console_level`, `debug_set_file_level`)
+- Фильтр уровней общий для выходов; `debug_enable_console()` включает/выключает консоль.
 - `debug_enable_file_output(path, truncate)` / `debug_disable_file_output()`
 
 ## Architecture
 
+### Ядро, сервисы и владение ресурсами
+
+- `utun_instance_create*()` создаёт ядро; `utun_core_start()` запускает общие сетевые службы.
+- `utun_service_start/stop()` управляет UTUN-группой, TUN/NAT и запросами к пирам из конфига.
+- `chat_service_start/stop()` управляет чатом и CHAT-группами. Чат не требует UTUN; desktop и Android запускают ядро и чат явно.
+- Ядро владеет общей SQLite (`db_path/chats.db`, без пути — `:memory:`), идентичностью, транспортом и маршрутизатором.
+  Остановка сервиса сохраняет БД и ресурсы другого сервиса. `utun_instance_destroy()` освобождает ядро, но не переданный `UASYNC`.
+- Группа владеет NCD handle с начала CONNECTING. Инициатор хранит отменяемый `TOPO_PEER_REQUEST`;
+  закрытие своего запроса не разрывает транспорт других владельцев. Готовая сессия сохраняется у группы.
+- UP означает работоспособный транспорт. READY означает завершённое согласование и обмен таблицей конкретной группы.
+  Recovery ждёт нужных маршрутов через READY-пиров; наличие `ETCP_CONN*` само по себе не гарантирует UP.
+- JOIN добавляет подписанного мембера, Merkle распространяет запись. Доступ к CHAT-группе каждый узел даёт по своей таблице участников;
+  invite-ключ не даёт временного членства. Протокол описан в `src/chat/chat_join.h`, групповое согласование — в `src/routing_layer/topo_group.h`.
+- `TOPO_NODE` — общая подписанная запись узла. Более свежий timestamp заменяет запись целиком, с полями и подписью;
+  адреса не версионируются отдельно. BGP обновляет запись и передаёт изменения NCD (см. `doc/node_snapshot.md`).
+- BGP хранит один путь к назначению от каждого соседа. WITHDRAW удаляет только путь отправителя;
+  NODEINFO с прежним timestamp также обновляет путь. Выбор: живой путь с минимумом хопов, затем меньший ID соседа.
+  REINIT сохраняет пути до проверки нового снимка; TABLE_COMPLETE удаляет неподтверждённые, зависший обмен перезапускается.
+- ETCP-router дописывает ID при транзите и отбрасывает повторное посещение для DATA/ACK/control.
+  Список переходов находится вне подписанного тела; формат описан в `src/routing_layer/etcp_router.h`.
+
+Все операции с ядром выполняются в его uasync-потоке; stop/destroy — вне callbacks останавливаемых сервисов.
+Порядок освобождения ресурсов и нюансы media workers: `doc/service_lifecycle.md`.
+
 ### Directory Structure
 ```
-├── lib/                    # Core libraries (18 .c + 20 .h + libopus/liblmdb)
+├── lib/                    # uasync, очереди, SQLite, Opus, SpeexDSP, Silero VAD, SoundTouch, LMDB
 ├── src/                    # Main source code
-│   ├── transport_layer/    #   ETCP stack, crypto, STCP, normalizer, BBR (~30 файлов)
-│   ├── routing_layer/      #   Routing, BGP, conn_mgr, etcp_router, NAT detection (~20 файлов)
-│   ├── chat/               #   P2P чат, db_sync, merkle_sync, member_sync (17 файлов)
-│   ├── proxy/              #   SOCKS5, TCP/UDP/ICMP прокси (10 файлов)
-│   ├── lwip_tcp/           #   Встроенный lwIP TCP стек (7 файлов)
-│   ├── media_delivery/     #   Доставка медиафайлов (6 файлов)
-│   ├── media_async/        #   Асинхронный движок медиа (2 файла)
-│   └── *.c/h               #   Корневые модули: utun, config, TUN, firewall, NAT, NTP, control (~14 файлов)
-├── tests/                  # ~70 тестов, 64 в check_PROGRAMS
+│   ├── transport_layer/    #   ETCP, сессии, crypto, STCP/REALITY, SOCKS-клиент, NCD, BBR
+│   ├── routing_layer/      #   Routing, группы/BGP, recovery, conn_mgr, etcp_router
+│   ├── chat/               #   P2P чат, join, db_sync, merkle_sync, member_sync
+│   ├── dm/                 #   Личные сообщения, E2E-вложения и offline-mailbox
+│   ├── call/               #   Звонки и общий голосовой стек
+│   ├── radio/              #   Групповая PTT-рация
+│   ├── stream/             #   Прямые трансляции: подписанные RS-блоки, выбор поставщиков, аудио/видео
+│   ├── member_files/       #   Файловое хранилище участников CHAT-группы и асинхронные передачи
+│   ├── local_transport/    #   Обнаружение устройств и доставка приглашений в локальной сети по UDP
+│   ├── proxy/              #   SOCKS5, TCP/UDP/ICMP прокси
+│   ├── lwip_tcp/           #   Встроенный lwIP TCP стек
+│   ├── media_delivery/     #   Блоки медиа каналов и передача неизменяемых файлов
+│   ├── media_async/        #   Фоновые задачи, метаданные вложений, подготовка голоса/видео
+│   ├── video/              #   Пробинг и транскодирование видео через FFmpeg
+│   ├── dnsmasq/            #   Архив исходников для встроенной сборки dnsmasq
+│   └── *.c/h               #   utun, instance, config, TUN, firewall, NAT, NTP, control, broadcast
+├── tests/                  # Состав тестов и цели запуска: tests/Makefile.am
 ├── doc/                    # Technical Specifications
 ├── tools/                  # Auxiliary tools
 │   ├── etcpmon/            # GUI монитор ETCP
 │   ├── chatgui/            # GUI чат (Qt 6 с Qt 5 fallback, сборка CMake)
 │   ├── chatgui-android/    # Android P2P чат (Jetpack Compose + libutun_lite)
+│   ├── logreceiver/        # Приём UDP-логов Android
+│   ├── chat_tcp_test/      # Сценарий проверки чата через TCP
+│   ├── lightsout/          # Отдельная игра Lights Out на Qt
+│   ├── lightsout-android/  # Android-версия Lights Out
 │   ├── tdesktop-dev/       # Референс: Telegram Desktop (только для изучения)
 │   ├── proxy/              # UDP прокси для тестов
-│   └── bping/              # BPing (bandwidth ping)
+│   ├── bping/              # BPing (bandwidth ping)
+│   └── chatcli             # Headless CLI; описание команд — chatcli_commands.txt
 ├── tinycrypt/              # TinyCrypt crypto library (external)
-├── net_emulator/           # Network emulator (delays, loss, reordering)
-└── c2/                     # Test instance 2 (конфиг и бинарник для тестов)
+└── net_emulator/           # Network emulator (delays, loss, reordering)
 ```
 
 ### File Overview
 
+Пути ниже относительны к каталогу секции; `name.c/h` означает пару `.c` и `.h`.
+Перечислены модули проекта; внутренние файлы сторонних библиотек сгруппированы по каталогам.
+
 **Core (src/)**
 - `utun.c` - Main program entry point, CLI parsing, daemon mode
-- `utun_instance.c/h` - Root instance lifecycle, config loading, all submodule init
+- `utun_instance.c/h` - Создание ядра и независимый жизненный цикл UTUN/чата, владение общими ресурсами
 - `tun_if.c/h` - TUN interface API (init/write/close, cross-platform)
 - `tun_linux.c` `tun_freebsd.c` `tun_windows.c` - Platform-specific TUN implementations
 - `tun_route.c/h` - TUN routing table sync
 - `config_parser.c/h` - INI-style config file parsing
-- `config_updater.c/h` - Config file modification utilities
+- `config_updater.c/h` - Проверка и сохранение согласованных X25519-ключей и node_id в INI-конфиге
 - `control_server.c/h` - Control/monitoring server (etcpmon backend API)
 - `firewall.c/h` - Firewall rules (per-interface filtering)
 - `eim_nat.c/h` - Endpoint-Independent Mapping NAT engine
-- `nat_transport.c/h` - NAT transport layer (packet relay)
-- `ntp_time.c/h` - NTP time synchronization
-- `ntp_node_time.c/h` - Inter-node time synchronization
+- `nat_transport.c/h` - Передача IPv4 между отдельным TUN и удалённым NAT-провайдером через UTUN-router; локальный провайдер использует eim_nat
+- `ntp_time.c/h` - Асинхронная NTP-синхронизация: поправка времени instance без изменения часов ОС
+- `ntp_node_time.c/h` - Получение временной поправки от синхронизированных ETCP-пиров и диагностика расхождения часов
+- `broadcast.c/h` - Широковещательная рассылка данных по topo-группе (UUID-дедупликация, TTL)
+- `video/video.c/h` - Пробинг и транскодирование видео (FFmpeg, опционально; H.264/MP4 ≤720p)
+- `dnsmasq/` - Архив dnsmasq-2.93.tar.xz для встроенной сборки
 
 **Transport Layer (src/transport_layer/)**
 - `etcp.c/h` - ETCP protocol implementation (inflight queues, retrans, ACK, RTT/jitter)
 - `etcp_api.c/h` - ETCP public API (send/recv/bind callbacks)
 - `etcp_connections.c/h` - Socket and link management, INIT handshake, keepalive, PING/PONG
+- `etcp_session.c/h` - Согласование эпох ETCP-сессии через HELLO/CHALLENGE/CONFIRM и проверка принадлежности DATA сессии
 - `etcp_loadbalancer.c/h` - Multi-link load balancing with traffic shaper
-- `etcp_debug.c/h` - ETCP packet dump/formatting
+- `etcp_debug.c/h` - Диагностический разбор секций ETCP_DGRAM и форматирование IPv4-адресов
 - `etcp_dump.c/h` - ETCP дамп/декодирование пакетов
 - `etcp_bbr.c/h` - BBR congestion control for ETCP
-- `etcp_connect.c/h` - ETCP outbound connections
+- `etcp_keepalive.c/h` - Keepalive-пакеты, адаптивный период, смена режима standby/normal (мобильные узлы)
+- `auto_socket.c/h` - Автосоздание UDP+TCP сокетов на всех интерфейсах и линков к ETCP-соединениям (`auto_sockets=yes`)
 - `pkt_normalizer.c/h` - Packet fragmentation/reassembly (packer/unpacker)
-- `packet_dump.c/h` - Packet hex dump utility
-- `dummynet.c/h` - Network emulator integrated into utun (for testing)
-- `secure_channel.c/h` - AES-CCM encryption with X25519 key exchange, pubkey obfuscation
+- `packet_dump.c/h` - Текстовая сводка IPv4-пакета: адреса, поля транспорта и короткий hex-фрагмент
+- `dummynet.c/h` - Двунаправленный UDP-эмулятор между заданными endpoint: задержка, ограничение скорости и случайные потери
+- `secure_channel.c/h` - X25519, пакетное AES-128-CCM, потоковое AES-CTR, подписи Ed25519 и обфускация публичного ключа
+- `etcp_padding.c/h` - Выбор длины случайного padding и периодическое обновление диапазона для instance/соединения
+- `etcp_tx_stats.c/h` - Общая статистика исходящих очередей, inflight и подтверждённых за секунду байтов ядра
 - `crc32.c/h` - CRC32 checksums
-- `stcp.c/h` - STCP протокол (Secure TCP)
-- `stcp_server.c/h` - STCP сервер
-- `stcp_client.c/h` - STCP клиент
-- `stcp_link.c/h` - STCP линк-уровень
-- `node_conn_direct.c/h` - Direct config-based connections
-- `socket_monitor.c/h` - Socket state monitoring
+- `stcp.c/h` - Зашифрованные кадры поверх TCP: согласование ключей/эпох, AES-CTR, CRC, очереди и закрытие соединения
+- `stcp_server.c/h` - Приём входящих STCP-соединений, handshake и передача готового соединения владельцу
+- `stcp_client.c/h` - Исходящее STCP-подключение, в том числе через SOCKS5 и REALITY
+- `stcp_link.c/h` - Подключение STCP к ETCP_LINK: передача пакетов, backpressure и жизненный цикл TCP-линка
+- `socks_client.c/h` - Исходящий SOCKS5-транспорт: TCP CONNECT и UDP ASSOCIATE с переподключением control-сокета
+- `node_conn_direct.c/h` - Общий прямой транспорт к пиру с отдельным handle каждого владельца; обновление линков по адресам узла
+- `socket_monitor.c/h` - Наблюдение за адресами интерфейсов и маршрутами ОС, обновление сетевого состояния ETCP-сокетов
+- `reality.c/h` - REALITY-style TLS ClientHello/ServerHello камуфляж для STCP
+- `reality_fingerprint.c/h` - Статические отпечатки (cipher suites, groups, ALPN) для REALITY-камуфляжа
+- `reality_io.c/h` - Внешний REALITY-handshake и поток защищённых записей STCP, Finished, replay-защита и выбор relay
+- `reality_record.c/h` - TLS-подобные AES-128-GCM записи: вывод ключей, счётчики направлений, padding и KeyUpdate
+- `reality_relay.c/h` - Релей неавторизованных клиентов на реальный HTTPS-сайт
+- `stun_nat.c/h` - Проверка mapping/filtering NAT через внешние STUN-серверы, RFC 5780 и кеш результатов по IP/интерфейсу
+- `call_ring.c/h` - Кольцевой трейс контрольных точек освобождения ETCP/STCP-ресурсов для диагностики teardown/UAF
 
 **BBR (src/transport_layer/BBR/)**
 - `bbr_v3.c` - BBR congestion control algorithm v3
 
 **Routing Layer (src/routing_layer/)**
-- `routing.c/h` - Routing table (local)
-- `route_lib.c/h` - Routing library
-- `route6_lib.c/h` - IPv6 routing
-- `route_ping.c/h` - Route ping probing (NAT check, liveness)
-- `route_connectivity.c/h` - Route connectivity checks
-- `topo_group.c/h` - BGP-like route exchange between nodes (NODEINFO/WITHDRAW, изолированные группы UTUN/CHAT)
-- `topo_group_connect.c/h` - Авто-подключение к узлам CHAT-группы (3 фазы, бесконечный цикл)
-- `topo_group_invite.c/h` - Invite/join канала через прямое ncd-подключение (INVITE_INFO_REQ/RESP)
-- `topo_node.c/h` - Node management (модель узла: TOPO_NODE/TOPO_GROUP_NODE, сериализация, node_registry)
-- `topo_node_sqlite.c/h` - SQLite persistence for nodes
-- `topo_recovery.c/h` - Восстановление каскадно отвалившихся узлов после разрыва соединения
+- `routing.c/h` - Обмен IPv4-пакетами UTUN между локальным TUN и сервисом DATA ETCP-router
+- `route_lib.c/h` - Локальная таблица IPv4-подсетей UTUN: добавление/удаление маршрутов и поиск узла назначения
+- `route6_lib.c/h` - Локальная таблица IPv6-подсетей на radix tree с поиском по самому длинному префиксу
+- `route_ping.c/h` - Пинг цели через явно выбранного BGP-посредника для NAT-проверки
+- `route_connectivity.c/h` - Прямые UDP/TCP-пробы адресов узла для оценки достижимости и RTT при выборе пиров
+- `topo_group.c/h` - Сессии UTUN/CHAT (JOIN/ACCEPT, эпохи, READY), групповые запросы, NODEINFO/WITHDRAW и владение NCD
+- `topo_group_connect.c/h` - Подбор пиров CHAT-группы по роли: суперузлы → desktop → mobile; история/RTT внутри класса, backoff и standby burst
+- `topo_group_invite.c/h` - Получение описания канала через INVITE_INFO_REQ/RESP; добавление мембера реализовано в chat_join/chat_sync
+- `topo_node.c/h` - Модель TOPO_NODE/TOPO_GROUP_NODE, подписанные снимки узлов, сериализация и общий node_registry
+- `topo_node_sqlite.c/h` - Хранение подписанных снимков узлов, адресов, каналов и блоков мемберов в общей SQLite
+- `topo_recovery.c/h` - Восстановление потерянных маршрутов группы через READY-сессии, отмена попыток при stop
 - `conn_mgr.h` + `conn_mgr_core.c`/`conn_mgr_indirect.c`/`conn_mgr_monitor.c` + `conn_mgr_priv.h` — Connection Manager (handle-based API, 3-phase DIR/REV/IND)
-- `etcp_router.c/h` - ETCP router/multiplexer (мультиплексирование каналов, transit forwarding)
-- `nat_detection.c/h` - NAT type detection
+- `etcp_router.c/h` - Надёжные логические каналы сервисов поверх BGP-маршрутов: ACK, окна, транзит и защита от циклов
+- `route_tx_stats.c/h` - Скользящее окно подтверждённых payload-байтов логического канала для оценки скорости доставки
+- `multicast.c/h` - Рассылка списку узлов группы с разделением маршрута на ветви, локальными подписками и отчётами о потерях
+- `nat_detection.c/h` - Проверка mapping и доступности входящих рабочих сокетов через ETCP-пиров с учётом предварительных STUN-измерений
+- `address_profile.h` - Профиль endpoint: изменение адреса, доступность входящих и источник измерения ETCP/STUN
+- `sock_match.c/h` - Классификация локальных сокетов и адресов пира, отбор совместимых пар для прямого подключения
+- `route_crypto.c/h` - Пред/пост-обработка SVC_ROUTE пакетов (encrypt-then-sign)
 
 **Chat (src/chat/)** — децентрализованный P2P чат: сообщения и участники автоматически синхронизируются между всеми узлами канала без центрального сервера.
-- `chat_core.c/h` - Главный модуль чата. Единственная точка входа из GUI: принять сообщение, создать канал, изменить настройку. Управляет БД и жизненным циклом всех chat-модулей
+- `chat_core.c/h` - API сообщений, каналов, профиля и настроек; chat_service_start/stop управляют чат-сервисом поверх общей БД ядра
 - `chat_core_priv.h` - Внутренний API для частей chat_core: общий контекст и утилиты БД. Снаружи не используется
 - `chat_sync.c/h` - Связывает чат с ETCP-сетью: отслеживает появление/разрыв соединений, обновляет онлайн-статус узлов, запускает синхронизацию участников каналов, обрабатывает приглашения
 - `chat_event.c/h` - Доставка событий из ядра чата в GUI. Единый механизм: любой модуль отправляет событие (новое сообщение, смена участников, статус), GUI получает через один обработчик
-- `chat_setting.c/h` - Настройки чата: проверяет корректность значений, хранит текущие. Используется и headless-парсером конфига, и GUI. Не зависит от других модулей
-- `db_sync.c/h` - Автоматическая репликация данных между подключёнными узлами. Запись на одном узле — появляется у всех остальных. Криптоподписи и цепочка хешей защищают от подделок
+- `chat_setting.c/h` - Проверка и хранение настроек чата per-instance; общая логика для конфигурации и GUI
+- `chat_join.c/h` - Регистрация invite-ключа с ACK, пересылка запроса инвайтеру и добавление подписанного мембера; контракт join в заголовке
+- `db_sync.c/h` - Репликация подписанных записей SQLite через прямые ETCP-соединения; расхождения по цепочке хешей, новые записи через PUSH
 - `member_sync.c/h` - Синхронизация участников каналов поверх merkle_sync. Два подписанных блока (мембер/владелец), по-блочное сравнение версий, верификация подписей. Удаление — только битая запись
 - `merkle_sync.c/h` - Универсальный движок синхронизации на Merkle-деревьях (5 уровней × 32 бакета, SHA256). Пиры обмениваются хешами и передают только различия; per-session out-очередь с backpressure. Не привязан к конкретному типу данных (коллбэки `data_ops`)
-- `chat_profile.c` - Собственный профиль: имя узла, сетевые адреса, сохранение UI-состояния (часть chat_core)
-- `chat_channel.c` - Создание и настройка каналов: готовит таблицы в БД, генерирует криптоключи, запускает подключение ко всем участникам (часть chat_core)
+- `merkle_tree.c/h` - Производный индекс Merkle-хешей в SQLite; восстанавливается из данных модели, обновляется с ними в одной транзакции
+- `chat_profile.c` - Подписанный профиль мембера: имя, аватар и опции сервисов; локальное UI-состояние (часть chat_core)
+- `chat_channel.c` - Создание и настройка каналов: таблицы, криптоключи, CHAT-группа и планировщик подключения (часть chat_core)
 - `chat_msg.c` - Отправка и приём сообщений: запись в локальную БД, автоматическая рассылка всем участникам канала (часть chat_core)
+- `chat_feedback.c/h` - Подписанные реакции и ответы: версии состояния, сохранение отмен и Merkle-синхронизация между участниками
+- `chat_poll.c/h` - Создание опросов, голосование, реакции и JSON-снимки результатов для UI/headless
+- `chat_poll_codec.c` - Проверка и wire-кодеки опросов, ответов и реакций; общий каталог эмодзи (API в chat_poll.h)
+- `chat_attachment.c/h` - Зашифрованные вложения канала: ключи, запросы доступа, ручное одобрение автора и сохраняемый outbox
+- `chat_local.c/h` - Обнаружение устройств чата и обмен готовыми invite-ссылками через локальный UDP-транспорт
+- `group_avatar.c/h` - Подписанная аватарка канала: хранение версии в SQLite, проверка подписи и передача блоков через router
 - `chat_status.c` - Сбор диагностики: текущее время, активные соединения, типы NAT. Отправляется в GUI (часть chat_core)
+- `chat_member.c/h` - Единая структура мембера для отображения в GUI (десктоп/headless/Android), фиксированная сериализация на проводе
+- `chat_admin.c/h` - Передача канального приватного ключа (прав админа) другому узлу
+- `chat_whisper.c/h` - Whisper speech-to-text транскрипция голосовых сообщений (опционально, асинхронно через media_async)
+- `chat_headless_control.c/h` - TCP control-socket для headless chat CLI (JSON line protocol)
+- `invite_build.c/h` - Сборка invite-ссылок utun:// (выбор лучшего узла + адреса)
+- `invite_link.c/h` - Кодирование utun://: версия, пароль, channel_id, join_key, Reality-параметры, ключ и адреса узла
+
+**Личные сообщения (src/dm/)**
+
+- `dm_core.c/h` - Беседы двух узлов, подписанные E2E-сообщения, SQLite/outbox, доставка через router/mailbox и квитанции
+- `dm_crypto.c/h` - Вывод ID беседы и ключа X25519, AES-256-CCM сообщений и E2E-контейнеры медиа через media_crypto
+- `dm_history.c/h` - Локальное удаление истории и скрытие бесед; поколения задач и отпечатки удалённых сообщений против повторов
+- `dm_mailbox.c/h` - Offline-очередь суперузла: хранение подписанных сообщений и повтор доставки до квитанции получателя
+- `dm_media.c/h` - Подготовка, доставка и публикация E2E-вложений; ciphertext-хранилище и отдельные квитанции файлов
+- `dm_media_priv.h` - Внутренние SQL/control-операции для dm_media и dm_mailbox_media
+- `dm_mailbox_media.c/h` - Сохраняемые задания суперузла для размещения медиа, доставки метаданных и удаления копий до DELETE_ACK
+
+**Звонки (src/call/)**
+
+- `call.c/h` - P2P аудио/видеозвонок: подписанный E2E-сигналинг, состояния, политика занятости и оптимизация пути через conn_mgr
+- `call_priv.h` - Общее внутреннее состояние сессии для call.c и call_video_transport.c; доступ только из uasync
+- `call_proto.h` - Wire-формат сигналинга, аудиокадров и управления видеотреком; треки/кодеки и причины завершения
+- `call_audio.c/h` - Общий аудио-движок: кодирование/декодирование Opus, jitter-буфер и тоны, API feed/pull PCM
+- `call_jitter.cpp/h` - FIFO Opus, адаптивный сетевой запас, декодирование на pull и восстановление воспроизведения после пауз
+- `call_jitter_window.h` - Окно из десяти секундных интервалов для оценки глубины очереди и изменения задержки доставки
+- `call_clock.h` - Метки времени захвата и снимок реально проигранного аудио для синхронизации видеотрека
+- `call_delay.cpp/h` - Уменьшение накопленной задержки PCM прямым ускорением и SoundTouch с сохранением исходной шкалы времени
+- `call_timeline.cpp/h` - Карта исходного PTS через обработку SoundTouch до позиции аудиоустройства
+- `call_video.c/h` - Общий формат H.264/H.265 видеотрека, согласование возможностей и сборка кадров из фрагментов
+- `call_video_bitstream.c/h` - Проверка конфигурации и IDR без reorder, профиля/уровня и геометрии H.264/H.265; KEY-пробы кодеков
+- `call_video_transport.c/h` - Отдельные router-каналы control/audio/video, backpressure, привязка видео к аудио и запросы KEY
+- `call_video_rate.c/h` - Регулятор битрейта и допуска новых видеокадров по скорости доставки, RTT и долгу очереди
+- `call_video_port.c/h` - Потокобезопасный обмен кадрами и командами между платформенными video workers и uasync-транспортом
+- `call_video_playout.c/h` - Расписание показа по аудиочасам, ожидание/отбрасывание кадров и подтверждение фактического показа
+- `call_video_fixtures.h` - Встроенные H.264/H.265 KEY-пробы для проверки базовых режимов кодека
+- `call_video_fast_fixtures.h` - KEY-пробы видеорежимов с частотой 60 fps
+- `call_video_fullhd_fixtures.h` - KEY-пробы видеорежимов Full HD
+- `call_video_portrait_fixtures.h` - KEY-пробы видеорежимов в портретной ориентации
+- `call_tones.c/h` - Генерация PCM-тонов паузы и завершения звонка
+- `call_headless.c/h` - Отдельный TCP-аудиосокет headless-клиента: обмен PCM; сигналинг остаётся на control-сокете
+
+**Рация (src/radio/)**
+
+- `radio.c/h` - Передача Opus по CHAT-группе, подписки, дедупликация и пересылка по ветвям с подписчиками
+- `radio_proto.h` - Wire-формат PTT: источник, поток, seq, FIN и hop-list против циклов
+- `radio_audio.c/h` - Общий аудио-движок: независимые RX/TX, Opus, микширование источников, ручной PTT и VAD-автомат
+- `radio_jitter.cpp/h` - Буфер кодированных кадров каждого источника с pre-roll и SoundTouch time-stretch на pull
+- `radio_vad.h` - Ресемплинг 48→16 кГц и автомат авто-PTT с подтверждением речи, задержкой завершения и учётом занятого канала
+- `radio_auto.h` - Общий автомат автопередачи по VAD/уровню звука, без захвата аудио и сетевого I/O
+- `radio_call.c/h` - Адресное приглашение участника в рацию канала: сигналинг вызова, занятость, принятие и отмена
+- `radio_headless.c/h` - TCP-аудиосокет headless-рации: PCM и команды начала/конца PTT
 
 **Прокси (src/proxy/)**
-- `socks_proxy.c/h` - SOCKS5 прокси
-- `udp_proxy.c/h` - UDP прокси
-- `icmp_proxy.c/h` - ICMP прокси
-- `tcp_proxy_server.c/h` - TCP прокси (серверная сторона)
-- `tcp_proxy_client.c/h` - TCP прокси (клиентская сторона)
+
+- `proxy_protocol.h` - Общий TCP-протокол и управление потоком: CONNECTED, DATA, кредит WINDOW, упорядоченный FIN
+- `socks_proxy.c/h` - Клиентские SOCKS5 CONNECT и HTTP proxy/CONNECT, DNS и передача потока выбранному exit-узлу
+- `http_proxy.c/h` - Потоковый HTTP/1.x кодек: проверка заголовков, разбор тела/chunked и учёт потреблённых байтов для WINDOW
+- `udp_proxy.c/h` - Передача UDP из TUN через exit-узел, сопоставление ответов и удаление неактивных потоков
+- `icmp_proxy.c/h` - Проксирование IPv4 ICMP echo через raw socket exit-узла с восстановлением исходных id/seq
+- `tcp_proxy_server.c/h` - Exit-сторона TCP-прокси: реальные исходящие сокеты, потоки по (peer, stream_id), окна и half-close
+- `tcp_proxy_client.c/h` - Клиентская сторона TCP-прокси: адаптер TUN/lwIP и обмен с настроенным exit через ETCP-router
 
 **lwIP TCP (src/lwip_tcp/)**
 - `lwip_tcp.c/h` - lwIP TCP стек
@@ -352,34 +497,102 @@ MEMBER_SYNC=27
 - `lwip_tcp_priv.h`, `lwip_tcp_opts.h` - Внутренние настройки lwIP
 
 **Media Delivery (src/media_delivery/)**
-- `media_delivery.c/h` + `media_delivery_proto.h` - Доставка медиафайлов, протокол
-- `media_download.c/h` - Скачивание медиа
-- `media_index.c/h` - Индексация медиафайлов
+- `media_delivery.c/h` - Доставка блоков медиа каналов, учёт держателей, репликация доступности между суперузлами и relay
+- `media_delivery_proto.h` - Кодограммы канального медиа: QUERY, BLOCK_REQ/CHUNK/DONE, HAVE_BLOCK и SUPER_REPL
+- `media_download.c/h` - Загрузка блоков с выбором держателей, failover, контролем простоя, проверкой подписей и сборкой файла
+- `media_index.c/h` - Индекс media_files: UUID, хеши и подписи блоков, асинхронная регистрация и удаление медиа канала
+- `file_transfer.c/h` - Передача неизменяемого файла между заданными узлами; авторизация lookup и владение CM handle до завершения
 
 **Media Async (src/media_async/)**
-- `media_async.c/h` - Асинхронный движок (thread-per-task для crypto/file операций)
+- `media_async.c/h` - Фоновые crypto/file-задачи: work в pthread, done в uasync; destroy ждёт workers и завершает ожидающие callbacks с CANCELLED
+- `attachment.c/h` - Общие метаданные file/voice/video, проверка и компактная wire-сериализация
+- `voice_file.c/h` - Worker-кодирование PCM в контейнер Opus с длительностью и waveform для desktop/Android
+- `attachment_send.c/h` - Асинхронная подготовка голоса/видео и отправка в зафиксированный канал или DM
+- `media_crypto.c/h` - Общие AES-256-CCM примитивы и порционное шифрование/проверка файлов для DM и групповых вложений
+- `encrypted_file.c/h` - Контейнер группового вложения: шифрование метаданных/файла, проверка SHA256 и durable-публикация результата
+
+**Трансляции (src/stream/)** — live-аудио/видео CHAT-группы с подписью источника, Reed–Solomon и раздачей через участников.
+
+- `stream.c/h` - Жизненный цикл трансляции, локальные handles издателя/читателей, события и публикация подписок
+- `stream_priv.h` - Внутренний доступ к сессиям, приём проверенных DATA/END и взаимодействие с планировщиком relay
+- `stream_proto.h` - Форматы подписанной пачки и RS-частей, дескриптор источника, размеры и коды результата
+- `stream_block.c/h` - Подпись пачки Ed25519 до RS-кодирования, разбор частей и проверка восстановленных данных
+- `stream_buffer.c/h` - Ограниченное кольцо RS-частей: дедупликация, восстановление пачек, проверка подписи и вытеснение старых данных
+- `stream_source.c/h` - Упаковка исходных байтов в подписанные RS-пачки, сброс неполной пачки по таймеру и завершение источника
+- `stream_member.c/h` - Объявления источников и подписок в опциях подписанного мембера; разбор и проверка принадлежности источника
+- `stream_wire.c/h` - Протокол выдач и relay: кодограммы управления, пути, метрики и подписанное завершение END
+- `stream_network.c/h` - Выдача блоков через прямой ETCP, NCD-владение, управляющие очереди, аренда подписок и reverse-запросы
+- `stream_optimizer.c/h` - Автоматический выбор и перенос поставщиков субпотоков, пробы доступности и привлечение relay
+- `stream_metrics.c/h` - Оценка относительного отставания субпотока и истории проблем по часам источника без NTP
+- `stream_load.c/h` - Учёт логической очереди DATA и её роста для обнаружения перегрузки раздающего узла
+- `stream_media.c/h` - Формат uAV2: упаковка/проверка видеокадров, конфигурации кодека, PTS и Opus внутри FEC-пачек
+- `stream_media_buffer.c/h` - Медиаиндекс общего RS-кольца и независимые курсоры audio/video; сборка кадров и восстановление с KEY
+- `stream_publisher.c/h` - Общий потокобезопасный publisher desktop/Android: очередь готовых кадров, публикация и завершение с FIN
+- `stream_viewer.c/h` - Независимые viewers: запрос ограниченных батчей по бюджетам треков, уведомления готовности и конца audio/video
+- `stream_playback_audio.cpp/h` - Opus/SoundTouch и очередь готового PCM; ускорение без изменения высоты и привязка к позиции устройства
+- `stream_playback_clock.c/h` - Общие часы воспроизведения и плавный догон live-потока по непрерывному запасу готового материала
+
+**Файлы участников (src/member_files/)**
+
+- `member_files.c/h` - Сервер и асинхронный клиент хранилища CHAT-группы: права доступа, запросы и события через защищённый router
+- `protocol.c/h` - Wire-кодек файловых команд, снимки версий каталогов/файлов и токены временных загрузок
+- `storage.c/h` - Серверные каталоги участников, квоты, файловые операции, временные загрузки и их очистка
+- `transfer.c` - Передача файлов с CM handle, backpressure, дисковым worker, проверкой хеша и публикацией результата
+- `disk.c/h` - Дисковые примитивы POSIX/Windows: безопасное разрешение путей без ссылок и I/O по 64-битному смещению
+- `worker.c/h` - Единственный дисковый pthread с ограниченной очередью и возвратом результатов в uasync
+- `private.h` - Внутреннее состояние запросов, передач, серверного хранилища и дискового worker
+
+**Локальная сеть (src/local_transport/)**
+
+- `local_transport.c/h` - Открытый UDP-транспорт LAN: обнаружение устройств, доставка сообщений с ACK/повторами и ограничения входящего потока
+- `platform.c/h` - Снимок IPv4/IPv6 интерфейсов, broadcast/multicast-адреса, приём метаданных UDP и проверка локальности источника
+- `protocol.h` - Wire-формат объявлений, сообщений и ACK: ID/эпохи устройств, ID запроса и проверка UTF-8 имени
 
 **Libraries (lib/)**
 - `u_async.c/h` - Async event loop (epoll/poll/select, timers via timeout_heap)
-- `ll_queue.c/h` - Lock-free linked list queue with callbacks, hash index, threshold waiter
-- `memory_pool.c/h` - Fast object pool allocator (pre-allocated blocks)
+- `ll_queue.c/h` - Двусвязная очередь одного uasync-потока с callbacks, хеш-индексом и ожиданием свободного места
+- `memory_pool.c/h` - Пул объектов: ленивое выделение и повторное использование, до 64 свободных объектов в кеше
 - `debug_config.c/h` - Debug logging system (levels, categories, dual output, runtime config)
 - `timeout_heap.c/h` - Min-heap for timer management (used by u_async)
 - `mem.c/h` - Memory wrappers with leak tracking (`u_malloc`/`u_free`/`u_calloc`/`u_strdup`)
 - `serialize.c/h` - Binary serialization utilities
+- `reed_solomon.c/h` - Кодирование и восстановление пачки данных Рида—Соломона с настраиваемым числом субблоков и избыточностью
+- `video_plane.c/h` - Копирование YUV-плоскости с поворотом 0/90/180/270°, учётом stride и проверкой границ без выделения памяти
 - `swm_min.c/h` - Sliding window minimum (for RTT min tracking)
-- `getmyip.c/h` - Get local IP / default route detection
+- `getmyip.c/h` - Локальный IP, который ОС выберет для UDP к заданному адресу (bind/connect/getsockname)
 - `myip.c` - My IP helper (no header)
 - `socket_compat.c/h` - Cross-platform socket compatibility (Linux/FreeBSD/Windows)
 - `platform_compat.c/h` - Cross-platform compatibility layer (byte order, time, random)
 - `radix.c/h` - Radix tree for IP routing lookups
-- `tcp_io.c/h` - TCP I/O abstraction (Windows IOCP, Linux epoll)
+- `tcp_io.c/h` - Неблокирующий TCP поверх uasync/ll_queue: backpressure, FIN/close и callbacks
 - `sqlite3.c/h` - SQLite3 amalgamation (embedded database)
 - `opus_codec.c/h` - Opus audio codec wrapper
 - `audio_compressor.c/h` - Audio dynamic range compressor
+- `speex_aec.c/h` - Эхоподавление SpeexDSP: согласование playback/capture PCM через линию задержки и диагностика её заполнения
+- `silero_vad.c/h` - Стриминговый VAD через ONNX Runtime: окна 512 отсчётов, 16 кГц моно, вероятность речи и сброс состояния
+- `silero_vad_model.inc` - Встроенная ONNX-модель Silero VAD для silero_vad_create_default
 - `json_flat.c/h` - Flat JSON parser
+- `strbuf.c/h` - Безопасный растущий printf-буфер (замена snprintf-цепочек)
+- `async_dns.c/h` - Асинхронный (неблокирующий) DNS-резолвер A-записей поверх uasync, адаптер над libdns
+- `dns.c/h` - Рекурсивный reentrant DNS-резолвер (libdns, MIT)
+- `miniaudio.h` - Воспроизведение/захват аудио (single-header)
+- `dr_mp3.h` - MP3-декодер (single-header, на базе minimp3)
+- `liblmdb/` - Встраиваемый key-value store LMDB
+- `libopus/` - Встраиваемый кодек Opus
+- `speexdsp/` - Встроенные исходники эхоканселлера SpeexDSP и KISS FFT
+- `soundtouch-master/` - SoundTouch: изменение темпа аудио в jitter-буферах звонка и рации
 - `wintun.h` - Wintun API header for Windows TUN driver
 
+**Проверки (tests/)**
+
+- `Makefile.am` - Состав тестовых целей, зависимости и отдельные проверки runner, service IDs и скрипта сборки
+- `run_tests.py` - Запуск тестов ограниченным пулом с отдельными логами и последовательными барьерами для CPU/LAN-проверок
+- `test_run_tests.py` - Проверки пула runner, эксклюзивного запуска, обработки ошибок и сигналов
+- `test_service_ids.py` - Проверка уникальности ID транспортных и router-сервисов
+- `test_build_script.py` - Регрессии выбора платформы, конфигурации и инкрементальной работы build.sh
+- `stream_netns/` - Linux network namespaces: топологии, NAT/STUN-сценарии и проверка трансляций в изолированной сети
+- `local_transport_ipv6.sh` - Проверка IPv6 link-local обнаружения и доставки в изолированной локальной сети
+
 **Memory Pools in UTUN_INSTANCE:**
 - `data_pool` — для данных пакетов (payload), используется input_queue/output_queue фрагментами
 - `pkt_pool` — для struct ETCP_DGRAM (сетевые пакеты на отправку/приём)
@@ -387,7 +600,7 @@ MEMBER_SYNC=27
 
 ### Key Components
 - **UASYNC:** One per thread. Async event loop (epoll/poll), timers via timeout_heap
-- **LL_QUEUE:** Lock-free queue with auto-callback, hash index lookup, threshold waiter
+- **LL_QUEUE:** Очередь с auto-callback, хеш-индексом и threshold waiter; не средство обмена между потоками
 - **Memory Pool:** Fast allocation for hot-path objects (packets, inflight entries, fragments)
 - **ETCP:** TCP-like reliable protocol with encryption, multi-link, load balancing
 - **Secure Channel:** AES-CCM + X25519 key exchange, nonce-based encryption, pubkey obfuscation
@@ -403,6 +616,8 @@ MEMBER_SYNC=27
 - Очереди забивать нельзя. Добавляй следующий элемент только когда очередь стала пустой.
 - Порог задаётся через `queue_set_threshold(q, max_packets, max_bytes)`.
 - Используй `queue_waiter_wait` для ожидания освобождения очереди до заданного порога.
+- Handle ожидания обнуляется целиком, живёт до callback/отмены и отменяется до освобождения владельца.
+  Callback может быть синхронным. `queue_entry_free` не освобождает dgram — его освобождают отдельно.
 
 ### Чтение из очереди
 - Используй `queue_set_callback`: при вызове callback обработай один или несколько элементов, потом вызови `queue_resume_callback`.
@@ -422,12 +637,13 @@ MEMBER_SYNC=27
 ## Config Rules
 - В серверном конфиге только собственные ключи и нет секций `[client]`
 - В клиентском конфиге есть собственные ключи и pubkey каждого сервера в секции `[client]`
-- Chat-настройки хранятся в секции `[chat]`. Парсер вызывает `chat_setting_set(key, value)` для каждого ключа — неизвестные ключи вызывают ошибку. Пример:
+- Chat-настройки хранятся в `[chatserver]` (также `[chat]`). Парсер обрабатывает общие поля секции,
+  затем вызывает `chat_setting_set_state(&cfg->global.chat_settings, key, value)`; неизвестные ключи логируются как ошибка. Пример:
   ```ini
-  [chat]
+  [chatserver]
   storage_autoload=1
-  storage_autoload_maxsize_mb=10
-  storage_maxsize_gb=1
+  storage_unit_size=10M
+  storage_total_size=1G
   opus_codec_preset=1
   compressor_enabled=0
   compressor_max_gain_db=25
@@ -445,7 +661,8 @@ MEMBER_SYNC=27
 Если видишь спам-логи - подумай как их выборочно отключить чтобы не мешали.
 
 Для отладки добавляй в DEBUG_CATEGORY_DEBUG диагностические сообщения где надо. И включи эту категорию в настройках. Убирай только после проверки (путём запуска) когда все ошибки устранены.
-сообщение выводится по или - либо debug_set_level(DEBUG_LEVEL_TRACE) - выводится ВСЁ независимо от настроек по категориям. Тоесть берется max(global level, category lavel)
+Явный уровень категории заменяет глобальный. DEBUG_LEVEL_NONE наследует глобальный уровень;
+DEBUG_LEVEL_DISABLED полностью отключает категорию, в том числе при глобальном TRACE (см. debug_should_output).
 
 Твой бич - ты постоянно гадаешь и анализируешь код. Что приводит к снежному кобу ошибок и неверных гипотез. 10 раз повторяю - только логи логи логи и никакого гадания. Лоооги!!! правильные логи покажут всё с предельной точностью. Вся суть отладки - информативные логи
 И смотри логи. не задавливай их grep-ом. лучше больше. единственное с чем борись - это бесполезные спам логи.
@@ -455,7 +672,8 @@ MEMBER_SYNC=27
 
 Но полезные смотри всегда, и всегда оставляй логи которые выводятся нечасто.
 Частые логи - это трафик которые >100 раз повторяются. Но которые мало раз обязательно оставлять и выводить.
-можешь в тесте включить логи в нужный интервал чтобы не спамить. debug_set_level(DEBUG_LEVEL_TRACE) и выключить debug_set_level(DEBUG_LEVEL_NONE)
+В тесте можно временно поднять нужные категории до TRACE, сохранив прежние уровни и восстановив их после участка.
+Одного debug_set_level(DEBUG_LEVEL_NONE) недостаточно для отключения категорий с явно заданным уровнем.
 Если видишь проблему и ее решение неочевидно то выстраивай диагностику вокруг неё пока не будет очевидно где и что происходит не так. Это базовое и обязательное требование к отладке.
 Подробные логи ты должен выводить не обрезая всегда и анализировать. Если лог большой - выведи в файл и анализируй файл.
 Рассуждение должно быть примерно таким:
@@ -497,7 +715,7 @@ MEMBER_SYNC=27
 - Нельзя ничего восстанавливать из репозитория не спрашивая
 - Для отладки не printf а DEBUG_*
 - Запрещено прямое включение arpa/inet.h, sys/time.h, unistd.h — использовать ../lib/platform_compat.h + socket_compat.h
-- Перед сборкой всегда make clean
+- Меняй режим и флаги сборки через `./build.sh`: он отслеживает конфигурацию и очищает объекты только при необходимости.
 - Все лишнее что менял при отладке - строго вернуть назад в состояние до вмешательства
 
 ## Написание кода
@@ -506,12 +724,17 @@ MEMBER_SYNC=27
 - Обязательно наличие подробной диагностики в функциях кода которые не сильно спамят (не часто вызываются).
 - Для каждого отладочного вывода подумай какая из доступной информация будет полезна чтобы можно было наиболее завершенно оценить состояние алгоритма и состояний влияющих на алгоритм.
 
+## Оформление кода
+- в .c: перед каждой функцией - краткое но понятное описание что делает функция (кроме совсем простых)
+- в .h: в начале - описание модуля - для чего предназначен, как пользоваться, нюансы. Далее структуры с комментариями, далее публичные функции с описаниями (что делает, как пользоваться, какие аргументы, возврат, нюансы работы)
 
 ## chatgui (GUI Chat Client)
 
-Chatgui — десктопный GUI-чат на Qt 6 (Qt 5 fallback), отдельный проект внутри репозитория. Не связан с autotools-сборкой utun.
+Chatgui (бинарник `vibechat`) — десктопный чат на Qt 6 (Qt 5 fallback), отдельная CMake-сборка общего ядра.
+Корневой `build.sh` дополнительно вызывает её, если уже существует `tools/chatgui/build/CMakeCache.txt`.
 
-В chat gui интегрированы библиотеки utun. Чат и библиотеки работают в разных потоках. Поэтому нужно использовать семафоры, сокеты или другие механизмы синхронизации (uasync_post, uasync_memsync, uasync_get_wakeup_fd)
+GUI работает в Qt-потоке, ядро и чат — в uasync-потоке. Команды передаются через
+`gui_bridge_post_uasync()` / `uasync_post()`, события возвращаются через Qt-сигналы.
 
 База данных sqlite в chatgui: можно писать (update) из потока utun / instance. можно только читать из gui потока.
 
@@ -519,38 +742,45 @@ Chatgui — десктопный GUI-чат на Qt 6 (Qt 5 fallback), отде
 - **Язык:** C++20
 - **Фреймворк:** Qt 6 (предпочитаемый) или Qt 5.15+ (Widgets + Network)
 - **Сборка:** CMake 3.16+
-- **БД:** SQLite3 (WAL mode, встроенный `db/sqlite3.c` amalgamation)
+- **БД:** SQLite3 (WAL mode, компилируется общий `lib/sqlite3.c`)
 - **Анимации:** rlottie (C API) + zlib (gzip-декомпрессия TGS)
 
 ### Сборка
 ```bash
 # Установка зависимостей
-sudo apt install librlottie-dev zlib1g-dev qt6-base-dev
+sudo apt install librlottie-dev zlib1g-dev qt6-base-dev libssl-dev libx11-dev libxfixes-dev libpipewire-0.3-dev
 # или qtbase5-dev для Qt 5 fallback
 
 # Сборка
 cd tools/chatgui && mkdir -p build && cd build
 cmake .. && make -j4
-./chatgui
+./vibechat
 ```
 
 ### Конфиг и логи чатгуи
-- **Конфиг:** `tools/chatgui/build/chatgui.cfg` (в `.gitignore`, содержит приватные ключи)
+- **Конфиг:** `vibechat.cfg` рядом с бинарником (обычно `tools/chatgui/build/vibechat.cfg`, содержит приватные ключи)
   - Секция `[gui]`: `debug_file`, `debug_level`, `debug_categories=cat=level,...`
   - Секция `[control]`: `ip`, `port` для подключения etcpmon
   - Секция `[ntp]`: синхронизация времени
 - **Лог:** `tools/chatgui/build/chatgui.log` (путь задаётся в конфиге `debug_file`)
-- **БД чата:** `tools/chatgui/build/chat_data/` (SQLite, путь из `db_path` в конфиге)
+- **БД чата:** `chats.db` в каталоге `[gui] db_path` (по умолчанию `chat_data/` рядом с бинарником)
 
 ### Структура файлов (src/)
 
 | Файл | Назначение |
 |------|-----------|
-| `main.cpp` | Точка входа, инициализация QApplication |
-| `mainwindow.h/cpp` | Главное окно, QSplitter (ChannelList \| MessageList \| AccountList), трей |
-| `chatview.h/cpp` | QListView с фоновым изображением, hover-сигнал, drag-to-select |
-| `messagelist.h/cpp` | QStandardItemModel, stub-данные, инициализация анимаций, hover→activate |
+| `main.cpp` | Точка входа, QApplication, язык интерфейса и запуск единственного экземпляра профиля |
+| `single_instance.h/cpp` | Блокировка каталога профиля и передача запроса показа окна уже работающему экземпляру |
+| `gui_language.h` | Выбор языка интерфейса независимо от регионального формата дат и чисел |
+| `mainwindow.h/cpp` | Главное окно, каналы/DM, трей, события ядра, звонки, локальные приглашения и окна трансляций |
+| `chatview.h/cpp` | Список сообщений: фон, hover, выделение текста и прокрутка истории мышью/клавиатурой |
+| `messagelist.h/cpp` | Модель сообщений из БД, обновления доставки/медиа, анимации, состояние просмотра канала |
 | `messagedelegate.h/cpp` | QStyledItemDelegate: бабблы, текст, цитаты, реакции, оверлей анимаций |
+| `messagefeedback.cpp` | Действия MessageList: создание опроса, голосование, выбор реакции и показ результатов |
+| `attachment_key_ui.cpp` | Список запросов на расшифровку групповых вложений и решения автора о выдаче ключа |
+| `message_links.h/cpp` | Разбор границ utun:// и HTTP/HTTPS ссылок для подсветки и обработки нажатий в сообщении |
+| `message_notification.h/cpp` | Уведомление о сообщении без захвата фокуса, переход в беседу и скрытие после активности пользователя |
+| `user_activity_monitor.h/cpp` | Ожидание первой активности через системный idle time либо события приложения |
 | `emoji.h/cpp` | EmojiData/EmojiCategory/EmojiType, 4 категории, `g_animatedEmojiMap` |
 | `emojipanel.h/cpp` | Эмодзи-пикер: QTabWidget + QGridLayout, EmojiButton с hover-анимацией |
 | `emojitabbar.h/cpp` | Кастомный QTabBar для эмодзи-панели |
@@ -558,20 +788,107 @@ cmake .. && make -j4
 | `lottieicon.h/cpp` | Загрузка TGS (gzip→zlib), рендер кадров через `lottie_animation_render` |
 | `animtimer.h/cpp` | Синглтон-таймер 30fps, refcount activate/deactivate, сигнал ticked |
 | `channellist.h/cpp` `channeldelegate.h/cpp` | Список каналов с аватарами и превью |
-| `accountlist.h/cpp` | Список аккаунтов/пользователей |
+| `accountlist.h/cpp` `accountdelegate.h/cpp` | Список аккаунтов/пользователей и его делегат отрисовки |
+| `memberlistmodel.h/cpp` | Модель списка участников канала |
+| `memberpropsdialog.h/cpp` | Диалог свойств участника |
+| `flagpainter.h/cpp` | Отрисовка иконок мембера (admin/mod/supernode/storage) |
 | `joindialog.h/cpp` | Диалог присоединения к группе/каналу |
 | `invitedialog.h/cpp` | Диалог приглашения пользователя |
 | `invite_link.h/cpp` | Логика invite-ссылок |
+| `inviteby.h/cpp` | Диалог приглашения по invite-ссылке (отправка через узел) |
+| `dminvitedialog.h/cpp` | Выбор канала для приглашения собеседника из DM с сопоставлением результата по request_id |
 | `settingsdialog.h/cpp` | Окно настроек |
 | `creategroupdialog.h/cpp` | Диалог создания группы |
+| `channelsettingsdialog.h/cpp` | Диалог настроек канала |
+| `renamedialog.h/cpp` | Диалог переименования |
 | `networksettingspage.h/cpp` | Страница сетевых настроек |
+| `addressprofiletext.h` | Читаемое представление mapping, доступности входящих и источника NAT-измерения |
+| `nodespage.h/cpp` | Таблица узлов + дамп в настройках |
+| `statuspage.h/cpp` | Страница статуса (NTP + соединения + живые часы) |
+| `databasesettingspage.h/cpp` | Страница обслуживания БД в настройках |
+| `storagesettingspage.h/cpp` | Страница настроек хранилища |
+| `soundsettingspage.h/cpp` | Страница настроек звука |
+| `audiodevicesettingspage.h/cpp` | Страница настроек аудиоустройств |
+| `sound_manager.h/cpp` | Общий miniaudio-контекст, уведомления/PCM, микширование голоса, маршруты устройств и восстановление |
+| `audio_device.h/cpp` | Жизненный цикл miniaudio-устройства, прогресс callbacks, пауза и повтор запуска после сбоя |
+| `audio_buffer_tuning.h` | Подбор размера аппаратного аудиобуфера по повторным XRUN с сохранением настройки при reopen |
+| `audio_capture.h/cpp` | Совместное использование одного микрофона трансляцией и рацией, подписки PCM и смена профиля захвата |
+| `audio_capture_lease.h` | Владение захватом, исключающее одновременную работу publisher, звонка и записи голосового сообщения |
+| `audio_event_queue.h` | Ограниченная очередь PCM/команд с несколькими producers и резервом для управляющих событий |
+| `audio_frame_ring.h` | Предвыделенное SPSC-кольцо кадров переменной длины под mutex; при переполнении удаляет старейший |
+| `voice_audio_io.h/cpp` | Workers захвата/AEC и воспроизведения; упорядочивание PCM/PTT/mute и итоговый render-reference |
+| `voice_capture_clock.h` | Непрерывные PTS захваченного PCM по позиции сэмплов с плавной поправкой аппаратного времени |
+| `voice_playback_buffer.h` | Адаптивный запас готового PCM: увеличение после недостачи и уменьшение при стабильном выводе |
+| `audiorecorder.h/cpp` | Захват голосовых сообщений, worker обработки PCM, компрессор, индикатор уровня и передача записи задаче |
+| `voicemessageencoder.h/cpp` | Выбор Opus preset и создание медиа-каталога; кодирование выполняет общий voice_file |
+| `voiceplayback.h/cpp` | Воспроизведение голосовых сообщений |
+| `callwindow.h/cpp` | Окно аудио/видеозвонка: управление, выбор камеры, локальное/удалённое видео и статистика |
+| `call_audio_engine.h/cpp` | Desktop-контур звонка: захват, VoiceAudioIo, общий выход SoundManager и завершение аудиосессии |
+| `call_video_engine.h/cpp` | Desktop-видеозвонок: камера, TX/RX workers, обмен с ядром и показ кадров по аудиочасам |
+| `call_video_encoder.h/cpp` | Кодер звонка: согласованный формат, смена битрейта с drain прежнего кодера и подтверждение настройки |
+| `call_video_decoder.h/cpp` | FFmpeg-декодер H.264/H.265 с выбором GPU/CPU и сохранением PTS при задержанном выходе |
+| `call_camera_capture.h/cpp` | Управление отдельным процессом камеры, каталог устройств/режимов и получение кадров |
+| `call_camera_worker.cpp` | Процесс Qt-захвата камеры: настройка устройства, отбор кадров и выдача пикселей через shared memory |
+| `call_camera_source.h` | Интерфейс backend камеры для процесса захвата и подстановки устройств в тестах |
+| `call_camera_protocol.h` | Локальный протокол управляющих команд, каталога устройств и FRAME/ACK процесса камеры |
+| `call_camera_buffer.h` | Владение shared-memory буфером пикселей между процессами захвата и GUI |
+| `call_camera_rate.h` | Временное отключение снижения FPS из-за автоэкспозиции V4L2 с восстановлением настройки камеры |
+| `call_video_cadence.h` | Отбор исходных кадров под заданный FPS без накопления ошибки дробного периода |
+| `call_video_capture_clock.h` | Привязка времени камеры к монотонным часам с коррекцией задержки первого callback |
+| `call_video_queue.h` | Ограниченная SPSC-очередь кадров между video workers без mutex и выделений памяти |
+| `call_video_wake.h` | Пробуждение video worker по событию или абсолютному монотонному deadline на POSIX/Windows |
+| `radio_audio_engine.h/cpp` | Desktop-контур рации: независимые захват/прослушивание, PTT/VAD и подключение к общему выходу |
+| `radiopanel.h/cpp` | Панель активной рации: выбор аудиоустройств, VAD, PTT и состояние передачи из ядра |
+| `radiosettingspage.h/cpp` | Настройки рации и запись глобальных сочетаний PTT |
+| `ptt_hotkey_manager.h/cpp` | Глобальный PTT: физические клавиши Windows/X11, системный портал Wayland |
+| `ptt_key_chord.h` | Хранение физических сочетаний с отдельными левыми/правыми модификаторами и запись одновременного нажатия |
+| `ptt_portal.h/cpp` | D-Bus-сессия GlobalShortcuts для Wayland, настройка сочетаний и обработка нажатий/отпусканий |
+| `media_blocks.h/cpp` | Чтение/сборка фрагментированных медиафайлов |
+| `imageviewer_window.h/cpp` | Окно просмотра изображений |
+| `videoplayer_engine.h/cpp` | Движок декодирования видео |
+| `videoplayer_window.h/cpp` | Окно просмотра видео |
+| `live_video_encoder.h/cpp` | Общий FFmpeg-кодер live-видео для звонка/трансляции, GPU/CPU, KEY-конфигурация и capture PTS |
+| `video_frame_image.h` | Выделение выровненного RGB-буфера FFmpeg и передача владения QImage без копирования |
+| `stream_publish_engine.h/cpp` | Публикация камеры/экрана и Opus: workers кодирования, локальный preview и завершение через общий publisher |
+| `stream_publish_window.h/cpp` | Настройки и управление трансляцией; закрытие окна сохраняет работающий engine |
+| `stream_portal_capture.h/cpp` | Захват экрана Wayland через ScreenCast portal/PipeWire, выбор монитора и режима курсора |
+| `stream_screen_cursor.h/cpp`, `stream_screen_cursor_win.cpp` | Наложение системного курсора на кадр выбранного экрана средствами X11/Windows |
+| `stream_video_modes.h` | Выбор размеров/FPS камеры и пропорционального масштабирования экрана для трансляции |
+| `stream_qp_control.h` | Плавная корректировка потолка QP по фактическому выходному видеобитрейту |
+| `stream_sources.h` | Разбор снимка активных источников канала из CHAT_EVT_STREAM_SOURCES |
+| `streamplayer_window.h/cpp` | Просмотр live-потока: отдельные audio/video workers, смешивание PCM и синхронизация по часам устройства |
+| `streamgrid_window.h/cpp` | Сетка трансляций канала и разворачивание плитки с сохранением плееров; своя плитка использует локальный preview |
+| `connmonitorwindow.h/cpp` | Окно мониторинга ETCP-соединений (standalone) |
 | `qrcode_utils.h/cpp` | Утилиты для QR-кодов |
 | `debug_ui.h` | Отладочный UI |
 
 ### Другие поддиректории
-- `db/` — SQLite3 amalgamation (`sqlite3.c/h`), `db_manager.h/cpp` (схема: nodes, node_addresses, channels, msg_<channel>, peers_<channel>, local_identity, accounts, ui_state)
-- `transport/` — интеграция с uTun: `gui_bridge.h/gui_bridge_impl.cpp` (Qt signal-based обмен), `chat_core.h/c` (управление), `chat_sync.h/c` (синхронизация), `db_sync_stub.c` (заглушка БД), `node_config.h/cpp`, `config_updater.h/cpp`, `utun_node.h/cpp`, `topo_node_sqlite.h/c`
+
+- `db/` — `db_manager.h/cpp`: доступ GUI к данным nodes, channels, msg_<channel>, peers_<channel> и состоянию интерфейса;
+  копия `db/sqlite3.c/h` не используется текущей CMake-целью, SQLite берётся из `lib/`
+- `transport/` — интеграция GUI с ядром; файлы перечислены ниже
+- `src/avatars/` — `avatarmanager.h/cpp`: загрузка/публикация аватаров участников через member_files, подписанные ссылки и очередь передач;
+  `avatarcache.h/cpp`: дисковый кеш, подготовка изображений и очистка; `avatarcrop.h/cpp`: выбор области;
+  `avatargallery.h/cpp`: просмотр аватаров пользователя; `groupavatarmanager.h/cpp`: подготовка и кеш подписанных аватарок каналов
+- `src/member_files/` — `browser.h/cpp`: браузер серверных файлов группы; `batch.h/cpp`: последовательные операции над файлами/деревьями,
+  фоновый локальный обход, загрузка/скачивание и отмена
+- `libutun/CMakeLists.txt` — состав и зависимости CMake-сборки общего ядра из `src/` и `lib/`
+- `CMakeLists.txt` — приложение vibechat, Qt-зависимости, ресурсы и цели GUI-тестов
+- `tests/` — проверки аудиотракта, PTT, видеозвонка, захвата камеры/экрана, трансляций, файлового браузера и GUI-компонентов
 - `resources/` — `bg.jpg`, `chatgui.qrc` (встраивает 5 TGS в бинарник), `animations/*.tgs`
+- `zxing-cpp/` — встроенная библиотека QR-кодов; `third_party/qhotkey/` — исходники QHotkey
+
+### Интеграция с ядром (transport/)
+
+| Файл | Назначение |
+|------|-----------|
+| `gui_bridge.h` / `gui_bridge_impl.cpp` | Команды GUI → uasync и события ядра → Qt-сигналы |
+| `utun_node.h/cpp` | Запуск и остановка ядра/чата в выделенном uasync-потоке |
+| `node_config.h/cpp` | Загрузка и сохранение конфигурации узла |
+| `config_updater.h/cpp` | Изменение настроек в конфиге |
+| `miniaudio_impl.c` | Реализация single-header miniaudio в отдельной единице трансляции |
+| `audio_diagnostics.h/cpp` | Диагностика этапов аудио и событий backend; записывает метаданные без PCM |
+| `stream_bridge.h/cpp` | Потокобезопасный мост к общим publisher/viewers: session IDs, каталог источников, запросы батчей и пробуждение workers |
 
 ### Система анимированных эмодзи
 
@@ -665,29 +982,81 @@ void lottie_animation_destroy(Lottie_Animation *anim);
 ---
 
 ## Key Documentation Files
-- `/doc/etcp_protocol.txt` - ETCP протокол (формат кодограмм, ACK, handshake, keepalive)
-- `/doc/etcp_arch.md` - ETCP архитектура
-- `/doc/etcp_config.txt` - Конфигурация ETCP
-- `/doc/etcp_router_arch.md` - ETCP роутер архитектура
-- `/doc/route_p2pconn.txt` - Route peer-to-peer соединения
-- `/src/route_bgp.txt` - BGP обмен маршрутами (дизайн-документ)
+
+- `doc/service_lifecycle.md` — ядро, независимые сервисы, владение ресурсами и остановка
+- `doc/node_snapshot.md` — подписанная запись узла, timestamp, SQLite и обновление NCD
+- `doc/etcp_protocol.txt` — ETCP: кодограммы, ACK, handshake, keepalive
+- `doc/etcp_arch.md` — архитектура ETCP
+- `doc/etcp_router_arch.md` — архитектура маршрутизатора
+- `src/chat/chat_join.h` — нормативный протокол добавления участника
+- `src/routing_layer/topo_group.h` — протокол групповой сессии и критерий READY
+- `tests/test_chat_join_e2e.c`, `tests/test_topo_recovery.c`, `tests/test_services.c` — проверки join, recovery и жизненного цикла
+- `doc/dm_arch.md`, `doc/chat_call_arch.md` — личные сообщения и звонки
+- `doc/call_video.txt` — видеотрек звонка: возможности кодеков, транспорт, битрейт, аудиочасы и показ кадров
+- `doc/stream.txt` — трансляции: RS-пачки, выдачи/relay, выбор поставщиков, медиакурсоры и платформенные плееры
+- `doc/stun_nat.md`, `doc/nat_detection.txt` — STUN-измерения и определение доступности рабочих UDP-сокетов
+- `doc/member_files.txt` — файловое хранилище участников, права, wire-команды и передачи
+- `doc/group_avatar.txt` — подписанная аватарка канала, хранение и репликация
+- `doc/encrypted_attachments.md` — контейнер группового вложения, запросы ключа и ручная выдача доступа
+- `doc/pm_invites.md`, `doc/message_links.md` — приглашения из личной беседы и ссылки внутри сообщений
+- `doc/proxy_protocol.md` — TCP/UDP/ICMP-прокси, управление окнами, half-close и проверки
+- `doc/lwip_nuances.md` — особенности адаптированного lwIP TCP-стека
+- `doc/linux_audio_recovery.md` — диагностика аудиотракта Linux, контракты владения и восстановление устройств
+- `src/media_delivery/file_transfer.h`, `src/dm/dm_media.h` — контракты передачи файлов и E2E-вложений DM
+- `src/call/call_audio.h`, `src/radio/radio_audio.h` — API общего голосового стека и правила потоков
+- `tools/chatcli_commands.txt` — команды headless CLI, в том числе DM, звонки и рация
+
+## Список задач по проекту
+
+Список задач — `doc/tasks.md` относительно корня репозитория (текущая работа, берём по одной задаче сверху).
+При нахождении попутных багов/fail/флаков тестов добавляем задачу (либо фиксим сразу если баг простой).
+Как сделали - помечаем [+] выполнено.
 
 ## chatgui-android (Android P2P Chat)
 
 **Расположение:** `tools/chatgui-android/`
 
-Android-версия чатгуи — P2P чат на STCP (TCP), UI на Jetpack Compose (Kotlin).
-C-ядро: `libutun_lite` (выборочная компиляция нужных .c из `lib/` и `src/`).
+Android-версия чатгуи — P2P чат на общем ETCP/STCP-ядре, UI на Jetpack Compose (Kotlin).
+C-библиотека `utun_lite` собирает `lib/` и `src/` по `libutun_lite/utun_sources.cmake`;
+`instance_lite` запускает ядро и чат в отдельном потоке, без UTUN-сервиса.
 Сборка: CMake (headless, Linux) + Gradle/NDK (Android APK).
-- 'fw' - собрать и обновить chatgui-android на телефоне (clean + сборка + install)
+- 'fw' - собрать и обновить chatgui-android на всех подключенных телефонах (clean + сборка + install)
 
 **Подробная инструкция:** `tools/chatgui-android/AGENTS.md`
 **Chat-модули:** все файлы из `src/chat/` (описаны выше в секции «Chat») компилируются в `libutun_lite`.
 
+### Основные файлы native-слоя
+
+Пути относительны к `tools/chatgui-android/`; UI и Android-сервисы описаны в локальном `AGENTS.md`.
+
+| Файл | Назначение |
+|------|-----------|
+| `libutun_lite/utun_sources.cmake` | Общий список исходников ядра для Android и headless |
+| `libutun_lite/CMakeLists.txt` | Сборка native-библиотеки и зависимостей |
+| `libutun_lite/instance_lite.c/h` | Запуск ядра/чата по INI-тексту и управление отдельным uasync-потоком |
+| `libutun_lite/utun_config_api.c/h` | Провайдер конфигурации: callbacks Kotlin и значения для native-слоя |
+| `libutun_lite/standby.c/h` | Фоновый duty-cycle, таймеры активных интервалов и ожидание пробуждения |
+| `libutun_lite/invite_link_c.c/h` | Старая копия C-кодека; .c исключён из UTUN_SOURCES, рабочий код — src/chat/invite_link.c/h |
+| `libutun_lite/attachment_sender.c/h` | Отправка файлов в канал через chat_msg_submit и канальный медиа-индекс |
+| `libutun_lite/photo_sender.c/h` | Отправка фотографий в канал с MIME-типом и размерами изображения |
+| `libutun_lite/video_sender.c/h` | Отправка видео через общий механизм подготовки вложений |
+| `libutun_lite/voice_recorder.c/h` | Накопление PCM записи, компрессор и отправка голоса через общий attachment_send |
+| `libutun_lite/stream_bridge.c/h` | Android-мост к publisher/viewers: session IDs, готовые access units/Opus и ограниченные батчи треков |
+| `jni_bridge/android_jni_bridge.c/h` | JNI-команды и callbacks между Kotlin и C-ядром, события и аудио API |
+| `jni_bridge/android_call_output_jni.c` | Вывод PCM звонка через AAudio с аппаратным тактированием и снимками позиции устройства |
+| `jni_bridge/android_call_video_jni.c` | JNI видеозвонка: capabilities/формат, обмен кадрами с call_video_port, playout и поворот YUV |
+| `jni_bridge/android_stream_jni.c` | JNI трансляций: publisher/viewer API, Opus/SoundTouch, готовый PCM и часы воспроизведения |
+| `jni_bridge/android_udp_log.c/h` | Потокобезопасный буфер UDP-логов с flush-таймером в потоке ядра |
+| `headless/headless_main.c` | Отдельный каркас control-loop; сам не запускает ядро/чат |
+| `headless/headless_control.c/h` | Каркас control-сокета; часть команд — заглушки, рабочий API — src/chat/chat_headless_control.c/h |
+| `app/src/main/cpp/CMakeLists.txt` | NDK-сборка библиотеки приложения |
+| `libutun_lite/tests/test_standby.c` | Проверка duty-cycle и жизненного цикла standby |
+
 ## Runtime
-- Запуск utun от root (для tun): `/home/vnc1/proj/utun3/utun_start.sh`
-- Стоп utun: `sudo /home/vnc1/proj/utun3/utun_stop1.sh`
-- Логи: `utun.log` (stdout), `utun_err.log` (stderr)
+- После autotools-сборки бинарник — `src/utun`. Запуск из корня с TUN: `sudo ./src/utun -f -c utun.cfg`.
+- Старый `utun_start.sh` ожидает `./utun` в корне. `utun_stop.sh` делает `killall -9 utun`, а не штатную остановку одного экземпляра.
+- `-f` оставляет процесс на переднем плане; остановка — SIGINT/SIGTERM. Пути конфигурации, PID и лога задаются через `-c`, `-p`, `-l`.
+- `utun_start.sh` перенаправляет stdout в `utun.log`, stderr в `utun_err.log`.
 - Тестовые логи: `tests/logs/`
 
 ## Git Conventions
@@ -698,19 +1067,19 @@ C-ядро: `libutun_lite` (выборочная компиляция нужны
 
 ## Quick Start for New Features
 1. Add new source file to `src/Makefile.am` under `utun_SOURCES`
-2. Add test file to `tests/Makefile.am` under `check_PROGRAMS`
+2. Add test target and its sources/dependencies to `tests/Makefile.am` under `check_PROGRAMS`
 3. Use existing patterns from similar modules
-5. Run `./check.sh` after changes
+4. Run `./check.sh` after changes
 5. Commit with descriptive message in appropriate language
 
 ## chatgui: отправка сообщений через xdotool
 
-1. **Запуск:** `setsid env DISPLAY=:1.0 QT_ACCESSIBILITY=1 ./chatgui & disown` (иначе SIGTERM убьёт процесс при таймауте bash)
-2. **Окно:** `0x4600006 "Chat"` (WM_CLASS "chatgui"), 900×600. Не путать с `0x4800001` (10×10, временное)
-3. **Фокус:** клик в область InputBar (x=400, y=570 относительно окна) перед вводом
-4. **Отправка:** `xdotool type --window WID "text"` + `xdotool key --window WID Return`
-5. **Проверка:** `sqlite3 chats.db "SELECT ... FROM msg_ch_GENERAL"` — сообщения в per-channel таблицах
-6. **MCP computer use** не видит chatgui — нужен `qt5-at-spi` bridge (нет в репах, ставить из исходников Qt)
+1. **Запуск:** из каталога сборки `setsid env QT_ACCESSIBILITY=1 ./vibechat & disown` с DISPLAY текущей X11-сессии.
+2. **Окно:** найти актуальный ID через `xdotool search --onlyvisible --class vibechat`; ID и размеры окна меняются между запусками.
+3. **Фокус:** активировать найденное окно и выбрать InputBar; координаты определять по текущему расположению интерфейса.
+4. **Отправка:** `xdotool type --window WID "text"` + `xdotool key --window WID Return`, где WID заменён найденным ID.
+5. **Проверка:** через `chats.db` из каталога `db_path`; таблицы сообщений называются `msg_<числовой channel_id>`.
+6. Доступность UI-автоматизации зависит от текущей X11/Wayland-сессии и настроек Qt accessibility; старые ID окон и DISPLAY не переносить.
 
 ---
 Эта инструкция имеет приоритет над инструкцией opencode.

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

LICENSING

@@ -0,0 +1,39 @@
+uTun licensing
+==============
+
+The original uTun source code, including its command-line, desktop and Android
+applications, is licensed under the GNU General Public License, version 3 only
+(GPL-3.0-only), with the additional permission for Wintun below.
+
+uTun is free software: you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation,
+version 3 of the License.
+
+uTun is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. See the GNU General Public License for more details.
+
+The complete GNU GPL version 3 is provided in LICENSE. Copyright remains with
+the respective authors. Third-party code and binaries retain their own licenses
+and copyright notices; see THIRD_PARTY_NOTICES and the notices in their files.
+
+Additional permission under GNU GPL version 3 section 7
+------------------------------------------------------
+
+If you modify this Program, or any covered work, by linking or combining it with
+Wintun (or a modified version of that library), containing parts covered by the
+terms of the Wintun Prebuilt Binaries License, the licensors of this Program
+grant you additional permission to convey the resulting work.
+
+This permission applies to the original uTun code. It does not change the
+license of Wintun or grant rights to modify its prebuilt binaries. Wintun must
+be used and distributed in accordance with its own license, through its
+Permitted API. No exception is granted for any other library.
+
+Distribution
+------------
+
+Include LICENSE, LICENSING and THIRD_PARTY_NOTICES with source and binary
+distributions. For GPL-covered binaries, also provide Corresponding Source
+as required by GNU GPL version 3; including these documents does not replace
+that requirement. Preserve upstream notices when updating bundled libraries.

Makefile.am

@@ -3,6 +3,22 @@
 # Order matters: lib -> src -> tests (tests depend on src objects)
 SUBDIRS = lib lib/libopus src tests
 
+# Полный комплект лицензий устанавливается вместе с бинарником и входит в make dist.
+licensedir = $(datadir)/licenses/utun
+dist_license_DATA = LICENSE LICENSING THIRD_PARTY_NOTICES
+
+EXTRA_DIST = readme.md \
+	doc/nat_detection.txt \
+	doc/stun_nat.md \
+	doc/node_snapshot.md \
+	tinycrypt/LICENSE \
+	tools/chatgui/zxing-cpp/LICENSE \
+	tools/chatgui/zxing-cpp/core/src/libzueci/LICENSE \
+	tools/chatgui/third_party/qhotkey/LICENSE \
+	tools/chatgui-android/app/src/main/cpp/onnxruntime/LICENSE \
+	tools/chatgui-android/app/src/main/cpp/onnxruntime/ThirdPartyNotices.txt \
+	tools/chatgui-android/app/src/main/cpp/openssl/LICENSE.txt
+
 # Clean build directory
 clean-local:
 	-rm -rf build/

PLAN_etcp_router_reset_id.md

@@ -0,0 +1,149 @@
+> Исторический документ. Актуальная реализация и wire-формат описаны в [ETCP Router](src/routing_layer/etcp_router_doc.md).
+
+# План: эпоха (reset_id) для ETCP Router
+
+Аналог фикса `reset_id` из ETCP (см. `61c572c`), применённый к сервисному слою
+маршрутизации `etcp_router` (src/routing_layer/etcp_router.c).
+
+## 1. Контекст
+
+`etcp_router` — «упрощённый TCP поверх ETCP»: своя seq-нумерация (`tx_seq`/`rx_seq`),
+reorder (`recv_q`), inflight-контроль (`inflight_q`), ретрансмиты, START/RST handshake.
+
+Текущий механизм детекции рестарта пира:
+
+- `SVC_ROUTE_HDR.flags & ROUTER_FLAG_START` — флаг на первом data-пакете сеанса
+  (`seq==0 && !start_sent && pl_len>0`, `etcp_router.c:207`).
+- `router_check_peer_restart` (`etcp_router.c:1055`) — если пришёл START на уже
+  синхронизированное соединение (`peer_sync_done==1`), то это рестарт пира;
+  **дедуп ретрансмитов** — побайтовое сравнение с `last_start_dgram`
+  (`etcp_router.c:1063`). Совпало → это ретрансмит (не рестарт). Не совпало →
+  `etcp_router_conn_restart` (полный сброс + `sess_id++`).
+- `ROUTER_FLAG_RST` + `router_restart_send` (`etcp_router.c:285`) — сброс только
+  TX-стороны; повторные RST гасятся через `send_restart_pending`.
+- `sess_id` (`etcp_router.h:121`) — **локальный счётчик переустановок, на wire
+  не пишется**. Используется только в `DEBUG_INFO`.
+
+## 2. Проблема (аналог ETCP seq-коллизии)
+
+Дедуп рестарта строится на **побайтовой идентичности** `last_start_dgram`. Это тот
+же класс хрупкости, что убрали в ETCP:
+
+1. **Байт-идентичный START** может быть и ретрансмитом, и (теоретически) новым
+   сеансом — если у нового START совпали `seq==0`, `svc_id`, `timestamp` (16-битные
+   часы 0.1ms заворачиваются каждые ~6.5 сек) и payload. Тогда рестарт **не
+   детектится**.
+2. Если рестарт не распознан: у пира `tx_seq` ушёл в 0, а у нас `rx_seq` остался
+   «высоким». В `router_handle_data_packet` (`etcp_router.c:1104`) ветка
+   `(rx_seq - seq) > 0` / `queue_find_data_by_index` считает пакеты новой сессии
+   **дубликатами** → молчаливый `c_dup_dropped` + пере-ACK (как `RX dup` в ETCP) →
+   потеря сервисных пакетов.
+3. `sess_id` не на wire → пир вообще не может отличить «мы перезапустились» от
+   «продолжаем сеанс» иначе как по байтам START.
+
+То есть нужен надёжный маркер **эпохи сеанса** на wire — аналог `reset_id`.
+
+## 3. Решение (аналог reset_id)
+
+Семантика та же, что в ETCP:
+
+- эпоха генерится **один раз** при создании `ETCP_ROUTER_CONN`;
+- меняется **только** при (фатальном) рестарте соединения;
+- при приёме START/RST с **другой** эпохой → рестарт (adopt);
+- **первая** увиденная эпоха принимается без рестарта (свежие при создании);
+- дедуп ретрансмитов START — по эпохе, а не по байтам.
+
+Два варианта источника эпохи:
+
+- **(A) Перенести `sess_id` на wire** — он уже есть как `uint32` счётчик
+  (0 при создании, `++` при рестарте). Минимально инвазивно.
+- **(B) Новый `reset_id` (uint64, случайный)** — симметрично ETCP; случайный
+  надёжнее счётчика (нет wrap-around и предсказуемости), но чуть больше поле.
+
+Рекомендация — **(A)** как минимальный шаг (поле уже есть), при желании апгрейд
+до (B).
+
+### Разрыв цикла (master/slave)
+
+Как и в ETCP, симметричное «увидел другую эпоху → рестарт» зацикливается при
+одновременном рестарте обеих сторон (A++ → B++ → A видит B → A++ → …).
+
+Ти-брейкер по `node_id` (как в ETCP):
+
+- на приёме START/RST с чужой эпохой:
+  - **master** (меньший `node_id`) — держит свою эпоху, шлёт RST пиру;
+  - **slave** (больший `node_id`) — принимает эпоху пира и рестартится.
+
+Существующие предохранители (`send_restart_pending`, `router_check_peer_restart`
+на стороне master) сохраняются.
+
+## 4. Wire-формат
+
+`SVC_ROUTE_HDR` (`etcp_router.h:26`) сейчас 33 байта:
+
+```
+cmd(1) group_id(8) dst(8) src(8) seq(4) svc_id(1) flags(1) timestamp(2)
+```
+
+Добавить поле эпохи (только START/RST, в обычных data/ACK — 0):
+
+- вариант (A): `uint32_t sess_id` → заголовок 33→37 байт (упакован);
+- вариант (B): `uint8_t reset_id[8]` → 33→41 байт.
+
+Заполняется в `router_build_packet` (START) и `router_send_rst`; читается в
+`router_check_peer_restart` / обработчике RST.
+
+## 5. Шаги реализации
+
+Файлы: `src/routing_layer/etcp_router.h`, `src/routing_layer/etcp_router.c`,
+(опц.) `tests/`.
+
+1. **Поле в заголовке**: добавить `sess_id`/`reset_id` в `struct SVC_ROUTE_HDR`;
+   обновить `SVC_ROUTE_HDR_SIZE`.
+2. **Локальное состояние** (`struct ETCP_ROUTER_CONN`):
+   - `uint32_t sess_id` (уже есть) — оставить как «моя эпоха»;
+   - добавить `uint32_t peer_sess_id` — последняя увиденная эпоха пира.
+   - `router_conn_reset` (`etcp_router.c:380`) НЕ сбрасывает `sess_id`
+     (комментарий на :379 уже это гарантирует).
+3. **Запись эпохи**:
+   - `router_build_packet` (`:193`) — при `ROUTER_FLAG_START` писать `sess_id`;
+   - `router_send_rst` (`:251`) — писать `sess_id`.
+4. **Детект рестарта по эпохе** — переписать `router_check_peer_restart` (`:1055`):
+   - если `peer_sess_id==0` → первая эпоха, принять без рестарта (сохранить);
+   - если `hdr->sess_id == peer_sess_id` → ретрансмит (не рестарт);
+   - если отличается → master/slave: slave → `etcp_router_conn_restart` + adopt;
+     master → держать свою, при необходимости RST.
+   - `last_start_dgram`-байт-дедуп заменить на это сравнение (поле можно удалить).
+5. **RST-обработчик** (`:1151`) — при RST также сверять `sess_id` (дедуп RST по
+   эпохе вместо/в дополнение к `send_restart_pending`).
+6. **Инициализация** — `peer_sess_id = 0` в `router_conn_reset`/`etcp_router_conn_get`.
+
+## 6. Тест
+
+`tests/test_etcp_router_*` (существующие `test_etcp_router`, `test_etcp_router_reconnect`,
+`test_etcp_router_unit`) — прогнать после правки заголовка (37/41 байт).
+
+Добавить (по возможности) регрессию, аналогичную `test_etcp_seq_collision`:
+
+- два инстанса, роутер-коннект, отправка N пакетов;
+- принудительный рестарт одной стороны (смена эпохи);
+- assert: пакеты новой эпохи доставлены (не `c_dup_dropped`), обе стороны сходятся
+  к одной эпохе.
+
+## 7. Решения (зафиксировано)
+
+1. **Вариант (B)** — `uint64_t reset_id`, случайный (`random_bytes`). Причина: вариант (A)
+   `sess_id` стартует с 0 и конфликтует с сентинелом «эпоха не задана». На wire — native
+   order (как остальные uint64-поля заголовка, SVC_ROUTE не использует htobe*).
+2. **master/slave по node_id** — нужен: `etcp_router_conn_restart` делает полный
+   двунаправленный сброс, без ти-брейкера симметричный рестарт зациклится. master
+   (меньший node_id) держит эпоху и шлёт RST; slave принимает и ресетится.
+3. **route_crypto** — совместим: заголовок не шифруется (только payload), подписывается
+   только в SIGN-режиме; `SVC_ROUTE_HDR_SIZE = sizeof(...)` авто-адаптируется. START
+   идёт через `route_crypto_encode`, RST/ACK/CLOSE — plain header-only.
+
+## 8. Статус
+
+Реализовано и проверено: `etcp_router.h/.c` + `tests/test_etcp_router_unit.c`.
+Сборка `make clean && make` без ошибок; `./check.sh` → 74 passed / 0 failed / 1 skipped;
+`test_etcp_router_unit` 34/34, `test_etcp_router` и `test_etcp_router_reconnect` — PASS.

USER_MANUAL.md

@@ -153,10 +153,14 @@ general=info                            # общая информация
 ```ini
 [firewall]
 allow=all                               # разрешить всё (bypass)
-allow=192.168.1.0/24                    # разрешить подсеть
+allow=192.168.1.10                      # разрешить весь IP
 allow=10.0.0.1:80                       # разрешить конкретный IP:порт
 ```
 
+Фильтр основного TUN проверяет IP и TCP/UDP-порт назначения одинаково в обоих направлениях.
+Без разрешений весь трафик этого интерфейса запрещён; ответы требуют отдельных разрешений.
+CIDR-подсети не поддерживаются. Ошибочное правило отменяет загрузку нового конфига.
+
 ### 3.7. `[nat]` — EIM NAT
 
 ```ini
@@ -553,11 +557,13 @@ dump=trace
 ```ini
 [firewall]
 allow=all                               # всё разрешено
-allow=10.0.0.0/8                        # разрешить подсеть
+allow=10.0.0.5                          # разрешить весь IP
 allow=192.168.1.5:22                    # разрешить IP:порт
 ```
 
-По умолчанию без секции `[firewall]` — фильтрация выключена.
+Без секции `[firewall]` весь входящий и исходящий трафик основного TUN запрещён.
+`allow=IP` и `allow=IP:0` разрешают все протоколы IP; `allow=IP:port` — TCP/UDP указанного порта.
+Для фрагментов IPv4 нужен весь IP либо `allow=all`. NAT и прокси используют отдельные TUN интерфейсы.
 
 ### 7.3. Проброс портов
 

build.bat

@@ -1,4 +1,5 @@
 @echo off
+setlocal EnableExtensions
 echo uTun Build Script for MSYS2 UCRT64
 echo.
 
@@ -10,11 +11,11 @@ rem export https_proxy="http://192.168.29.1:9999"
 
 
 REM Default MSYS2 path
-set MSYS2_PATH=C:\msys64
+set "MSYS2_PATH=C:\msys64"
 
 REM Use environment variable if set
-if not "%MSYS2_ROOT%"=="" set MSYS2_PATH=%MSYS2_ROOT%
-if not "%MSYS2%"=="" set MSYS2_PATH=%MSYS2%
+if not "%MSYS2_ROOT%"=="" set "MSYS2_PATH=%MSYS2_ROOT%"
+if not "%MSYS2%"=="" set "MSYS2_PATH=%MSYS2%"
 
 REM Check if msys2_shell.cmd exists
 if not exist "%MSYS2_PATH%\msys2_shell.cmd" (
@@ -22,10 +23,15 @@ if not exist "%MSYS2_PATH%\msys2_shell.cmd" (
     echo Please install MSYS2 from https://www.msys2.org/
     echo or set MSYS2_ROOT environment variable.
     pause
+    popd
     exit /b 1
 )
 
 REM Launch MSYS2 UCRT64 shell and run build script
 echo Starting MSYS2 UCRT64 environment...
 rem call "%MSYS2_PATH%\msys2_shell.cmd" -ucrt64 -here -c "bash build.sh > build_win.log 2>&1"
-call "%MSYS2_PATH%\msys2_shell.cmd" -ucrt64 -here -defterm -no-start -c "set -o pipefail; bash build.sh 2>&1 | tee build_win.log"
+call "%MSYS2_PATH%\msys2_shell.cmd" -ucrt64 -here -defterm -no-start -c "set -o pipefail; bash build.sh --installer 2>&1 | tee build_win.log"
+set "BUILD_RESULT=%ERRORLEVEL%"
+if not "%BUILD_RESULT%"=="0" echo [ERROR] Build or installer failed. See build_win.log.
+popd
+endlocal & exit /b %BUILD_RESULT%

build.sh

@@ -1,197 +1,221 @@
-#!/bin/bash
-# Build script for uTun (supports both Linux and Windows/MSYS2)
-# Usage: ./build.sh [options]
-# Options:
-#   -h, --help      Show this help
-#   --clean         Clean before build
-#   --full          Full rebuild (autoreconf + configure + make)
-#   --asan          Build with AddressSanitizer (debug)
-#   --hardened      Build with compiler security hardening flags
-#   -j[N]           Build with N parallel jobs (default: 4)
+#!/usr/bin/env bash
+# Инкрементальная сборка Linux, FreeBSD и Windows/MSYS2; флаги задаются через configure.
+set -euo pipefail
+cd "$(dirname "$0")"
 
-set -e  # Exit on error
-
-# Detect platform
-if [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]] || [[ -n "$MSYSTEM" ]]; then
-    IS_WINDOWS=1
-    echo "Detected Windows/MSYS2 environment"
-else
-    IS_WINDOWS=0
-    echo "Detected Linux environment"
-fi
-
-# Parse arguments
+MODE=normal
 CLEAN=0
-FULL_REBUILD=0
-USE_ASAN=0
-USE_HARDENED=0
-JOBS="-j4"
-MAKE_ARGS=""
-HARDEN_FLAGS=""
+FULL=0
+BUILD_GUI=1
+BUILD_INSTALLER=0
+JOBS=4
+MAKE_ARGS=()
+MAKE_SETTINGS=()
+STATE=.utun-build-state
 
 while [[ $# -gt 0 ]]; do
-    case $1 in
+    case "$1" in
         -h|--help)
-            echo "Usage: ./build.sh [options]"
-            echo "Options:"
-            echo "  -h, --help      Show this help"
-            echo "  --clean         Clean before build"
-            echo "  --full          Full rebuild (autoreconf + configure + make)"
-            echo "  --asan          Build with AddressSanitizer"
-            echo "  --hardened      Build with compiler security hardening flags"
-            echo "  -j[N]           Build with N parallel jobs (default: 4)"
-            exit 0
-            ;;
-        --clean)
-            CLEAN=1
-            shift
-            ;;
-        --full)
-            FULL_REBUILD=1
-            shift
-            ;;
-        --asan)
-            USE_ASAN=1
-            shift
-            ;;
-        --hardened)
-            USE_HARDENED=1
-            shift
-            ;;    
-        -j*)
-            JOBS="$1"
-            shift
-            ;;
-        *)
-            MAKE_ARGS="$MAKE_ARGS $1"
-            shift
-            ;;
-    esac
-done
-
-# Check required tools
-if ! command -v gcc &> /dev/null; then
-    echo "Error: gcc not found."
-    if [ "$IS_WINDOWS" -eq 1 ]; then
-        echo "Please install: pacman -S mingw-w64-ucrt-x86_64-toolchain"
-    else
-        echo "Please install build-essential or gcc"
-    fi
-    exit 1
-fi
-
-# Clean if requested
-if [ "$CLEAN" -eq 1 ]; then
-    echo "Cleaning build..."
-    make clean 2>/dev/null || true
-fi
-
-# Full rebuild: regenerate build system
-if [ "$FULL_REBUILD" -eq 1 ]; then
-    echo ""
-    echo "======================================"
-    echo "FULL REBUILD: autoreconf"
-    echo "======================================"
-    echo ""
-
-    # Check for autotools
-    if ! command -v autoreconf &> /dev/null; then
-        echo "Error: autoreconf not found."
-        if [ "$IS_WINDOWS" -eq 1 ]; then
-            echo "Install autotools: pacman -S mingw-w64-ucrt-x86_64-autotools"
-        else
-            echo "Install autotools: apt-get install autoconf automake libtool"
-        fi
-        exit 1
-    fi
-
-    # Clean generated files
-    echo "Cleaning generated files..."
-    make distclean 2>/dev/null || true
-    rm -rf build/
-
-    # Regenerate build system (root Makefile is hand-written, not generated)
-    echo ""
-    echo "Running autoreconf -fi..."
-    autoreconf -fi 2>&1 | tee autoreconf.log
-
-    echo ""
-    echo "======================================"
-    echo "Build system regenerated successfully"
-    echo "======================================"
-    echo ""
-else
-    # Quick/incremental build: generate configure if needed
-    if [ ! -f ./configure ]; then
-        echo "Configure script not found. Generating..."
-        if ! command -v autoreconf &> /dev/null; then
-            echo "Error: autoreconf not found."
-            if [ "$IS_WINDOWS" -eq 1 ]; then
-                echo "Install autotools: pacman -S mingw-w64-ucrt-x86_64-autotools"
-            else
-                echo "Install autotools: apt-get install autoconf automake libtool"
+            echo "Usage: ./build.sh [--clean] [--full] [--asan|--hardened] [--no-gui] [--installer] [-jN] [make arguments]"
+            echo "  --clean     Rebuild objects without forcing configure"
+            echo "  --full      Regenerate, configure and rebuild everything"
+            echo "  --asan      AddressSanitizer; skip tests"
+            echo "  --hardened  Enable compiler security hardening"
+            echo "  --no-gui    Skip the separately configured ChatGUI"
+            echo "  --installer Build Windows ChatGUI in Release and create its Inno Setup installer"
+            echo "  -jN, -j N   Parallel jobs (default: 4)"
+            echo "  CC/CFLAGS/CPPFLAGS/LDFLAGS/LIBS assignments are passed to configure"
+            exit 0 ;;
+        --clean) CLEAN=1 ;;
+        --full) FULL=1 ;;
+        --no-gui) BUILD_GUI=0 ;;
+        --installer) BUILD_INSTALLER=1 ;;
+        --asan|--hardened)
+            selected_mode=${1#--}
+            if [[ "$MODE" != normal && "$MODE" != "$selected_mode" ]]; then
+                echo "ERROR: --asan and --hardened cannot be combined" >&2; exit 1
             fi
-            exit 1
+            MODE=$selected_mode ;;
+        -j)
+            [[ $# -gt 1 ]] || { echo "ERROR: -j requires a positive job count" >&2; exit 1; }
+            shift; JOBS=$1 ;;
+        -j*) JOBS=${1#-j} ;;
+        CC=*|CFLAGS=*|CPPFLAGS=*|LDFLAGS=*|LIBS=*) export "$1" ;;
+        CC+=*|CFLAGS+=*|CPPFLAGS+=*|LDFLAGS+=*|LIBS+=*)
+            echo "ERROR: use NAME=value for configure flags; append assignments are not supported" >&2; exit 1 ;;
+        *)
+            MAKE_ARGS+=("$1")
+            [[ "$1" != *=* ]] || MAKE_SETTINGS+=("$1") ;;
+    esac
+    shift
+done
+[[ "$JOBS" =~ ^[1-9][0-9]*$ ]] || { echo "ERROR: invalid job count: $JOBS" >&2; exit 1; }
+if [[ "$BUILD_INSTALLER" = 1 ]]; then
+    [[ "$BUILD_GUI" = 1 && "$MODE" = normal ]] || { echo "ERROR: --installer requires GUI and normal build mode" >&2; exit 1; }
+    bash tools/chatgui/package_win.sh --check
+fi
+
+PLATFORM=$(uname -s)
+MAKE_TOOL=${MAKE:-make}
+if [[ "$PLATFORM" = FreeBSD ]]; then
+    MAKE_TOOL=${MAKE:-gmake}
+    export CC="${CC:-clang}"
+fi
+MAKE_PATH=$(command -v "$MAKE_TOOL") || { echo "ERROR: GNU make not found: $MAKE_TOOL (FreeBSD: pkg install gmake)" >&2; exit 1; }
+MAKE_ID=$("$MAKE_TOOL" --version) || { echo "ERROR: GNU make is required; use MAKE=gmake on BSD" >&2; exit 1; }
+[[ "$MAKE_ID" = *'GNU Make'* ]] || { echo "ERROR: GNU make is required; use MAKE=gmake on BSD" >&2; exit 1; }
+export MAKE="$MAKE_TOOL"
+if command -v sha256sum >/dev/null; then
+    HASH_COMMAND=(sha256sum)
+elif command -v sha256 >/dev/null; then
+    HASH_COMMAND=(sha256 -r)
+elif command -v shasum >/dev/null; then
+    HASH_COMMAND=(shasum -a 256)
+else
+    echo "ERROR: SHA-256 utility not found: sha256sum, sha256 or shasum is required" >&2; exit 1
+fi
+read -r -a COMPILER <<< "${CC:-gcc}"
+COMPILER_PATH=$(command -v "${COMPILER[0]}") || { echo "ERROR: compiler not found: ${CC:-gcc}" >&2; exit 1; }
+COMPILER_ID=$("${COMPILER[@]}" --version) || { echo "ERROR: cannot identify compiler: ${CC:-gcc}" >&2; exit 1; }
+
+# Хеши учитывают содержимое и имена файлов, включая добавление/удаление макросов.
+hash_files() {
+    local result
+    result=$({ printf '%s\0' "$@"; "${HASH_COMMAND[@]}" "$@"; } | "${HASH_COMMAND[@]}")
+    printf '%s\n' "${result%% *}"
+}
+
+BUILD_DIRS=(lib lib/libopus src tests)
+AUTOTOOLS_INPUTS=(configure.ac Makefile.am lib/Makefile.am lib/libopus/Makefile.am src/Makefile.am tests/Makefile.am)
+AUTOTOOLS_OUTPUTS=(configure aclocal.m4 config.h.in Makefile.in lib/Makefile.in lib/libopus/Makefile.in src/Makefile.in tests/Makefile.in)
+CONFIG_OUTPUTS=(config.status config.h Makefile lib/Makefile lib/libopus/Makefile src/Makefile tests/Makefile)
+shopt -s globstar nullglob
+for macro in m4/**/*.m4; do AUTOTOOLS_INPUTS+=("$macro"); done
+GENERATION_INPUT=$(hash_files "${AUTOTOOLS_INPUTS[@]}")
+GENERATION_OUTPUT=missing
+CONFIG_OUTPUT=missing
+missing_generation=0
+missing_configuration=0
+for file in "${AUTOTOOLS_OUTPUTS[@]}"; do [[ -f "$file" ]] || missing_generation=1; done
+for file in "${CONFIG_OUTPUTS[@]}"; do [[ -f "$file" ]] || missing_configuration=1; done
+if [[ "$missing_generation" = 0 ]]; then GENERATION_OUTPUT=$(hash_files "${AUTOTOOLS_OUTPUTS[@]}"); fi
+if [[ "$missing_configuration" = 0 ]]; then CONFIG_OUTPUT=$(hash_files "${CONFIG_OUTPUTS[@]}"); fi
+
+FFMPEG_PACKAGES=(libavformat libavcodec libavutil libswscale libswresample)
+FFMPEG_OPTION=--without-ffmpeg
+FFMPEG_ID=unavailable
+FFMPEG_CFLAGS=""
+FFMPEG_LDFLAGS=""
+if command -v pkg-config >/dev/null && pkg-config --exists "${FFMPEG_PACKAGES[@]}"; then
+    FFMPEG_OPTION=--with-ffmpeg
+    FFMPEG_ID=$(pkg-config --modversion "${FFMPEG_PACKAGES[@]}")
+    FFMPEG_CFLAGS=$(pkg-config --cflags "${FFMPEG_PACKAGES[@]}")
+    FFMPEG_LDFLAGS=$(pkg-config --libs-only-L "${FFMPEG_PACKAGES[@]}")
+fi
+request_sum=$({
+    printf '%s\0' "$MODE" "$PLATFORM" "${MSYSTEM:-}" "${MSYSTEM_PREFIX:-}" "${CC:-gcc}" "$COMPILER_PATH" "$COMPILER_ID"
+    printf '%s\0' "$MAKE_PATH" "$MAKE_ID" "${HASH_COMMAND[@]}"
+    printf '%s\0' "${CFLAGS+x}" "${CFLAGS-}" "${CPPFLAGS+x}" "${CPPFLAGS-}" "${LDFLAGS+x}" "${LDFLAGS-}"
+    printf '%s\0' "${LIBS+x}" "${LIBS-}" "${MAKEFLAGS-}" "${DEBUG_FLAGS+x}" "${DEBUG_FLAGS-}"
+    printf '%s\0' "$FFMPEG_OPTION" "$FFMPEG_ID" "$FFMPEG_CFLAGS" "$FFMPEG_LDFLAGS"
+    printf '%s\0' "${MAKE_SETTINGS[@]}"
+    hash_files build.sh
+} | "${HASH_COMMAND[@]}")
+CONFIG_REQUEST=${request_sum%% *}
+
+OLD_GENERATION_INPUT=""; OLD_GENERATION_OUTPUT=""; OLD_CONFIG_REQUEST=""; OLD_CONFIG_OUTPUT=""
+if [[ -f "$STATE" ]]; then
+    if ! {
+        read -r OLD_GENERATION_INPUT; read -r OLD_GENERATION_OUTPUT
+        read -r OLD_CONFIG_REQUEST; read -r OLD_CONFIG_OUTPUT
+    } < "$STATE"; then
+        echo "WARN: incomplete build state; adopting the build with a clean rebuild"
+        OLD_GENERATION_INPUT=""; OLD_GENERATION_OUTPUT=""; OLD_CONFIG_REQUEST=""; OLD_CONFIG_OUTPUT=""
+    fi
+fi
+
+REGENERATE=0
+RECONFIGURE=0
+if [[ "$FULL" = 1 || "$GENERATION_INPUT" != "$OLD_GENERATION_INPUT" || "$GENERATION_OUTPUT" != "$OLD_GENERATION_OUTPUT" ]]; then
+    echo "INFO: regenerating Autotools: full=$FULL"
+    if [[ "$GENERATION_INPUT" != "$OLD_GENERATION_INPUT" ]]; then echo "INFO: Autotools descriptions changed or unrecorded"; fi
+    if [[ "$GENERATION_OUTPUT" != "$OLD_GENERATION_OUTPUT" ]]; then echo "INFO: generated Autotools files changed or missing"; fi
+    command -v autoreconf >/dev/null || { echo "ERROR: autoreconf is required to regenerate the build" >&2; exit 1; }
+    mkdir -p m4
+    autoreconf -fi 2>&1 | tee autoreconf.log || { echo "ERROR: autoreconf failed; see autoreconf.log" >&2; exit 1; }
+    REGENERATE=1
+fi
+if [[ "$REGENERATE" = 1 || "$CONFIG_REQUEST" != "$OLD_CONFIG_REQUEST" || "$CONFIG_OUTPUT" != "$OLD_CONFIG_OUTPUT" ]]; then
+    echo "INFO: configuring: mode=$MODE regenerated=$REGENERATE"
+    if [[ "$CONFIG_REQUEST" != "$OLD_CONFIG_REQUEST" ]]; then echo "INFO: compiler, flags or optional dependencies changed or unrecorded"; fi
+    if [[ "$CONFIG_OUTPUT" != "$OLD_CONFIG_OUTPUT" ]]; then echo "INFO: configuration files changed or missing"; fi
+    CONFIG_ARGS=("$FFMPEG_OPTION" --disable-hardening)
+    if [[ "$MODE" = asan ]]; then
+        export CFLAGS="${CFLAGS-} -g -Og -fsanitize=address -fno-omit-frame-pointer -fno-pie"
+        export LDFLAGS="${LDFLAGS-} -fsanitize=address -no-pie"
+        if [[ "$PLATFORM" = FreeBSD ]]; then export ASAN_OPTIONS="${ASAN_OPTIONS:-detect_leaks=0}"; fi
+    elif [[ "$MODE" = hardened ]]; then
+        CONFIG_ARGS+=(--enable-hardening)
+    fi
+    if [[ "$FFMPEG_OPTION" = --with-ffmpeg ]]; then
+        export CPPFLAGS="${CPPFLAGS-} $FFMPEG_CFLAGS"
+        export LDFLAGS="${LDFLAGS-} $FFMPEG_LDFLAGS"
+    fi
+    ./configure "${CONFIG_ARGS[@]}" 2>&1 | tee configure.log || { echo "ERROR: configure failed; see configure.log" >&2; exit 1; }
+    RECONFIGURE=1
+fi
+
+# Проверяем только зависимости объектов, перечисленных Automake; посторонние сборки не затрагиваем.
+MISSING_DEPS=0
+for directory in "${BUILD_DIRS[@]}"; do
+    while read -r keyword depfile marker; do
+        [[ "$keyword" = include && "$marker" = '# am--include-marker' && "$depfile" = *.Po ]] || continue
+        depfile=${depfile//\$\(DEPDIR\)/.deps}
+        object=${depfile/.deps\//}
+        object=${object%.Po}
+        [[ -f "$directory/$object.o" || -f "$directory/$object.obj" ]] || continue
+        dependency_line=""
+        if [[ -s "$directory/$depfile" ]]; then IFS= read -r dependency_line < "$directory/$depfile" || true; fi
+        if [[ "$dependency_line" != *:* ]]; then
+            echo "WARN: missing or empty dependencies for $directory/$object: $directory/$depfile"
+            MISSING_DEPS=1
+            break
         fi
-        autoreconf -fiv
-    fi
+    done < "$directory/Makefile"
+done
+if [[ "$RECONFIGURE" = 1 || "$CLEAN" = 1 || "$MISSING_DEPS" = 1 ]]; then
+    echo "INFO: cleaning objects: reconfigured=$RECONFIGURE requested=$CLEAN missing_dependencies=$MISSING_DEPS"
+    "$MAKE_TOOL" clean 2>&1 | tee build.log || { echo "ERROR: clean failed; see build.log" >&2; exit 1; }
+else
+    echo "INFO: configuration unchanged; incremental build (mode=$MODE)"
+    : > build.log
 fi
 
-# Generate Makefiles if needed
-if [ ! -f Makefile ]; then
-    echo ""
-    echo "Running ./configure..."
-    if [ "$USE_ASAN" -eq 1 ]; then
-        ./configure CFLAGS="-g -Og -fsanitize=address -fno-omit-frame-pointer -fno-pie" LDFLAGS="-no-pie"
-    elif [ "$USE_HARDENED" -eq 1 ]; then
-        ./configure --enable-hardening
+echo "INFO: compiling: mode=$MODE jobs=$JOBS"
+if [[ "$MODE" = asan ]]; then
+    echo "INFO: AddressSanitizer: building lib, Opus and src; skipping tests"
+    MAKE_ARGS+=("SUBDIRS=lib lib/libopus src")
+fi
+"$MAKE_TOOL" "-j$JOBS" "${MAKE_ARGS[@]}" 2>&1 | tee -a build.log || { echo "ERROR: build failed; see build.log" >&2; exit 1; }
+
+# Состояние обновляется после успешной сборки ядра; ошибка GUI не инвалидирует готовые объекты.
+GENERATION_OUTPUT=$(hash_files "${AUTOTOOLS_OUTPUTS[@]}")
+CONFIG_OUTPUT=$(hash_files "${CONFIG_OUTPUTS[@]}")
+state_tmp="$STATE.tmp.$$"
+trap 'rm -f "$state_tmp"' EXIT
+printf '%s\n' "$GENERATION_INPUT" "$GENERATION_OUTPUT" "$CONFIG_REQUEST" "$CONFIG_OUTPUT" > "$state_tmp"
+mv -f "$state_tmp" "$STATE"
+
+if [[ "$BUILD_GUI" = 1 && ( "$BUILD_INSTALLER" = 1 || -f tools/chatgui/build/CMakeCache.txt ) ]]; then
+    command -v cmake >/dev/null || { echo "ERROR: ChatGUI exists but cmake is not available" >&2; exit 1; }
+    echo "INFO: building ChatGUI with its CMake configuration: jobs=$JOBS"
+    if [[ "${MSYSTEM:-}" = UCRT64 ]]; then
+        GUI_ARGS=("-j$JOBS")
+        [[ "$BUILD_INSTALLER" != 1 ]] || GUI_ARGS+=(--installer)
+        (cd tools/chatgui && bash build.sh "${GUI_ARGS[@]}") || { echo "ERROR: ChatGUI build failed" >&2; exit 1; }
     else
-        ./configure
+        cmake --build tools/chatgui/build --parallel "$JOBS" || { echo "ERROR: ChatGUI build failed" >&2; exit 1; }
     fi
 fi
-
-# Build (all .o files go to build/ directory, binary copied to project root)
-echo ""
-echo "Compiling with $JOBS..."
-BUILD_SUCCESS=0
-if [ "$USE_ASAN" -eq 1 ]; then
-    echo "(AddressSanitizer enabled — lib/ and src/ only, skipping tests)"
-    AF="-fsanitize=address -fno-omit-frame-pointer -g -Og"
-    AL="-fsanitize=address"
-    (cd lib && make clean $JOBS $MAKE_ARGS 2>&1 && make "CFLAGS+=$AF" "LDFLAGS+=$AL" $JOBS $MAKE_ARGS 2>&1) || { echo "lib build failed"; exit 1; }
-    (cd src && make clean $JOBS $MAKE_ARGS 2>&1 && make "CFLAGS+=$AF" "LDFLAGS+=$AL" $JOBS $MAKE_ARGS 2>&1) || { echo "src build failed"; exit 1; }
-    BUILD_SUCCESS=1
-elif [ "$USE_HARDENED" -eq 1 ]; then
-    echo "(Hardening flags enabled)"
-    HF="-D_FORTIFY_SOURCE=2 -fstack-protector-strong -fstack-clash-protection -Wformat=2 -Wformat-overflow=2 -fPIE"
-    HL="-Wl,-z,relro -Wl,-z,now -pie"
-    (cd lib && make clean $JOBS $MAKE_ARGS 2>&1 && make "CFLAGS+=$HF" "LDFLAGS+=$HL" $JOBS $MAKE_ARGS 2>&1) || { echo "lib build failed"; exit 1; }
-    (cd src && make clean $JOBS $MAKE_ARGS 2>&1 && make "CFLAGS+=$HF" "LDFLAGS+=$HL" $JOBS $MAKE_ARGS 2>&1) || { echo "src build failed"; exit 1; }
-    (cd tests && make clean $JOBS $MAKE_ARGS 2>&1 && make "CFLAGS+=$HF" "LDFLAGS+=$HL" $JOBS $MAKE_ARGS 2>&1) || { echo "tests build failed"; exit 1; }
-    BUILD_SUCCESS=1
-else
-    make $JOBS $MAKE_ARGS 2>&1 | tee build.log
-    if [ ${PIPESTATUS[0]} -eq 0 ]; then
-        BUILD_SUCCESS=1
-    fi
-fi
-
-if [ $BUILD_SUCCESS -eq 1 ]; then
-    echo ""
-    echo "Build completed successfully!"
-    echo "Binary: utun"
-
-    # Rebuild chatgui (CMake project) if transport sources changed
-    if [ -f tools/chatgui/build/CMakeCache.txt ] && command -v cmake &> /dev/null; then
-        echo ""
-        echo "======================================"
-        echo "Rebuilding chatgui (CMake)"
-        echo "======================================"
-        (cd tools/chatgui/build && cmake --build . -j4 2>&1) || echo "WARNING: chatgui build failed"
-    fi
-else
-    echo ""
-    echo "ERROR: Build failed!"
-    echo "Check build.log for details"
-    exit 1
-fi
+echo "Build completed successfully!"
+echo "Binary: src/utun"

build_bsd_full.sh

@@ -1,60 +1,32 @@
 #!/bin/sh
-
+# Полная сборка FreeBSD: зависимости и общий инкрементальный скрипт.
 set -e
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+case " ${*} " in
+    *" --help "*|*" -h "*)
+        echo "Usage: ./build_bsd_full.sh [--asan|--hardened] [-jN] [build.sh arguments]"
+        echo "Installs missing build tools and runs build.sh --full"
+        exit 0 ;;
+esac
 
-# Проверка и установка зависимостей
-need_install=""
-
-for cmd in autoreconf aclocal automake libtoolize; do
-    if ! command -v "$cmd" >/dev/null 2>&1; then
-        need_install=1
-        break
-    fi
+need_install=0
+for tool in bash gmake autoreconf aclocal automake libtoolize pkg-config; do
+    command -v "$tool" >/dev/null 2>&1 || need_install=1
 done
-
-if [ -n "$need_install" ]; then
-    echo "Устанавливаются необходимые пакеты..."
-    pkg update
-    pkg install -y autoconf automake libtool pkgconf openssl
+if [ "$need_install" -eq 1 ]; then
+    echo "INFO: installing missing FreeBSD build dependencies (requires root)"
+    pkg install -y bash gmake autoconf automake libtool pkgconf openssl || {
+        echo "ERROR: cannot install FreeBSD build dependencies" >&2; exit 1;
+    }
 fi
 
-mkdir -p m4
-
-echo "=== Полная пересборка uTun ==="
-
-# 1. Очистка
-echo "[1/4] Очистка..."
-make distclean 2>/dev/null || true
-rm -f config.h config.status config.log
-rm -f configure.log autoreconf.log build.log
-
-# 2. Генерация configure
-echo "[2/4] Автогенерация..."
-autoreconf -fi 2>&1 | tee autoreconf.log
-
-# Проверяем, появился ли configure
-if [ ! -f configure ]; then
-    echo "Ошибка: autoreconf не создал configure."
-    exit 1
+jobs_found=0
+for argument do
+    case "$argument" in -j*) jobs_found=1 ;; esac
+done
+if [ "$jobs_found" -eq 0 ]; then
+    jobs=$(sysctl -n hw.ncpu) || { echo "ERROR: cannot determine CPU count" >&2; exit 1; }
+    set -- "-j$jobs" "$@"
 fi
-
-chmod +x configure
-
-# 3. Конфигурация
-echo "[3/4] Конфигурация..."
-./configure --prefix=/usr/local 2>&1 | tee configure.log
-
-# Определяем количество ядер
-if command -v nproc >/dev/null 2>&1; then
-    JOBS=$(nproc)
-else
-    JOBS=$(sysctl -n hw.ncpu)
-fi
-
-# 4. Сборка
-echo "[4/4] Сборка..."
-make -j"$JOBS" 2>&1 | tee build.log
-
-echo
-echo "=== Готово ==="
-echo "Бинарный файл: src/utun"
+echo "INFO: running shared build script for FreeBSD"
+exec bash "$SCRIPT_DIR/build.sh" --full "$@"

build_direct.sh

@@ -70,7 +70,7 @@ echo "Building utun.exe..."
 cd src
 EXE_NEEDS_REBUILD=0
 
-CORE_SOURCES="utun.c utun_instance.c config_parser.c config_updater.c routing_layer/route_lib.c topo_bgp.c routing_layer/routing.c tun_if.c tun_route.c transport_layer/etcp.c transport_layer/etcp_connections.c transport_layer/etcp_loadbalancer.c transport_layer/secure_channel.c transport_layer/crc32.c transport_layer/pkt_normalizer.c transport_layer/etcp_api.c tun_windows.c"
+CORE_SOURCES="utun.c utun_instance.c config_parser.c config_updater.c routing_layer/route_lib.c topo_bgp.c routing_layer/routing.c tun_if.c tun_route.c transport_layer/etcp.c transport_layer/etcp_padding.c transport_layer/reality_record.c transport_layer/reality_io.c transport_layer/etcp_session.c transport_layer/etcp_connections.c transport_layer/etcp_loadbalancer.c transport_layer/secure_channel.c transport_layer/crc32.c transport_layer/pkt_normalizer.c transport_layer/etcp_api.c tun_windows.c"
 
 for src in $CORE_SOURCES; do
     if [ -f "$src" ]; then

build_full.bat

@@ -1,4 +1,5 @@
 @echo off
+setlocal EnableExtensions
 echo uTun Full Build Script for MSYS2 UCRT64
 echo =========================================
 echo This will regenerate build system with autoreconf
@@ -11,11 +12,11 @@ rem export https_proxy="http://192.168.29.1:9999"
 
 
 REM Default MSYS2 path
-set MSYS2_PATH=C:\msys64
+set "MSYS2_PATH=C:\msys64"
 
 REM Use environment variable if set
-if not "%MSYS2_ROOT%"=="" set MSYS2_PATH=%MSYS2_ROOT%
-if not "%MSYS2%"=="" set MSYS2_PATH=%MSYS2%
+if not "%MSYS2_ROOT%"=="" set "MSYS2_PATH=%MSYS2_ROOT%"
+if not "%MSYS2%"=="" set "MSYS2_PATH=%MSYS2%"
 
 REM Check if msys2_shell.cmd exists
 if not exist "%MSYS2_PATH%\msys2_shell.cmd" (
@@ -23,11 +24,16 @@ if not exist "%MSYS2_PATH%\msys2_shell.cmd" (
     echo Please install MSYS2 from https://www.msys2.org/
     echo or set MSYS2_ROOT environment variable.
     pause
+    popd
     exit /b 1
 )
 
 REM Launch MSYS2 UCRT64 shell and run build script with --full flag
 echo Starting MSYS2 UCRT64 environment for FULL REBUILD...
-echo Running: bash build.sh --full
+echo Running: bash build.sh --full --installer
 echo.
-call "%MSYS2_PATH%\msys2_shell.cmd" -ucrt64 -here -defterm -no-start -c "set -o pipefail; bash build.sh --full 2>&1 | tee build_full.log"
+call "%MSYS2_PATH%\msys2_shell.cmd" -ucrt64 -here -defterm -no-start -c "set -o pipefail; bash build.sh --full --installer 2>&1 | tee build_full.log"
+set "BUILD_RESULT=%ERRORLEVEL%"
+if not "%BUILD_RESULT%"=="0" echo [ERROR] Build or installer failed. See build_full.log.
+popd
+endlocal & exit /b %BUILD_RESULT%

build_linux_full.sh

@@ -1,7 +1,79 @@
 #!/bin/sh
-mkdir -p m4
 set -e
 
+# --- определение пакетного менеджера ---
+detect_pm() {
+    if command -v apt-get >/dev/null 2>&1; then
+        PM=apt; PM_UPDATE="apt-get update"; PM_INSTALL="apt-get install -y"
+        P_AUTOCONF=autoconf; P_AUTOMAKE=automake; P_BUILD=build-essential; P_SSL=libssl-dev
+    elif command -v dnf >/dev/null 2>&1; then
+        PM=dnf; PM_UPDATE="true"; PM_INSTALL="dnf install -y"
+        P_AUTOCONF=autoconf; P_AUTOMAKE=automake; P_BUILD="gcc make"; P_SSL=openssl-devel
+    elif command -v yum >/dev/null 2>&1; then
+        PM=yum; PM_UPDATE="true"; PM_INSTALL="yum install -y"
+        P_AUTOCONF=autoconf; P_AUTOMAKE=automake; P_BUILD="gcc make"; P_SSL=openssl-devel
+    elif command -v pacman >/dev/null 2>&1; then
+        PM=pacman; PM_UPDATE="pacman -Sy --noconfirm"; PM_INSTALL="pacman -S --noconfirm"
+        P_AUTOCONF=autoconf; P_AUTOMAKE=automake; P_BUILD=base-devel; P_SSL=openssl
+    elif command -v apk >/dev/null 2>&1; then
+        PM=apk; PM_UPDATE="apk update"; PM_INSTALL="apk add"
+        P_AUTOCONF=autoconf; P_AUTOMAKE=automake; P_BUILD=build-base; P_SSL=openssl-dev
+    else
+        PM=none
+    fi
+}
+
+# --- чего не хватает (логические маркеры) ---
+detect_missing() {
+    missing=""
+    command -v autoreconf >/dev/null 2>&1 || missing="$missing autoconf"
+    command -v automake   >/dev/null 2>&1 || missing="$missing automake"
+    if ! command -v gcc >/dev/null 2>&1 || ! command -v make >/dev/null 2>&1; then
+        missing="$missing buildtools"
+    fi
+    [ -f /usr/include/openssl/sha.h ] || missing="$missing openssl"
+}
+
+# --- перевести маркеры в пакеты выбранного PM ---
+pkg_names() {
+    pkgs=""
+    case "$missing" in *autoconf*)   pkgs="$pkgs $P_AUTOCONF";; esac
+    case "$missing" in *automake*)   pkgs="$pkgs $P_AUTOMAKE";; esac
+    case "$missing" in *buildtools*) pkgs="$pkgs $P_BUILD";; esac
+    case "$missing" in *openssl*)    pkgs="$pkgs $P_SSL";; esac
+}
+
+# --- установка, если что-то отсутствует ---
+detect_pm
+detect_missing
+if [ -n "$missing" ]; then
+    if [ "$PM" = "none" ]; then
+        echo "Ошибка: не найден пакетный менеджер. Установите вручную:$missing"
+        exit 1
+    fi
+    if [ "$(id -u)" -eq 0 ]; then
+        SUDO=""
+    elif command -v sudo >/dev/null 2>&1; then
+        SUDO="sudo"
+    else
+        echo "Ошибка: нужны права root (sudo не найден). Установите вручную:$missing"
+        exit 1
+    fi
+    pkg_names
+    echo "Установка недостающих пакетов ($PM):$pkgs"
+    $SUDO $PM_UPDATE && $SUDO $PM_INSTALL $pkgs || {
+        echo "Ошибка: не удалось установить пакеты:$pkgs"
+        exit 1
+    }
+    detect_missing
+    if [ -n "$missing" ]; then
+        echo "Ошибка: после установки всё ещё не хватает:$missing"
+        exit 1
+    fi
+fi
+
+mkdir -p m4
+
 echo "=== Полная пересборка uTun ==="
 
 # 1. Очистка
@@ -9,19 +81,36 @@ echo "[1/4] Очистка..."
 make distclean 2>/dev/null || true
 rm -f config.h config.status config.log
 rm -f configure.log autoreconf.log build.log
+rm -f src/utun
 
 # 2. Автогенерация (autoreconf)
 echo "[2/4] Автогенерация (autoreconf -fi)..."
 autoreconf -fi 2>&1 | tee autoreconf.log
 
+if [ ! -f configure ]; then
+    echo "Ошибка: autoreconf не создал configure. См. autoreconf.log"
+    exit 1
+fi
+
 # 3. Конфигурация
 echo "[3/4] Конфигурация..."
 ./configure --prefix=/usr/local 2>&1 | tee configure.log
 
+if [ ! -f Makefile ]; then
+    echo "Ошибка: configure не создал Makefile. См. configure.log"
+    echo "Возможно не установлен libssl-dev (OpenSSL)."
+    exit 1
+fi
+
 # 4. Сборка
 echo "[4/4] Сборка..."
 make -j$(nproc) 2>&1 | tee build.log
 
+if [ ! -f src/utun ]; then
+    echo "Ошибка: сборка не создала src/utun. См. build.log"
+    exit 1
+fi
+
 echo ""
 echo "=== Готово ==="
-echo "Бинарный файл: src/utun"
+echo "Бинарный файл: src/utun (скопирован в ./utun)"

check.bat

@@ -16,7 +16,7 @@ set "TOTAL=0"
 if not exist "%LOGS_DIR%" mkdir "%LOGS_DIR%"
 
 :: List of all test executables
-set "TEST_LIST=test_etcp_crypto test_crypto test_etcp_two_instances test_etcp_simple_traffic test_etcp_minimal test_etcp_100_packets test_pkt_normalizer_etcp test_pkt_normalizer_standalone test_etcp_api test_ll_queue test_ecc_encrypt test_intensive_memory_pool test_memory_pool_and_config test_packet_dump test_u_async_comprehensive test_u_async_performance test_debug_categories test_config_debug test_route_lib test_bgp_route_exchange bench_timeout_heap bench_uasync_timeouts"
+set "TEST_LIST=bench_timeout_heap bench_uasync_timeouts test_etcp_minimal test_u_async_performance test_packet_dump test_config_debug test_debug_categories test_memory_pool_and_config test_etcp_crypto test_route_lib test_crypto test_ecc_encrypt test_ll_queue test_intensive_memory_pool test_pkt_normalizer_standalone test_etcp_two_instances test_u_async_comprehensive test_etcp_simple_traffic test_pkt_normalizer_etcp test_etcp_100_packets test_etcp_api test_bgp_route_exchange"
 
 echo Running tests...
 echo.

check.sh

@@ -1,6 +1,10 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -eo pipefail
 cd "$(dirname "$0")"
+MAKE_TOOL=${MAKE:-$(command -v gmake || command -v make)}
+TIMEOUT_TOOL=$(command -v timeout || command -v gtimeout) || {
+    echo "ERROR: timeout or gtimeout is required for the test runner" >&2; exit 1;
+}
 
 LAST=0; [ -f .check_time ] && read -r LAST < .check_time
 TMO=$(( LAST + 30 ))
@@ -8,14 +12,33 @@ TMO=$(( LAST + 30 ))
 
 START=$(date +%s)
 TMP=$(mktemp)
-timeout $TMO make check -j4 > "$TMP" 2>&1 || {
+"$TIMEOUT_TOOL" "$TMO" "$MAKE_TOOL" check -j4 > "$TMP" 2>&1 || {
     tail -40 "$TMP"; rm -f "$TMP"
     [ $(date +%s) -ge $((START + TMO)) ] && echo "TIMEOUT (${TMO}s)" >&2
     exit 1
 }
-grep -E '\[PASS|\[FAIL|\[SKIP|Test Results|Failed tests|Log directory|^====' "$TMP"
+grep -E '\[INFO|\[PASS|\[FAIL|\[SKIP|Test Results|Failed tests|Log directory|^====' "$TMP"
 rm -f "$TMP"
 
+# Интеграционный тест tcp_proxy_full (требует sudo; без passwordless sudo — пропускаем)
+echo ""
+if [ "$(uname -s)" != Linux ]; then
+    echo "[SKIP] tcp_proxy_full integration tests require Linux networking tools"
+elif [ "$(id -u)" -eq 0 ]; then
+    "$MAKE_TOOL" -C tests check-proxy
+    "$MAKE_TOOL" -C tests check-burst
+    "$MAKE_TOOL" -C tests check-load
+elif command -v sudo >/dev/null 2>&1 && sudo -n true 2>/dev/null; then
+    echo "=== tcp_proxy_full integration test (sudo) ==="
+    sudo -n "$MAKE_TOOL" -C tests check-proxy
+    echo "=== tcp_proxy_full burst test (sudo) ==="
+    sudo -n "$MAKE_TOOL" -C tests check-burst
+    echo "=== tcp_proxy_full load test (sudo) ==="
+    sudo -n "$MAKE_TOOL" -C tests check-load
+else
+    echo "[SKIP] tcp_proxy_full integration test (requires passwordless sudo)"
+fi
+
 ELAPSED=$(( $(date +%s) - START ))
 echo "Time: ${ELAPSED}s"
 echo "$ELAPSED" > .check_time

check_cc.bat

@@ -0,0 +1,34 @@
+@echo off
+setlocal
+pushd "%~dp0"
+if errorlevel 1 (
+    echo [ERROR] Cannot open the script directory.
+    pause
+    exit /b 1
+)
+
+set "MSYS2_PATH=C:\msys64"
+if not "%MSYS2_ROOT%"=="" set "MSYS2_PATH=%MSYS2_ROOT%"
+if not "%MSYS2%"=="" set "MSYS2_PATH=%MSYS2%"
+set "PROBE_LOG=%CD%\cc-probe.log"
+set "PROBE_RESULT=1"
+
+> "%PROBE_LOG%" echo [INFO] MSYS2: %MSYS2_PATH%
+if not exist "%MSYS2_PATH%\msys2_shell.cmd" (
+    >> "%PROBE_LOG%" echo [ERROR] msys2_shell.cmd not found. Set MSYS2_ROOT to the MSYS2 directory.
+    goto finish
+)
+
+echo [INFO] Checking the UCRT64 C compiler and Opus build...
+call "%MSYS2_PATH%\msys2_shell.cmd" -ucrt64 -here -defterm -no-start -c "bash ./check_cc.sh" >> "%PROBE_LOG%" 2>&1
+set "PROBE_RESULT=%ERRORLEVEL%"
+
+:finish
+>> "%PROBE_LOG%" echo [INFO] MSYS2 shell exit code: %PROBE_RESULT%
+type "%PROBE_LOG%"
+echo.
+echo [INFO] Log: "%PROBE_LOG%"
+if not "%PROBE_RESULT%"=="0" echo [ERROR] Compiler or Opus check failed. See the log above.
+if /i not "%~1"=="--no-pause" pause
+popd
+exit /b %PROBE_RESULT%

check_cc.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+set -uo pipefail
+
+# Проверяем базовую компиляцию, затем Opus отдельно и через существующую CMake-сборку.
+probe_cc="${UTUN_PROBE_CC:-/ucrt64/bin/cc.exe}"
+printf '[INFO] MSYSTEM=%s\n[INFO] PATH=%s\n[INFO] Compiler=%s\n' "${MSYSTEM:-unset}" "$PATH" "$probe_cc"
+if [ ! -x "$probe_cc" ]; then
+    printf '[ERROR] Compiler is missing or not executable: %s\n' "$probe_cc"
+    exit 1
+fi
+
+probe_dir=$(mktemp -d "${TMPDIR:-/tmp}/utun-cc-probe.XXXXXX") || {
+    printf '[ERROR] Cannot create the temporary probe directory.\n'
+    exit 1
+}
+trap 'rm -rf -- "$probe_dir" || printf "[WARN] Cannot remove probe directory: %s\n" "$probe_dir"' EXIT
+printf '[INFO] Temporary directory: %s\n' "$probe_dir"
+
+# Каждый этап сохраняет собственный код завершения, включая молчаливые сбои.
+probe_step() {
+    local step="$1" result
+    shift
+    printf '\n[INFO] %s\n[INFO] Directory: %s\n[INFO] Command:' "$step" "$PWD"
+    printf ' %q' "$@"
+    printf '\n'
+    "$@"
+    result=$?
+    printf '[INFO] %s exit code: %d\n' "$step" "$result"
+    if [ "$result" -ne 0 ]; then
+        printf '[ERROR] Failed stage: %s\n' "$step"
+    fi
+    return "$result"
+}
+
+printf '#include <stdio.h>\nint main(void) { puts("utun compiler probe OK"); return 0; }\n' > "$probe_dir/probe.c" || {
+    printf '[ERROR] Cannot write the probe source: %s/probe.c\n' "$probe_dir"
+    exit 1
+}
+probe_step 'Compiler version' "$probe_cc" --version || exit $?
+probe_step 'Compile' "$probe_cc" -v -std=c99 -c "$probe_dir/probe.c" -o "$probe_dir/probe.o" || exit $?
+probe_step 'Link' "$probe_cc" -v "$probe_dir/probe.o" -o "$probe_dir/probe.exe" || exit $?
+probe_step 'Run' "$probe_dir/probe.exe" || exit $?
+printf '\n[SUCCESS] Compile, link and run completed.\n'
+
+probe_root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd) || {
+    printf '[ERROR] Cannot locate the repository directory.\n'
+    exit 1
+}
+probe_opus="$probe_root/lib/libopus"
+probe_includes=()
+for probe_include in '' include celt silk silk/float silk/fixed src; do
+    probe_includes+=("-I$probe_opus/$probe_include")
+done
+for probe_source in laplace bands; do
+    probe_step "Compile Opus $probe_source.c" "$probe_cc" -v -DOPUS_BUILD -DUSE_ALLOCA -DVAR_ARRAYS "${probe_includes[@]}" \
+        -O3 -DNDEBUG -std=gnu99 -MD -MF "$probe_dir/$probe_source.d" \
+        -c "$probe_opus/celt/$probe_source.c" -o "$probe_dir/$probe_source.o" || exit $?
+done
+
+probe_build="$probe_root/tools/chatgui/build"
+if [ ! -f "$probe_build/CMakeCache.txt" ]; then
+    printf '[ERROR] Existing ChatGUI build cache not found: %s/CMakeCache.txt\n' "$probe_build"
+    exit 1
+fi
+if ! command -v cmake >/dev/null 2>&1; then
+    printf '[ERROR] cmake is not available in PATH.\n'
+    exit 1
+fi
+probe_step 'CMake cache settings' sed -n -E \
+    '/^CMAKE_(C_COMPILER|C_COMPILER_LAUNCHER|C_FLAGS(_(DEBUG|RELEASE|MINSIZEREL|RELWITHDEBINFO))?|MAKE_PROGRAM|GENERATOR|BUILD_TYPE):/p' \
+    "$probe_build/CMakeCache.txt" || exit $?
+
+# Повторяем Windows-команду без преобразования аргументов MSYS2; добавляем только GCC -v.
+if [ "${MSYSTEM:-}" = UCRT64 ]; then
+    probe_ninja=$(sed -n 's/^CMAKE_MAKE_PROGRAM:[^=]*=//p' "$probe_build/CMakeCache.txt")
+    probe_ninja=${probe_ninja%$'\r'}
+    probe_ninja=$(cygpath -u "$probe_ninja") || exit $?
+    "$probe_ninja" -C "$probe_build" -t commands opus_internal > "$probe_dir/ninja-commands.txt"
+    probe_result=$?
+    if [ "$probe_result" -ne 0 ]; then
+        cat "$probe_dir/ninja-commands.txt"
+        printf '[ERROR] Cannot read Ninja commands, exit code: %d\n' "$probe_result"
+        exit "$probe_result"
+    fi
+    probe_command=''
+    while IFS= read -r probe_line; do
+        probe_line=${probe_line%$'\r'}
+        case "$probe_line" in
+            *' -DOPUS_BUILD '*' -c '*'/celt/bands.c'|*' -DOPUS_BUILD '*' -c '*'/celt/bands.c"')
+                probe_command="$probe_line"; break ;;
+        esac
+    done < "$probe_dir/ninja-commands.txt"
+    if [ -z "$probe_command" ]; then
+        printf '[ERROR] Cannot find the Opus bands.c compile command in Ninja.\n'
+        exit 1
+    fi
+    probe_command=${probe_command/ -DOPUS_BUILD/ -v -DOPUS_BUILD}
+    printf '[INFO] Native command: %s\n' "$probe_command"
+    printf '@echo off\r\n%s\r\nexit /b %%errorlevel%%\r\n' "$probe_command" > "$probe_dir/replay.cmd" || {
+        printf '[ERROR] Cannot write the native compiler replay script.\n'
+        exit 1
+    }
+    probe_cmd=$(cygpath -u "${COMSPEC:-C:/Windows/System32/cmd.exe}") || exit $?
+    probe_replay=$(cygpath -w "$probe_dir/replay.cmd") || exit $?
+
+    # CMD сохраняет полный Windows-код завершения cc1; Bash оставляет только младший байт.
+    probe_cc1=$("$probe_cc" -print-prog-name=cc1) || { printf '[ERROR] Cannot locate cc1.\n'; exit 1; }
+    probe_cc1=${probe_cc1%$'\r'}
+    probe_cc1=$(cygpath -u "$probe_cc1") || { printf '[ERROR] Cannot resolve the cc1 path.\n'; exit 1; }
+    probe_cc1_native=$(cygpath -w "$probe_cc1") || { printf '[ERROR] Cannot resolve the native cc1 path.\n'; exit 1; }
+    printf '@echo off\r\n"%s" --version\r\nset "UTUN_CC1_RESULT=%%errorlevel%%"\r\n' "$probe_cc1_native" \
+        > "$probe_dir/cc1.cmd" || { printf '[ERROR] Cannot write the cc1 probe script.\n'; exit 1; }
+    printf 'echo [INFO] cc1 Windows exit code: %%UTUN_CC1_RESULT%%\r\nexit /b %%UTUN_CC1_RESULT%%\r\n' \
+        >> "$probe_dir/cc1.cmd" || { printf '[ERROR] Cannot finish the cc1 probe script.\n'; exit 1; }
+    probe_cc1_script=$(cygpath -w "$probe_dir/cc1.cmd") || { printf '[ERROR] Cannot resolve the cc1 script path.\n'; exit 1; }
+    for probe_cwd in "$probe_root" "$probe_build"; do
+        cd -- "$probe_cwd" || { printf '[ERROR] Cannot open probe directory: %s\n' "$probe_cwd"; exit 1; }
+        MSYS2_ARG_CONV_EXCL='*' probe_step 'Launch cc1 before runtime refresh' "$probe_cmd" /d /c call "$probe_cc1_script"
+        # При ошибке продолжаем сравнение каталогов и DLL, затем повторяем исходный сбой.
+    done
+    cd -- "$probe_root" || { printf '[ERROR] Cannot open the repository directory.\n'; exit 1; }
+    probe_objdump="${probe_cc%/*}/objdump.exe"
+    "$probe_objdump" -p "$probe_cc1" > "$probe_dir/cc1-imports.txt" || {
+        printf '[ERROR] Cannot inspect cc1 imports.\n'; exit 1;
+    }
+    printf '\n[INFO] cc1 DLL imports:\n'
+    sed -n '/DLL Name:/p' "$probe_dir/cc1-imports.txt" || { printf '[ERROR] Cannot read cc1 imports.\n'; exit 1; }
+    source "$probe_root/tools/chatgui/compiler_runtime.sh"
+    for probe_dll in "$probe_build/"*.dll; do
+        [ -f "$probe_dll" ] || continue
+        chatgui_is_compiler_runtime_dll "${probe_dll##*/}" || continue
+        probe_system_dll="${probe_cc%/*}/${probe_dll##*/}"
+        [ -f "$probe_system_dll" ] || continue
+        cmp -s "$probe_dll" "$probe_system_dll"
+        probe_result=$?
+        case "$probe_result" in
+            0) printf '[INFO] DLL matches UCRT64: %s\n' "${probe_dll##*/}" ;;
+            1) printf '[WARN] DLL differs from UCRT64: %s\n' "${probe_dll##*/}"
+               probe_step 'DLL hashes' sha256sum "$probe_dll" "$probe_system_dll" || exit $? ;;
+            *) printf '[ERROR] Cannot compare DLL: %s, exit code: %d\n' "$probe_dll" "$probe_result"; exit "$probe_result" ;;
+        esac
+    done
+    probe_step 'Refresh compiler runtime DLLs' chatgui_refresh_compiler_runtime "$probe_build" "${probe_cc%/*}" || exit $?
+    cd -- "$probe_build" || { printf '[ERROR] Cannot open the ChatGUI build directory.\n'; exit 1; }
+    MSYS2_ARG_CONV_EXCL='*' probe_step 'Launch cc1 after runtime refresh' "$probe_cmd" /d /c call "$probe_cc1_script" || exit $?
+    MSYS2_ARG_CONV_EXCL='*' probe_step 'Replay Ninja bands.c command with GCC verbose output' \
+        "$probe_cmd" /d /c call "$probe_replay" || exit $?
+fi
+probe_step 'Build Opus with CMake' cmake --build "$probe_build" --target opus_internal --parallel 1 --verbose || exit $?
+printf '\n[SUCCESS] Standalone Opus compilation and CMake Opus build completed.\n'

configure.ac

@@ -62,11 +62,24 @@ AC_ARG_ENABLE([hardening],
     [enable_hardening=no])
 
 if test "x$enable_hardening" = "xyes"; then
-    HARDEN_CFLAGS="-D_FORTIFY_SOURCE=2 -fstack-protector-strong -fstack-clash-protection -Wformat=2 -Wformat-overflow=2 -fPIE"
-    HARDEN_LDFLAGS="-Wl,-z,relro -Wl,-z,now -pie"
+    HARDEN_CFLAGS="-D_FORTIFY_SOURCE=2 -fstack-protector-strong -Wformat=2"
+    compiler_version=$($CC --version 2>&1) || AC_MSG_ERROR([Cannot identify compiler for hardening])
+    case "$compiler_version" in
+        *clang*) ;;
+        *) HARDEN_CFLAGS="$HARDEN_CFLAGS -fstack-clash-protection -Wformat-overflow=2" ;;
+    esac
+    case "$host" in
+        *mingw* | *msys* | *cygwin*)
+            HARDEN_LDFLAGS="-Wl,--dynamicbase,--nxcompat,--high-entropy-va"
+            ;;
+        *)
+            HARDEN_CFLAGS="$HARDEN_CFLAGS -fPIE"
+            HARDEN_LDFLAGS="-Wl,-z,relro -Wl,-z,now -pie"
+            ;;
+    esac
     CFLAGS="$CFLAGS $HARDEN_CFLAGS"
     LDFLAGS="$LDFLAGS $HARDEN_LDFLAGS"
-    AC_MSG_NOTICE([Hardening flags enabled: $HARDEN_CFLAGS])
+    AC_MSG_NOTICE([Hardening flags enabled: CFLAGS=$HARDEN_CFLAGS LDFLAGS=$HARDEN_LDFLAGS])
 fi
 
 # ==================== НАДЁЖНЫЙ ДЕТЕКТ WINDOWS ====================
@@ -95,6 +108,19 @@ AC_MSG_RESULT([$os_freebsd])
 
 AM_CONDITIONAL([OS_FREEBSD], [test "x$os_freebsd" = "xyes"])
 
+# ==================== DETECT LINUX ====================
+AC_MSG_CHECKING([for Linux])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+#ifndef __linux__
+#error "Not Linux"
+#endif
+]], [[ return 0; ]])],
+    [os_linux=yes],
+    [os_linux=no])
+AC_MSG_RESULT([$os_linux])
+
+AM_CONDITIONAL([OS_LINUX], [test "x$os_linux" = "xyes"])
+
 # Set TUN libs based on platform
 if test "x$os_windows" = "xyes"; then
     TUN_LIBS="-liphlpapi -lws2_32 -ladvapi32 -lbcrypt -ldbghelp"
@@ -127,6 +153,75 @@ fi
 AM_CONDITIONAL([HAVE_WHISPER], [test "x$with_whisper" = "xyes"])
 AC_SUBST([WHISPER_LIBS])
 
+# ==================== FFMPEG (OPTIONAL) ====================
+AC_ARG_WITH([ffmpeg],
+    AS_HELP_STRING([--with-ffmpeg], [Enable video transcoding (requires FFmpeg libav libraries)]),
+    [with_ffmpeg=$withval],
+    [with_ffmpeg=no])
+
+if test "x$with_ffmpeg" = "xyes"; then
+    save_LIBS="$LIBS"
+    FFMPEG_LIBS="-lavformat -lavcodec -lavutil -lswscale -lswresample"
+    LIBS="$FFMPEG_LIBS $LIBS"
+    AC_CHECK_HEADER([libavformat/avformat.h], [
+        AC_CHECK_HEADER([libavcodec/avcodec.h], [
+            AC_CHECK_HEADER([libavutil/imgutils.h], [
+                AC_CHECK_HEADER([libswscale/swscale.h], [
+                    AC_CHECK_HEADER([libswresample/swresample.h], [
+                        AC_CHECK_LIB([avformat], [avformat_open_input], [
+                            AC_DEFINE([HAVE_FFMPEG], [1], [Define to enable FFmpeg video transcoding])
+                            AC_MSG_NOTICE([FFmpeg enabled])
+                        ], [
+                            AC_MSG_WARN([FFmpeg libs not found, disabling ffmpeg])
+                            with_ffmpeg=no
+                        ])
+                    ], [AC_MSG_WARN([swresample.h not found, disabling ffmpeg]); with_ffmpeg=no])
+                ], [AC_MSG_WARN([swscale.h not found, disabling ffmpeg]); with_ffmpeg=no])
+            ], [AC_MSG_WARN([imgutils.h not found, disabling ffmpeg]); with_ffmpeg=no])
+        ], [AC_MSG_WARN([avcodec.h not found, disabling ffmpeg]); with_ffmpeg=no])
+    ], [AC_MSG_WARN([avformat.h not found, disabling ffmpeg]); with_ffmpeg=no])
+    LIBS="$save_LIBS"
+fi
+
+if test "x$with_ffmpeg" != "xyes"; then
+    FFMPEG_LIBS=""
+    FFMPEG_CFLAGS=""
+fi
+AM_CONDITIONAL([HAVE_FFMPEG], [test "x$with_ffmpeg" = "xyes"])
+AC_SUBST([FFMPEG_LIBS])
+AC_SUBST([FFMPEG_CFLAGS])
+
+# ==================== SILERO VAD (OPTIONAL, requires ONNX Runtime) ====================
+AC_ARG_WITH([silero-vad],
+    AS_HELP_STRING([--with-silero-vad], [Enable Silero voice activity detector (requires ONNX Runtime)]),
+    [with_silero_vad=$withval],
+    [with_silero_vad=no])
+
+if test "x$with_silero_vad" = "xyes"; then
+    AC_CHECK_HEADER([onnxruntime/onnxruntime_c_api.h], [
+        save_LIBS="$LIBS"
+        LIBS="-lonnxruntime $LIBS"
+        AC_CHECK_LIB([onnxruntime], [OrtGetApiBase], [
+            SILERO_VAD_LIBS="-lonnxruntime"
+            AC_DEFINE([HAVE_SILERO_VAD], [1], [Define to enable Silero VAD via ONNX Runtime])
+            AC_MSG_NOTICE([Silero VAD enabled (ONNX Runtime)])
+        ], [
+            AC_MSG_WARN([libonnxruntime not found, disabling silero-vad])
+            with_silero_vad=no
+        ])
+        LIBS="$save_LIBS"
+    ], [
+        AC_MSG_WARN([onnxruntime/onnxruntime_c_api.h not found, disabling silero-vad])
+        with_silero_vad=no
+    ])
+fi
+
+if test "x$with_silero_vad" != "xyes"; then
+    SILERO_VAD_LIBS=""
+fi
+AM_CONDITIONAL([HAVE_SILERO_VAD], [test "x$with_silero_vad" = "xyes"])
+AC_SUBST([SILERO_VAD_LIBS])
+
 # Checks for header files, typedefs, functions...
 AC_CHECK_HEADERS([arpa/inet.h fcntl.h limits.h netinet/in.h stdint.h stdlib.h string.h sys/ioctl.h sys/socket.h unistd.h])
 AC_TYPE_SIZE_T
@@ -153,10 +248,11 @@ AC_OUTPUT
 # Summary
 echo "
 Configuration summary:
-----------------------
+---------------------
   Host:         ${host}
   Windows:      ${os_windows}
   Prefix:       ${prefix}
   Compiler:     ${CC}
   CFLAGS:       ${CFLAGS}
-"
+  Silero VAD:   ${with_silero_vad}
+"

cross-build-win.sh

@@ -197,14 +197,14 @@ SRC_SOURCES=(
     routing_layer/route_lib.c routing_layer/route6_lib.c topo_bgp.c routing_layer/route_ping.c
     routing_layer/topo_node.c topo_node_lmdb.c routing_layer/route_connectivity.c routing_layer/conn_mgr.c
     routing_layer/routing.c tun_if.c tun_route.c tun_linux.c tun_freebsd.c tun_windows.c
-    transport_layer/etcp.c transport_layer/etcp_connections.c transport_layer/etcp_bbr.c transport_layer/etcp_loadbalancer.c
+    transport_layer/etcp.c transport_layer/etcp_session.c transport_layer/etcp_connections.c transport_layer/etcp_bbr.c transport_layer/etcp_loadbalancer.c
     transport_layer/etcp_debug.c transport_layer/etcp_dump.c transport_layer/secure_channel.c transport_layer/crc32.c
     transport_layer/stcp_link.c transport_layer/stcp.c transport_layer/stcp_server.c transport_layer/stcp_client.c
     transport_layer/pkt_normalizer.c transport_layer/packet_dump.c transport_layer/etcp_api.c
     control_server.c
     firewall.c eim_nat.c nat_transport.c transport_layer/dummynet.c
-    etcp_router.c
-    proxy/udp_proxy.c proxy/socks_proxy.c
+    etcp_router.c route_crypto.c
+    proxy/udp_proxy.c proxy/socks_proxy.c proxy/http_proxy.c
     lwip_tcp/lwip_pbuf.c
 )
 
@@ -272,7 +272,7 @@ echo ""
 if [ -f "$SCRIPT_DIR/lib/wintun.dll" ]; then
     echo "Run on Windows:"
     echo "  1. Install Wintun driver (https://www.wintun.net)"
-    echo "  2. Copy utun.exe + wintun.dll to the same directory"
+    echo "  2. Copy utun.exe + wintun.dll + LICENSE + LICENSING + THIRD_PARTY_NOTICES to the same directory"
     echo "  3. Run: utun.exe -f -p utun.pid -l utun.log"
 else
     echo "Run on Windows:"

doc/_plan.txt

@@ -1,35 +0,0 @@
-План доработок
-[ ] продумать архитектуру репликации таблицы узлов группы
-[ ] добавить узлы хелперы (для проксирования трафика)
-
-
-Категории узлов:
-- узлы без нат []
-- узлы с nat [restricted]
-
-Узлы за nat сами подключаются к прямым
-
-Узлы за eim nat сами подключаются и сообщают обновление адреса.
-
-Прямые узлы должны сами должны объединиться в сеть следующим образом:
-
-Инит: база содержит RTT по узлам.
-выбираем n=16 узлов с минимальным rtt. запускаем подключение к ним.
-синхронизируем роутинг таблицу с ними (обмен маршрутами должен инициироваться сразу после подключения).
-при потере связи узлы через nat должны найти альтернативы.
-
-в таблице обновляется 
-
-как обмен завершен
-
-Нужно собирать и обновлять информацию о том
-- к каким публичным нодам подключены nat узлы.
-
-- метрика доступности узла - как давно не менялся ip:port - собираем с клиентов. вместе с рейтигном (каждый клиент по узлу фолрмирует свой рейтинг кандидата в суперузлы и отправляет подписанный рейтинг узлу)
-рейтинг включает:
-- число разных часов фигурирует в замерах
-- число разных дат фигурирует в замерах
-- гистограмма rtt: 0-2ms, 2-4ms, 4-6ms, 6-10ms, 10-13ms, 14-18ms, 18-25ms, 25-35ms, 35-50ms, 50-75ms, 75-100ms, 100-130ms, 130-160ms, 160+ms
-- гистограмма потерь: 0-1% 1-2% 2-4% 4-8% >8% (обновляется каждый час)
-
-Сделать подключение к группе

doc/chat_call_arch.md

@@ -0,0 +1,465 @@
+# P2P аудио- и видеозвонок пользователю — архитектура
+
+Статус: реализовано. Звонок использует роутер, CM подготавливает оптимальный путь.
+
+## 1. Область
+
+Аудио и видео 1:1. Звонок можно инициировать **из CHAT-группы или из p2p-чата (DM)**.
+Модуль оперирует `group_id` + `peer_node_id`. Для `dm:<conv_id>` функция `dm_call_route`
+выбирает общую CHAT-группу с живым BGP-маршрутом к собеседнику; отдельная DM-группа не создаётся.
+Аудио и видео используют отдельные каналы `etcp_router`; возможности видеокодеков
+согласуются в активном звонке (см. [call_video.txt](call_video.txt)). Работает desktop↔desktop и desktop↔android
+(обе стороны компилируют общий стек `etcp_router` / `topo_group` (BGP) / `conn_mgr`).
+
+Полный цикл: проверка онлайна (BGP) → INVITE → звонок → ACCEPT/DECLINE →
+аудиопоток и опциональное видео через роутер → HANGUP. CM инициируется вызывающим при старте, вызываемым при принятии вызова.
+
+### Входящие вызовы и телефонная занятость
+
+Android хранит пять независимых настроек: показывать статус звонка, предупреждать вызывающего,
+отклонять при телефонной занятости, отклонять все обычные звонки, отклонять все приглашения в рацию.
+Они передаются маской `CALL_POLICY_*` через `[chat] incoming_call_policy` при старте,
+а при изменениях — вместе с живым состоянием телефона через JNI в uasync.
+Первые три настройки используют `READ_PHONE_STATE`; запреты всех входящих разрешения не требуют.
+Наблюдатель учитывает все активные SIM, набор номера, удержание и входящий телефонный вызов.
+Без разрешения или без телефонной службы состояние неизвестно, а не свободно.
+
+Приоритет: запрет типа вызова → автоматический отказ при телефонной занятости → предупреждение с выбором.
+Отказ при занятости возвращает `CALL_REASON_PHONE_BUSY`/`RADIO_CALL_PHONE_BUSY`.
+Предупреждение переводит попытку в `WAIT_DECISION`: у вызываемого нет события INCOMING, рингтона и регистрации в Telecom.
+Вызывающий видит «Абонент разговаривает по телефону», «Всё равно позвонить» и «Завершить».
+Продолжение подтверждается повторяемой командой внутри той же попытки; освобождение телефона само не запускает звонок.
+Повторные пакеты не создают повторных входящих событий. При изменении политики перед продолжением запрет проверяется снова.
+Предел всей попытки — 60с от начала, включая выбор; продолжение deadline не меняет.
+У рации первый ответ и подтверждение продолжения ограничены 2с; сообщение о занятости является ответом, но не RINGING.
+
+Рация, уже включённая у адресата в указанном канале, возвращает `RADIO_CALL_ALREADY_ACTIVE`:
+вызывающий получает уведомление, входящий вызов не показывается, его собственная рация не включается.
+Этот ответ описывает существующую подписку и не создаёт нового входящего вызова даже при включённом запрете приглашений.
+Принятие обычного приглашения в рацию по-прежнему сначала включает местную подписку, затем отправляет ACCEPT.
+Android обычного звонка показывает своё уведомление после `onShowIncomingCallUi` и обрабатывает отказ Telecom.
+
+## 2. Разбиение файлов (отдельный каталог `src/call/`)
+
+| Файл | Язык | Сборки | Назначение |
+|---|---|---|---|
+| `src/call/call_proto.h` | C | везде | wire-формат сигналинга (`0x36`) и аудио (`0x3F`), subcmd |
+| `src/call/call.h` / `call.c` | C | везде (autotools + GUI) | сигналинг, реестр сессий, таймеры, watchdog (20с по приёму), релей медиа с backpressure, счётчики |
+| `src/call/call_audio.h/c` | C | только GUI-сборки | Opus encode/decode, фрейминг, pull-обвязка с тонами; регистрация через `call_audio_ops` |
+| `src/call/call_tones.h/c` | C | только GUI-сборки | генератор тонов (glitch/ended), синус |
+| `src/call/call_jitter.h/cpp` | C++ | только GUI-сборки | SoundTouch джиттер-буфер, C API |
+| `src/call/call_video.h/c`, `call_video_transport.h/c` | C | везде | формат видеотрека, согласование возможностей и передача кадров отдельными каналами |
+
+Autotools-сборка демона остаётся C-only (`.cpp` не компилируется); сигналинг `call.c`
+присутствует и в демоне, аудиопроцессинг — только там, где есть GUI.
+
+Диагностика: категория `call` (`DEBUG_CATEGORY_CALL`); транспортная доставка — `etcp_route`.
+Desktop направляет сообщения FFmpeg и Qt в общий `debug_file` (по умолчанию `chatgui.log`).
+Начальная проверка codec пишет краткий итог на info, детали и ожидаемые отказы — на debug:
+`[gui] debug_categories=call=debug,video=debug`. Повторы FFmpeg внутри пробы сворачиваются со счётчиком;
+рабочие ошибки параллельного звонка сохраняют error/warn. Информационный stderr libva отключён по умолчанию;
+для диагностики драйвера можно явно запустить с `LIBVA_MESSAGING_LEVEL=2`.
+Отсутствующая desktop-запись приложения создаётся в XDG data applications для регистрации в portal.
+
+
+## 3. Протокол
+
+Каналы роутера независимы:
+
+| svc_id | Константа | Назначение |
+|---|---|---|
+| `0x36` | `ETCP_RT_ID_CALL` | сигналинг звонка |
+| `0x3D` | `ETCP_RT_ID_CALL_VIDEO_CONTROL` | согласование и восстановление видеотрека |
+| `0x3E` | `ETCP_RT_ID_CALL_VIDEO` | видеокадры |
+| `0x3F` | `ETCP_RT_ID_CALL_AUDIO` | аудиокадры `CALL_MEDIA` |
+
+Формат приёма сигналинга и аудио: `entry->dgram[0]=svc_id`, служебный заголовок роутера до
+`ROUTER_SVC_PAYLOAD_OFF=26`, затем subcmd и тело команды.
+
+Сигналинг (`0x36`):
+
+```
+CALL_INVITE  0x01 {call_id:8, group_id:8, num_tracks:1, force:1, expires_us:8, tracks:[{type:AUDIO, codec:OPUS, sr:4, ch:1, bitrate:4}]}
+CALL_RINGING 0x02 {call_id:8}
+CALL_ACCEPT  0x03 {call_id:8}
+CALL_DECLINE 0x04 {call_id:8, reason:1}
+CALL_BUSY    0x05 {call_id:8}
+CALL_CANCEL  0x06 {call_id:8}
+CALL_HANGUP  0x07 {call_id:8, reason:1}
+CALL_END_ACK 0x08 {call_id:8}
+CALL_PHONE_BUSY 0x09 {call_id:8}
+```
+
+Аудио (`0x3F`):
+
+```
+CALL_MEDIA   0x10 {call_id:8, track_id:1, seq:2, ts_ms:4, capture_pts_us:8, capture_epoch:8, codec_delay_samples:4, payload}
+```
+
+- `call_id` — случайный uint64, генерит вызывающий; идентифицирует сессию на обеих сторонах.
+- `group_id` — CHAT-группа; для DM-звонка выбирается общая группа участников с живым BGP-маршрутом.
+- Сигналинг: `etcp_route_send(..., ROUTE_CRYPTO_SIGN | ROUTE_CRYPTO_ENCRYPT)`.
+- Сигналинг, аудио и видео: обязательные `ROUTE_CRYPTO_SIGN | ROUTE_CRYPTO_ENCRYPT` между конечными узлами.
+- AES-128-CCM шифрует тело, Ed25519 подписывает заголовок роутера и шифртекст. Посредники не имеют ключа для расшифровки.
+- Ключ получается из постоянных X25519-идентичностей собеседников; forward secrecy отсутствует.
+- Маска защиты задаётся через `etcp_router_require_crypto`: открытые/частично защищённые данные отбрасываются
+  на конечном узле до изменения состояния приёма, очередей и `receive_ready`; отправка без требуемых флагов возвращает ошибку.
+  Пустые служебные пакеты роутера не являются медиаданными. Перехода на открытое медиа при ошибках нет.
+- Каждый пакет получает случайный nonce(13) от OpenSSL CSPRNG; ошибка RNG прекращает шифрование.
+  Надбавка к сервисным данным: nonce(13) + CRC(4) + CCM tag(16) + Ed25519(64) = 97 байт.
+- `CALL_MEDIA` переносит только аудио (`track_id=CALL_TRACK_AUDIO`); остальные значения приёмник отклоняет.
+  Видео имеет отдельный формат и транспорт: `call_video.h`, `call_video_transport.h`, [call_video.txt](call_video.txt).
+- Аудио: Opus 48kHz mono, 20ms (960 сэмплов), ~24–32 kbps. ~50 кадров/с.
+- Заголовок медиа — 36 байт с subcmd. `ts_ms` — время отправки для оценки сетевого джиттера;
+  `capture_pts_us` — время первого входного сэмпла в монотонной шкале отправителя, `INT64_MIN` при отсутствии метки.
+  `capture_epoch` различает разрывы захвата; `codec_delay_samples` передаёт Opus lookahead.
+  Старый формат не поддерживается; медиа принимается только от пира текущего звонка.
+
+## 4. Машина состояний
+
+```
+Caller: IDLE → OUTGOING(INVITE) → RINGING(RINGING) → ACTIVE(ACCEPT) → ENDED
+Callee: IDLE → INCOMING(INVITE) → RINGING(sent RINGING) → ACTIVE(accept) → ENDED
+```
+
+`ENDED` reasons: `LOCAL_HANGUP / REMOTE_HANGUP / DECLINE / BUSY / CANCEL /
+NO_TRAFFIC / RING_TIMEOUT / CONNECT_FAIL`.
+
+Таймауты:
+- **кодограмма INVITE 300мс** — вызывающий шлёт её весь период вызова
+  (`OUTGOING` + `RINGING`) как «сердцебиение»: покрывает потерю INVITE/RINGING и
+  держит маршрут живым;
+- **watchdog 2с у вызываемого** — нет кодограммы 2с → вызов считается сорванным
+  (отмена потерялась), сессия закрывается локально (`CALL_REASON_CANCEL`);
+- ring-timeout 60с от начала, включая ожидание решения вызывающего (нет ответа → CANCEL);
+- `CONN_EVENT_DOWN/TIMEOUT` CM не завершают звонок: роутер использует доступные пути;
+- **NO_TRAFFIC 20с** — нет входящих медиа-кадров → авто HANGUP.
+
+Завершающие кодограммы HANGUP/CANCEL/DECLINE повторяются каждые 300мс до END_ACK,
+не дольше 20с. Это необходимо при смене эпохи роутера: старые очереди удаляются,
+даже если отправитель ранее получил успешный результат постановки команды в очередь.
+Медиа и их локальные очереди освобождаются сразу, ENDED публикуется один раз.
+В реестре до ACK/таймаута остаётся только завершённая сессия с CM handle и таймером.
+Получатель подтверждает также повторные команды после удаления сессии, без повторного ENDED.
+Команда и ACK проверяются по подписи, шифрованию, размеру, call_id, пиру и группе существующей сессии.
+ACK не подтверждается. Новый звонок имеет другой call_id и не затрагивается поздними командами старого.
+При одновременном завершении стороны независимо подтверждают команды друг друга.
+После ACK сессия удаляется на ближайшем tick завершения; при удалённом завершении CM удерживается
+ещё 500мс для отправки ACK. Остановка ядра отменяет таймер без повторных отправок.
+Запоздалые кодограммы вызова при идущем разговоре (`ACTIVE`) игнорируются.
+
+Онлайн-проверка: `topo_node_find_by_id(group, peer) == NULL` → «не в сети» (event).
+
+CM handle инициирует оптимальное подключение и удерживается до завершения звонка.
+Медиа всегда идёт через `etcp_route_send`: роутер сам выбирает лучший путь и fallback.
+Звонок не хранит ETCP_CONN и не завершается при потере отдельного транспорта.
+Очистка записи CM отсоединяет handles и отменяет отложенные UP; handle закрывает владелец.
+Закрытие CM handle не посылает DISCONNECT удалённым владельцам. Механизм NCD не меняется.
+
+## 5. Отправка медиа — backpressure через локальный буфер
+
+Требование: не дропать аудио при переполнении роутера — держим в локальном буфере
+отправки, дренируем при появлении места.
+
+Механика (`etcp_router` уже предоставляет):
+- `etcp_route_send(force=0)` возвращает `-1`, когда `send_q` роутера полон
+  (`count >= ROUTER_MAX_SEND_Q_PACKETS`).
+- `etcp_router_send_q_has_room(...)` — есть ли место (порог `ROUTER_MAX_SEND_Q_PACKETS-1`).
+- `etcp_router_on_send_ready(..., &waiter, drain_cb, arg)` — одноразовый waiter:
+  колбэк вызывается, когда `send_q->count <= threshold` (освободилось место).
+
+В сессии:
+- `tx_q` — локальная FIFO очередь закодированных кадров (ll_entry с dgram), ёмкостью
+  15с (750 кадров). При переполнении — дроп старейшего + счётчик `c_tx_dropped`.
+- Алгоритм (`call_tx_flush`): пока `tx_q` не пуст:
+  - если `send_q_has_room` → `queue_data_get` + `etcp_route_send(force=1)` (после проверки места);
+  - иначе — если waiter не зарегистрирован → `etcp_router_on_send_ready(... drain_cb)` и выход.
+- `drain_cb(q, arg)` → снова `call_tx_flush(session)` (re-arm при необходимости).
+- Весь код — в uasync-потоке (single-threaded, реентерабельность как в
+  `media_delivery.c:stream_send_chunk_cb`).
+
+## 6. Потоки и жизненный цикл
+
+`call_session`, CM handle, очередь TX и таймеры принадлежат uasync-потоку.
+Аудиопоток кодирует PCM и постит `call_send_media`; приём в uasync кладёт Opus в `call_jitter`.
+Декодер, SoundTouch и генератор тонов принадлежат аудиопотоку.
+Кольцо кодированных кадров и снимок статистики защищены мьютексом; статистика не читает SoundTouch из другого потока.
+`CallTimeline` хранит фактическое соответствие входных участков SoundTouch выходному PCM.
+Платформа публикует позицию воспроизведения с локальной монотонной меткой; `call_audio_get_clock`
+возвращает исходный PTS слышимого участка. Локальная тишина и тоны удерживают PTS.
+Невалидная/устаревшая отметка устройства не разрешает продвижение видео. Контракт и ограничения — `call_video.txt`.
+
+GUI запускает аудиоустройство по CALL_ACCEPTED. При CALL_ENDED начинается финальный тон;
+устройство останавливается перед `call_audio_release`. Явное завершение звонка прекращает
+воспроизведение накопленной речи и включает тон завершения — на обеих платформах.
+Android останавливает гудки до настройки звонкового аудиотракта. После выбора маршрута
+capture/play потоки независимо создают и запускают AudioRecord/AudioTrack; каждый сразу обслуживает своё направление.
+`start()` подтверждает запуск подготовки, ошибки устройств передаются владельцу на main через `onFailure`.
+Ошибка любого направления завершает звонок. Общий `stop()` отменяет подготовку, разблокирует I/O и ждёт оба потока
+до освобождения Android-устройств и native-аудиостека. Отдельные locks защищают подготовку/остановку каждого устройства.
+Замер AEC планируется через 300мс после готовности обоих направлений и не задерживает воспроизведение.
+При наличии Telecom Connection режимом и выходом звонка управляет только Telecom.
+ACTIVE запрашивается до создания аудиоустройств; AudioManager/прямой preferred device не дублируют выбор.
+На API 34+ маршрут запрашивается через доступный CallEndpoint, на старых — через Connection.setAudioRoute.
+Подтверждённый маршрут приходит из callback системы, отдельно от желания пользователя; ошибка запроса логируется.
+Если Connection ещё нет, используется AudioManager. Поздняя регистрация передаёт управление Telecom,
+снимая заявку приложения на режим и прямые устройства. Рация сохраняет отдельный AudioManager-путь.
+Реальное время запуска/переключения зависит от Android и требует проверки на устройстве.
+Маршрутизатор использует один снимок входных/выходных устройств; обновляет его при старте,
+событиях устройств/BT-профиля и явной переоценке. По завершении снимок освобождается.
+INFO-логи Android показывают длительности настройки режима, регистрации callback, BT-профиля, выбора маршрута,
+создания/старта устройств, первого чтения микрофона и первой записи в AudioTrack, а также готовность другого направления.
+Общий `call_audio` логирует время ожидания первого PCM; запись в AudioTrack может содержать начальную тишину.
+Эффективный рабочий буфер AudioTrack на всех поддерживаемых API при старте запрашивается размером
+два блока PCM (40мс); на API 31+ стартовый порог следует фактически принятому размеру.
+Ёмкость выделенной памяти может быть больше. Ограничение повторяется по callback фактической
+смены выхода на main, под trackLock; callback старого AudioTrack игнорируется и снимается при stop.
+Подачу PCM задаёт свободное место в AudioTrack, без дополнительного таймера 20мс.
+Частичная запись удерживает остаток одного блока до полной передачи; следующий pull ждёт.
+Сетевой запас остаётся в адаптивном JB, его рост и SoundTouch-догон не изменены.
+Лог `playback buffering` показывает причину настройки, запрошенный/принятый размер, порог и ёмкость;
+ежесекундный `audio summary` — queueUs, текущий порог и underruns; новый episode underrun имеет уровень WARN.
+Это очередь AudioTrack, а не полная сквозная задержка и не сетевой jitter reserve.
+Ранее на Samsung startFrames=1920 был принят, но без ограничения рабочего буфера
+written-played оставался 120–160мс; одного стартового порога недостаточно.
+Замер Samsung подтвердил постоянную очередь 40мс. При прежнем параллельном управлении маршрутом
+AudioTrack пересоздавался, очередь временно достигала 160мс, а ожидание свободного места — 328–336мс.
+При старте AudioTrack.play занимал 1080мс. После перехода к единственному владельцу Telecom
+в проверенном звонке старт занял 62мс, очередь оставалась не более 40мс и при смене выхода.
+Переключение всё ещё останавливало потребление на 293–328мс; этот всплеск принимает сетевой JB.
+
+На desktop `AudioDiag: capture clock` при call=debug выводит секундную сводку исходных backend-блоков:
+число блоков/сэмплов, накопленную последовательность, диапазон ошибки относительно конца предыдущего блока,
+latency PulseAudio, число скачков >2мс, hole-сэмплы и блоки без достоверного измерения.
+Первый скачок за секунду содержит обе latency/поправки конвертера, expected/actual PTS и монотонное время.
+Backend публикует только числовой снимок в ограниченное кольцо; форматирование выполняет reporter.
+Исходный backend-снимок остаётся наблюдением. В capture worker позиция PCM задаёт непрерывные PTS,
+а backend медленно корректирует их привязку: постоянная времени 2с, предел 0.5% (100мкс на 20мс PCM).
+Скорректированное время используется и для Opus, и для выбора AEC-референса. Сам PCM не изменяется.
+Разрыв sequence, смена route и скачок исходных меток >20мс по-прежнему сбрасывают capture/AEC и эпоху;
+порог 2мс в call_audio не увеличивается. Секундный `voice-io: capture clock` показывает phase/error/adjustment.
+Тесты проверяют десять минут дрейфа +/-300ppm, скачки оценки до 14мс, разбиение чанков 25мс на Opus 20мс,
+сохранность PCM, явную потерю, смену устройства и большой разрыв исходных часов.
+Счётчик sequence описывает полученные backend-сэмплы; отсутствие потерь очереди само по себе
+не доказывает непрерывность физического захвата. Проверять вместе с hole/overflow и route-событиями.
+
+Для захвата звонка desktop явно запрашивает период 20мс вместо дефолта PulseAudio 25мс;
+фактический период сообщает `audio: call-capture initialized`. Сборщик по-прежнему принимает произвольные чанки.
+Секундные замеры задержки при `call=debug`:
+- `voice-io: capture latency`: возраст первого сэмпла перед native feed (включает сам блок 20мс),
+  подготовка/AEC в worker и вызов native feed; диапазоны min/avg/max в микросекундах.
+- `voice-io: playback latency`: приблизительный остаток PCM после mix, включая частичный блок,
+  длительность pull и недостающие сэмплы. Это очередь приложения, отдельно от backend.
+- `AudioDiag: playback clock`: latency backend, задержка конвертера/cache и максимальный размер
+  backend-порции в микросекундах. При measured=0 нулевые границы не означают нулевую задержку.
+- Windows `AudioDiag: WASAPI queue`: текущий padding shared-mode, отдельный stream latency,
+  converter/cache, размер callback и незавершённого mapped buffer. Диапазоны — min/avg/max в мкс;
+  `padding_samples=0` означает отсутствие пригодного замера, а не пустую очередь.
+  Снимок снимается перед заполнением client PCM; запись и форматирование выполняет reporter.
+  `AudioDiag: audio timing` для стадий `callback`/`write` при `call=debug` показывает интервалы
+  callback и время блокирующей передачи в WASAPI. HRESULT ошибок и потери диагностической очереди логируются.
+  Снимки только наблюдают: Windows-аудиочасы остаются `callback-estimate` (`measured=0`).
+- `video playout`: показанные кадры, `speed_ppm`, диапазон A/V-фазы, интервалы показа,
+  опоздание worker и ожидания аудиочасов. Опоздание кадра не вызывает пропуск; догон до 1.6x.
+- Desktop `video RX worker`: число декодированных кадров, максимальное время декодирования,
+  возраст кадра после декодирования и опоздание пробуждения worker после sleep. Снимок аудио
+  содержит `audio_measured`, PTS и позиции played/written. Все эти строки относятся к `call=debug`;
+  `video=trace` для этой диагностики не требуется.
+- `video GUI delivery`: доставленные изображения, ожидание уведомления, промежуток доставки,
+  `paint_wait_max_us` до подтверждения рисования. В GUI один ожидающий кадр, замены нет.
+- `video port TX paused/resumed`: сохранённый хвост пачки, первый ID, длительность ожидания
+  и число повторов. Busy сохраняет encoded-кадры и не запрашивает KEY.
+- `video port RX full/drained`: заполнение и полная разгрузка encoded FIFO перед возобновлением
+  приёма. Hysteresis переносит ограничение до новых входов sender encoder, освобождая запас для догона.
+- `call audio TX timing`: ожидание g_mtx, обработка/кодирование под ним, ожидание posted task;
+  post включает ожидание lock при выполнении задачи, его разрешение 100мкс. На Android этот же
+  замер обработки включает программный AEC, на desktop AEC уже выполнен в capture worker.
+- `call audio TX queue`: число ожидающих кадров, возраст старейшего и avg/max ожидания кадров,
+  переданных роутеру за интервал. Отправка роутеру не является подтверждением доставки пиру.
+- Android `audio capture latency`: возраст первого сэмпла перед native feed и число измеренных
+  привязок; дополнительные поля старта устройств разделяют min-buffer query, constructor, routing и buffer setup.
+Возраст PCM содержит часть измеренной обработки: эти числа нельзя механически складывать.
+PTS/возраст используют локальный MONOTONIC, интервалы внутри native — локальный get_time_us/get_time_tb;
+эти временные базы и часы разных устройств напрямую не вычитаются. Все сводки формируются вне device callback.
+Период захвата 20мс и новые измерения требуют контрольного звонка; дополнительная desktop PCM-очередь,
+жизненный цикл подготовки Android и таймер показа видео этим изменением не менялись.
+
+На Android `CallPlaybackBuffer` подбирает рабочую очередь отдельно от JB/SoundTouch:
+после 30с наблюдаемого продвижения playback head без underrun пробует уменьшить её на один
+блок PCM (960 сэмплов, 20мс), до одного блока или фактического минимума устройства.
+При росте AudioTrack.underrunCount добавляет один блок в пределах выделенной ёмкости.
+Интервал следующей пробы удваивается (60/120/240/300с), чтобы не повторять частые неудачные уменьшения.
+После старта, запроса/подтверждения маршрута и увеличения даются 2с на стабилизацию;
+после уменьшения первый underrun учитывается немедленно. Отсутствие продвижения head или
+пропуск наблюдений >1с обнуляет стабильный участок. Сброс системного счётчика учитывается отдельно.
+Фактическая смена выхода начинает подбор с 40мс заново. Непринятая меньшая заявка фиксирует
+нижнюю границу до следующего выхода; ошибки API выключают подбор с WARN/ERROR, сохраняя воспроизведение.
+Reporter управляет размером под trackLock независимо от фильтра debug; playback не берёт этот lock.
+Нет flush/recreate, частичная запись PCM сохраняется. После смены размера/выхода через секунду
+повторно измеряется задержка для AEC. Ожидание полного буфера и недостача сети не увеличивают его размер.
+Лог настройки содержит reason, previous/requested/actualFrames и прирост underruns;
+достижение ёмкости предупреждает не чаще раза в 10с. Принятие и стабильность 20мс ещё требуют
+проверки на Samsung; буферы HAL и Bluetooth могут добавлять собственную задержку.
+На desktop адаптация устройства ещё не реализована: выход принадлежит SoundManager,
+изменение backend-буфера должно выполняться его владельцем, а не отдельным звонком.
+
+Диагностика Android при `call=debug`: playback сохраняет один числовой снимок на блок (20мс)
+в кольце 512 элементов, без форматирования/вывода. Отдельный reporter раз в 200мс забирает записи;
+раз в секунду выводит `audio summary` с min/avg/max очередей, задержек pull/write и опоздания потока,
+целевым запасом/разбросом доставки JB, темпом, недостающим PCM и отдельными счётчиками JB/AudioTrack.
+Снимок JB не сбрасывает события для CALL_STATS. encodedMs — очередь Opus после pull,
+processingMs — оставшийся PCM SoundTouch в длительности исходной речи; reserveMs зависит только от доставки.
+Reporter опрашивает AudioTimestamp, routedDevice, underrunCount и размеры буфера не чаще раза в 200мс.
+Playback читает только опубликованный неизменяемый снимок. Его begin/end и возраст deviceAgeUs
+отличают задержку опроса от задержки аудио; stampQueryUs/routeQueryUs/propertiesQueryUs показывают стоимость запросов.
+Android API может удерживать общие внутренние locks даже при вызове из reporter: перенос убирает
+прямое ожидание диагностического запроса в playback, но сам по себе не доказывает отсутствие влияния на write/head.
+frame/time аппаратного timestamp и время начала опроса печатаются отдельно;
+при недоступности стоит stampOk=0. Времена trace — MONOTONIC; очередь устройства — written-played.
+Эти показатели нельзя складывать с возрастом AudioTimestamp как независимые задержки.
+В playback отдельно измеряются writeCallUs (только вызовы write), headCallUs (чтение позиции),
+progressCallUs (публикация позиции ядру), jbSnapshotUs (нативный снимок), writeSpanUs (весь цикл записи)
+и blockUs (pull до формирования строки). При частичных записях длительности вызовов суммируются за блок.
+pullGapExcessUs — превышение интервала между началами соседних pull над 20мс;
+включает ожидание устройства, а не только задержку планировщика (прежнее поле wakeLateUs удалено).
+Старое поле writeUs включало чтение позиции и прогресс: его нельзя трактовать как длительность одного AudioTrack.write.
+Stop дожидается reporter, включая непрерываемый Android-запрос, до освобождения AudioTrack.
+
+`audio detail` сохраняет 2с до и 3с после старта, фактической смены routedDevice или новой аномалии:
+очередь устройства >100мс в течение секунды, отсутствие продвижения head 100мс при наличии данных,
+либо новый episode underrun (затухает через 3с без повторений). Порог очереди — диагностический,
+не настройка JB и не изменение воспроизведения. События внутри окна объединяются, между выгрузками
+не менее 10с; продолжающаяся аномалия не создаёт повторных дампов. Восстановление логируется INFO.
+Подробные строки содержат по четыре снимка и заголовок с порядком колонок; при stop окно может быть неполным.
+Переполнение кольца при задержке reporter имеет отдельный WARN lost=N. Аудиоданные не сохраняются.
+Выключение call=debug прекращает сбор/выгрузку; буфер и reporter освобождаются с playback worker.
+Сравнивать сводки следует по call ID и monoUs; рост сетевого запаса сам по себе не является ошибкой.
+
+## 7. Буфер звонка и восстановление
+
+`call_jitter` независим от `radio_jitter`: рация сохраняет свои правила задержки и сброса.
+Буфер звонка хранит до 750 кодированных кадров (15с): 10с перебоя и 5с запаса.
+Целевой запас — `clamp(max-min, 60, max_reserve_ms)` мс по изменению задержки доставки:
+на входящем кадре накапливается разность интервалов приёма и отправки, десять секундных интервалов хранят её экстремумы.
+Отправитель уже передаёт timestamp в CALL_MEDIA; смещение часов пиров исключается, переполнение uint32 учитывается.
+Подготовка местного аудиоустройства и ускоренное воспроизведение очереди не изменяют оценку доставки.
+Минимум/максимум глубины очереди для GUI собираются отдельно в аудиопотоке за те же десять секунд.
+Верхний предел задаётся `call_jitter_max_reserve_ms`: 500–2000 мс, по умолчанию 1000 мс.
+Настройка есть в аудиопараметрах desktop и Android и применяется к следующему звонку.
+Начальное и повторное накопление ждёт этот запас; увеличение запаса не прерывает текущую речь.
+Ускорение зависит от превышения запаса. При отсутствии входящих кадров обычное воспроизведение
+может исчерпать запас: это не жёсткий запрет воспроизведения ниже цели.
+Статистика раз в секунду отображается в desktop-окне и Android-экране звонка (под кнопками): глубина, запас, минимум/максимум,
+темп, RTT, удаления при переполнении и недостачи PCM. Диагностика буфера — категория `call=debug`.
+После восстановления кадры последовательно декодируются; темп плавно растёт до 1.6x
+без изменения высоты голоса: линейный предел роста 1.0x→1.6x за 500мс воспроизведения.
+При уменьшении накопления целевой темп снижается к 1.0x; скорость снижения ограничена тем же пределом.
+Пауза аудиоустройства не сбрасывает буфер. Переполнение удаляет старейший кадр с WARN и счётчиком.
+
+Роутер сохраняет последовательность и неподтверждённые данные при смене пути.
+Для сервиса звонка срок без прогресса ACK увеличен примерно до 20с; прочие сервисы сохраняют прежний срок.
+Перезапуск удалённого процесса/роутерной сессии не является кратковременным перебоем пути и может сбросить данные.
+SoundTouch: `USE_QUICKSEEK=1, SEQUENCE_MS=20, SEEKWINDOW_MS=10, OVERLAP_MS=4`.
+
+## 8. Тоны и диагностика
+
+- **Исходящий звонок — две фазы с разными гудками** (у вызывающего):
+  - фаза 1 «пытаемся связаться» (`OUTGOING`: INVITE отправлен/ретранслируется, маршрут
+    устанавливается) — гудок «соединение» (короткие бипы);
+  - фаза 2 «звоним» (`RINGING`: получен RINGING, у пира идёт вызов) — длинные гудки (ringback).
+  Гудки генерируются платформенно-нативно: desktop — цикличные MP3 через `SoundManager`
+  (`call_connecting`/`call_ringing`), Android — цикличные MP3 через `CallRingback`/`MediaPlayer`.
+  Переключение — по `CHAT_EVT_CALL_RINGING`,
+  остановка — по `CALL_ACCEPTED`/`CALL_ENDED`/`CALL_ERROR`/hangup.
+- **Начальное ожидание первого PCM** → тишина без сигнала потери звука. Подготовка удалённого микрофона
+  и начальное накопление jitter не считаются перебоем. Существующий таймаут 20с без медиа действует с ACTIVE.
+- **Недобор PCM ≥500мс после начала воспроизведения** → в `call_audio_pull_pcm` воспроизводится
+  `CALL_TONE_GLITCH`: `пи-пи (2×150мс, gap 100мс) … тишина до 1.0с … пи(200мс)
+  пауза(200мс) пи(200мс)`, 1000 Гц, цикл пока длится сталл. До порога — тишина при нехватке PCM.
+  При возобновлении PCM сигнал останавливается; одного входящего пакета без достаточного запаса недостаточно.
+- **Завершение звонка → всегда** `CALL_TONE_ENDED`: 3 нисходящих 700/500/400 Гц по 150 мс.
+- Счётчики: tx/rx кадры, `c_tx_dropped`/`c_rx_dropped`, дропы буфера, сталлы,
+  tempo-события, причины завершения. Логи `DEBUG_CATEGORY_CALL` (+стата раз в 1с).
+
+## 9. GUI-события (extend `chat_event.h` + `gui_bridge.h` + android)
+
+```
+CHAT_EVT_CALL_INCOMING   32  [ch_id_len][ch_id][caller_node_id:8][call_id:8]
+CHAT_EVT_CALL_RINGING    33  [call_id:8]
+CHAT_EVT_CALL_ACCEPTED   34  [call_id:8]
+CHAT_EVT_CALL_ENDED      35  [call_id:8][reason:1]
+CHAT_EVT_CALL_DECLINED   36  [call_id:8][reason:1]
+CHAT_EVT_CALL_STATS      39  [call_id:8][rtt:2][buffer:2][tempo:2][dropped:2][underruns:2][min:2][max:2][reserve:2]
+CHAT_EVT_CALL_ERROR      38  [call_id:8][err:1][text:var]
+CHAT_EVT_CALL_AUDIO_ROUTE 39 (Android: текущий маршрут/наличие гарнитуры)
+```
+
+## 10. Основные функции публичного API
+
+`call.h`: сигналинг и отправка готового Opus выполняются в uasync-потоке.
+Из других потоков команды передаются через `uasync_post`/мост GUI и соответствующие `call_*_trampoline`.
+`ch_id` — идентификатор CHAT-группы либо `dm:<conv_id>`; `out_call_id` — значение, заранее сгенерированное вызывающим.
+
+```c
+void call_start(struct UTUN_INSTANCE* inst, const char* ch_id, uint64_t peer_node_id, uint64_t out_call_id);
+void call_accept(struct UTUN_INSTANCE* inst, uint64_t call_id);
+void call_decline(struct UTUN_INSTANCE* inst, uint64_t call_id);
+void call_hangup(struct UTUN_INSTANCE* inst, uint64_t call_id);
+int call_is_online(struct UTUN_INSTANCE* inst, const char* ch_id, uint64_t peer_node_id);
+int call_send_media(struct UTUN_INSTANCE* inst, uint64_t call_id, const uint8_t* opus, int len,
+                    const struct call_capture_time* timing);
+```
+
+`call_audio.h`: движок сам кодирует PCM и ставит отправку Opus в uasync.
+Захват и воспроизведение используют по одному аудиопотоку на направление.
+
+```c
+int call_audio_feed_pcm(uint64_t call_id, const int16_t* pcm, int count, int64_t capture_pts_us);
+int call_audio_feed_prepared_pcm(uint64_t call_id, const int16_t* pcm, const uint8_t* mute_mask, int64_t capture_pts_us);
+int call_audio_pull_pcm(uint64_t call_id, int16_t* out, int max_samples);
+void call_audio_release(uint64_t call_id);
+```
+
+`feed_pcm` принимает ровно 960 отсчётов; `feed_prepared_pcm` — 960 отсчётов после платформенного AEC
+и маску mute. `call_audio_release` вызывается в GUI-потоке после остановки обоих направлений I/O.
+Создание движка — `call_audio_start`, для подготовленного PCM — `call_audio_start_prepared`.
+Видео настраивается через `call_video_configure`, кадры отправляются через `call_video_send_frame`
+в uasync-потоке; полный контракт — в `call_video_transport.h`.
+
+`call_init / call_destroy` вызываются из `chat_service_start / chat_service_stop` в `utun_instance.c`:
+инициализация после `dm_core_init`, освобождение перед `dm_core_destroy`.
+
+## 11. Платформенный I/O
+
+- **Desktop:** `tools/chatgui/src/call_audio_engine.cpp` — miniaudio full-duplex
+  (capture через VoiceAudioIo → `call_audio_feed_prepared_pcm`, `call_audio_pull_pcm` → playback) + окно звонка (UI)
+  + события в `gui_bridge_impl.cpp`.
+- **Android:** JNI `nativeCall*` + Kotlin `AudioRecord`/`AudioTrack`.
+  **Переключение источника:** `AudioManager` (API31+ `setCommunicationDevice` +
+  `availableCommunicationDevices`; fallback `setSpeakerphoneOn` + `startBluetoothSco`),
+  детект гарнитуры (`ACTION_HEADSET_PLUG`, BT-профиль, `ACTION_SCO_AUDIO_STATE_UPDATED`),
+  кнопка-цикл трубка/громкая/гарнитура, авто-выбор гарнитуры. `nativeCallSetAudioRoute(route)`.
+
+## 12. Сборка
+
+- `src/Makefile.am` + `tests/Makefile.am`: `call.c` (C, без `.cpp`). `src/call/` в include path.
+- `tools/chatgui/libutun/CMakeLists.txt`: +`call_audio.c`, `call_tones.c`,
+  `audio_jitter.cpp`, soundtouch sources (AAFilter, FIFOSampleBuffer, FIRFilter,
+  InterpolateCubic/Linear/Shannon, RateTransposer, SoundTouch, TDStretch, cpu_detect_x86,
+  mmx_optimized, sse_optimized) как C++. `call.c` попадёт через GLOB `src/*.c`.
+- `tools/chatgui-android/libutun_lite/CMakeLists.txt` + `utun_sources.cmake`:
+  `LANGUAGES C CXX`, те же файлы.
+- `src/transport_layer/etcp_api.h`: `ETCP_RT_ID_CALL=0x36`, `ETCP_RT_ID_CALL_VIDEO_CONTROL=0x3D`,
+  `ETCP_RT_ID_CALL_VIDEO=0x3E`, `ETCP_RT_ID_CALL_AUDIO=0x3F`.
+- `lib/debug_config.h`: `DEBUG_CATEGORY_CALL 31`, `DEBUG_CATEGORY_COUNT` → 32.
+
+## 13. Порядок задач
+
+1. `call_proto.h` + svc_id + `DEBUG_CATEGORY_CALL`.
+2. `call.c` (машина состояний, backpressure-media, watchdog, события, API) + `chat_core` хуки.
+3. `audio_jitter.cpp` (SoundTouch) + `test_audio_jitter.c`.
+4. `call_tones.c` + `call_audio.c` (Opus + фрейминг + тон-обвязка).
+5. Desktop: `call_audio_engine.cpp` + UI + события.
+6. Android: JNI + Kotlin AudioRecord/Track + переключение источника + UI.
+7. Сборка (Makefile.am / CMake обе).
+8. `test_call.c` (два инстанса), интеграция desktop↔desktop и desktop↔android.

doc/db_sync_v2.md

@@ -1,292 +0,0 @@
-# DB Sync Protocol v2 — Техническое задание
-
-## 1. Проблема
-
-chain_hash = SHA256(prev_chain_hash || id || ts || datahash) — хеш-цепочка, где хеш каждой записи зависит от предыдущей.
-
-`db_record_insert` (db_sync.c:341-463) при вставке записи в середину сортированного порядка делает каскадный пересчёт chain_hash всех последующих записей — O(N). При двустороннем обмене PUSH'ами получается O(N²).
-
-## 2. Решение
-
-**Разделить два концерна:**
-- **Сравнение при синхронизации** — перейти на `datahash` (первые 8 байт SHA256(data), позиционно-независимый). Не требует каскада.
-- **Целостность цепочки** — `chain_hash` остаётся в схеме БД, но используется только для однократной стартап-проверки и диагностики.
-
-**Синхронизация:** per-peer позиционная (`synced_pos`). При PUSH каскад не делается. При SEND_DATA батч-вставка + один каскад после батча.
-
-## 3. Модель данных
-
-### 3.1. SI_PEER
-
-```c
-struct SI_PEER {
-    uint64_t node_id;
-    uint32_t synced_pos;    // последняя подтверждённо общая позиция (0-based index)
-    uint8_t  sync_state;    // 0=not_synced, 1=syncing, 2=synced
-};
-```
-
-- `synced_pos` = индекс последней записи в глобальном порядке `ORDER BY timestamp, datahash`, для которой chain_hash (а после v2 — datahash) подтверждённо совпадает у обоих пиров.
-- При PUSH-вставке записи на позицию P, для всех peer'ов у которых `synced_pos >= P`: `synced_pos = P - 1`.
-- При SEND_DATA: `synced_pos = from + received_count - 1`.
-
-### 3.2. Схема БД (без изменений)
-
-```sql
-CREATE TABLE "db_sync_<name>_<id>" (
-    timestamp     INTEGER NOT NULL,
-    datahash      INTEGER NOT NULL,
-    id            INTEGER NOT NULL,
-    chain_hash    BLOB NOT NULL,
-    author        INTEGER NOT NULL,
-    flags         INTEGER NOT NULL DEFAULT 0,
-    data          BLOB,
-    author_signature BLOB,
-    delivered_peers INTEGER NOT NULL DEFAULT 0,
-    delivery_chain TEXT NOT NULL DEFAULT '',
-    PRIMARY KEY (timestamp, datahash)
-);
-```
-
-## 4. Wire-формат
-
-### 4.1. Сообщения, которые меняются
-
-#### INIT_SYNC
-
-```
-Было:  [type:1][count:4][last_chain_hash:32] = 37 байт
-Стало: [type:1][count:4]                      = 5 байт
-```
-
-#### INIT_RESP
-
-```
-Было:  [type:1][tp:4][chain_at_tp:32][sc:1][(pos:4,chain_hash:32)*sc]
-Стало: [type:1][tp:4][dh_at_tp:8]    [sc:1][(pos:4,dh:8)*sc]
-
-  dh_at_tp   — datahash на позиции tp (8 байт вместо 32)
-  sparse     — datahash вместо chain_hash (8 байт на элемент вместо 32)
-  
-  При sc=0 (exact match): длина 1+4+8+1 = 14 байт (было 37)
-  При sc=16 sparse:       длина 14 + 16*12 = 206 байт (было 37 + 16*36 = 613)
-```
-
-#### SYNC_DONE
-
-```
-Было:  [type:1][count:4][last_chain_hash:32] = 37 байт
-Стало: [type:1][count:4][last_dh:8]           = 13 байт
-```
-
-### 4.2. Сообщения, которые НЕ меняются
-
-- **PUSH**: `[type:1][id:8][ts:8][dh:8][dlen:4][data][sig_len:1][sig]` — без изменений. `prev_ch` НЕ добавляется.
-- **ACK_PUSH**: `[type:1][dh:8][ts:8]` — без изменений.
-- **REFINE**: `[type:1][from:4][to:4][hc:1][(pos:4,dh:8)*hc]` — уже использует datahash, без изменений.
-- **SEND_DATA**: `[type:1][from:4][count:2][(id:8,ts:8,dh:8,dlen:4,data,sig_len:1,sig)*count]` — без изменений.
-- **ERROR**: `[type:1][code:1]` — без изменений.
-
-## 5. Новые/изменённые функции
-
-### 5.1. `db_cascade_from`
-
-```c
-static void db_cascade_from(struct DB_SYNC_INSTANCE* si, uint32_t from_pos);
-```
-
-Выполняет каскадный пересчёт `chain_hash` для записей с позиции `from_pos` до конца таблицы.
-
-Алгоритм:
-1. BEGIN IMMEDIATE
-2. SELECT chain_hash записи на позиции `from_pos - 1` (или zero если from_pos = 0) как prev_ch
-3. SELECT id, timestamp, datahash от позиции from_pos до конца
-4. Для каждой: chain_hash = SHA256(prev_ch || id || ts || dh), UPDATE в БД, prev_ch = новый chain_hash
-5. COMMIT
-
-Выделяется из текущего кода `db_record_insert` (строки 412-451) в отдельную функцию.
-
-### 5.2. `db_record_insert` — новый параметр
-
-```c
-static int db_record_insert(struct DB_SYNC_INSTANCE* si,
-                            uint64_t id, uint64_t ts, uint64_t dh,
-                            const char* json, size_t jlen,
-                            const uint8_t* sig, size_t sig_len,
-                            int do_cascade);
-```
-
-- `do_cascade=1` — после INSERT выполняется cascade (строки 412-451). Используется для локальных вставок.
-- `do_cascade=0` — без cascade. Используется для PUSH и SEND_DATA (каскад делается отдельно).
-
-### 5.3. `db_verify_chain` (стартап-проверка)
-
-```c
-static void db_verify_chain(struct DB_SYNC_INSTANCE* si);
-```
-
-Вызывается один раз после `db_sync_instance_add` (перед инициацией sync с пирами).
-
-Алгоритм:
-1. Проход записей 0..N-1 в порядке `ORDER BY timestamp, datahash`
-2. Для каждой: chain_hash = SHA256(prev_ch || id || ts || dh)
-3. Сравнить с хранимым в БД
-4. При первом расхождении на позиции P: пересчитать цепочку от P до конца через `db_cascade_from(si, P)`. Завершить.
-
-Сложность: O(N) SHA256, однократно при старте.
-
-### 5.4. `si_find_pos` (новая)
-
-```c
-static uint32_t si_find_pos(struct DB_SYNC_INSTANCE* si,
-                            uint64_t ts, uint64_t dh);
-```
-
-Возвращает позицию (0-based index) записи с ключом `(ts, dh)` в глобальном порядке. Используется после вставки PUSH для корректировки `synced_pos`.
-
-### 5.5. `db_datahash_at` — уже существует (стр. 295)
-
-Возвращает `datahash` на заданной позиции. Используется для сравнения в INIT_SYNC/INIT_RESP/SYNC_DONE.
-
-## 6. Обработчики сообщений
-
-### 6.1. PUSH (`db_handle_push`)
-
-```
-Было:  db_record_insert(si, ...,  /* cascade встроен */)
-Стало: db_record_insert(si, ...,  /* do_cascade= */ 0)
-       uint32_t pos = si_find_pos(si, ts, dh);
-       for each peer: if peer->synced_pos >= pos: peer->synced_pos = pos - 1;
-```
-
-### 6.2. INIT_SYNC (`db_handle_init_sync`)
-
-```
-Изменения:
-  - Принимает [count:4] вместо [count:4][chain_hash:32] (проверка len >= 5 вместо 36)
-  - Сравнение: datahash вместо chain_hash (8 байт вместо 32)
-  - sparse: datahash вместо chain_hash (8 байт на элемент вместо 32)
-  - Размер sparse-элемента: 4(pos) + 8(dh) = 12 байт (было 4+32=36)
-  - resp буфер: 4096 → достаточно (14 + 16*12 = 206 байт при max sparse)
-```
-
-### 6.3. INIT_RESP (`db_handle_init_resp`)
-
-```
-Изменения:
-  - Принимает [tp:4][dh:8][sc:1][...] вместо [tp:4][ch:32][sc:1][...]
-  - Проверка len >= 13 вместо 37
-  - Сравнение: datahash вместо chain_hash
-  - Пустая БД пира: zero-хеш 8 байт вместо 32
-  - Sparse элементы: 12 байт вместо 36
-  - При совпадении: synced_pos = tp (в дополнение к sync_state = 2)
-```
-
-### 6.4. SEND_DATA (`db_handle_send_data`)
-
-```
-Стало:
-  struct SI_PEER* sp = si_peer_find(si, src);
-  uint32_t fix_from = sp ? sp->synced_pos : 0;
-
-  for each record:
-     db_record_insert(si, ..., /* do_cascade= */ 0);
-
-  db_cascade_from(si, fix_from);
-
-  sp->synced_pos = from + received_count - 1;
-  sp->sync_state = 2;
-```
-
-Каскад от `fix_from` (позиция, которая была synced ДО этого батча) гарантирует, что все chain_hash после этой точки пересчитаны — независимо от того, какие PUSH'и испортили их между синхронизациями.
-
-### 6.5. SYNC_DONE (`db_handle_sync_done`)
-
-```
-Изменения:
-  - Принимает [count:4][last_dh:8] вместо [count:4][last_chain_hash:32] (len >= 13 вместо 36)
-  - Сравнение последнего datahash вместо chain_hash
-```
-
-## 7. Механика многопировой синхронизации
-
-При наличии нескольких пиров с одинаковым `sync_state` (например, syncing=1) выбирается пир с минимальным `synced_pos` — у него самый старый общий префикс. После завершения его синхронизации выбор повторяется.
-
-Это гарантирует: двигаемся от самого старого несинхронизированного участка, не прыгая. Новые записи (в хвосте) синхронизируются последними.
-
-## 8. Полный сценарий: три участника A, B, C
-
-```
-Начальное состояние: все пусты.
-
-=== Шаг 1. A создаёт R1 (ts=1000) ===
-A: PUSH R1 → B, C. Все вставляют в конец, cascade 0.
-synced_pos = 0 у всех.
-
-=== Шаг 2. B создаёт R2 (ts=2000), C создаёт R3 (ts=1500) ===
-B: [R1(1000), R2(2000)], PUSH R2 → A, C.
-   A: R2 в конец. C: R2 в конец.
-C: [R1(1000), R2(2000)]? Нет — C создал R3(1500).
-   C: [R1(1000), R3(1500)] локально, потом PUSH R2 → R2.ts=2000 → в конец.
-   C: [R1(1000), R3(1500), R2(2000)]
-C: PUSH R3 → A, B.
-   A: [R1(1000), R2(2000)] + R3(1500) → между R1 и R2:
-   A: [R1, R3, R2]       ← R3 в середину, cascade ПРОПУЩЕН
-   B: [R1, R3, R2]       ← аналогично
-
-   synced_pos после PUSH R3 на A относительно B:
-     A вставил R3 на поз.1 → synced_pos_B: было 1 → стало 0
-     (A считает, что совпадает с B только на позиции 0)
-
-=== Шаг 3. A инициирует sync с B (чемпион: min synced_pos) ===
-A→B: INIT_SYNC [count=3]
-B→A: INIT_RESP [tp=min(3,3)-1=2, dh_at_tp=H2, sc=2, sparse:{(1,H3),(0,H1)}]
-A проверяет: A@2=R2→dh=H2✓, A@1=R3→dh=H3✓, A@0=R1→dh=H1✓
-→ sync complete, synced_pos_B=2, sync_state=2
-
-=== Шаг 4. Рестарт A ===
-db_verify_chain:
-  pos 0: R1.ch = SHA256(0||R1)          ✓
-  pos 1: R3.ch = SHA256(R1.ch||R3)       ✓   (посчитан при PUSH без cascade — корректен)
-  pos 2: R2.ch = SHA256(R3.ch||R2)       ✗   (STALE: был посчитан как SHA256(R1.ch||R2) до PUSH R3)
-  → расхождение на pos=2 → db_cascade_from(2): пересчёт R2.ch = SHA256(R3.ch||R2) ✓
-
-=== Шаг 5. A, B, C активно обмениваются ===
-Каждый PUSH: вставка без cascade.
-Периодические sync (по min synced_pos): SEND_DATA + один cascade от synced_pos.
-synced_pos растёт.
-```
-
-## 9. Что НЕ трогать
-
-- `db_sync_insert_signed` — локальная вставка. ts всегда монотонный, запись в конец, `do_cascade=1`, каскад всегда 0 строк.
-- TTL cleanup (`db_sync_instance_ttl_cb`) — удаление старых записей. Нужен cascade после удаления (уже существующая логика, не меняется).
-- ACK_PUSH, ERROR, REFINE — без изменений.
-- Схема БД — без изменений.
-- `etcp_bind`/эпилог — без изменений.
-
-## 10. Сложность операций (итого)
-
-| Операция | Каскад | Сложность |
-|----------|--------|-----------|
-| Локальная вставка | 0 строк (конец) | O(1) |
-| PUSH (приём) | нет | O(1) |
-| SEND_DATA (батч N записей) | 1 каскад после батча | O(N + tail) |
-| Стартап-проверка | 1 раз | O(total) |
-| Sync-протокол (INIT_SYNC/INIT_RESP/REFINE) | нет cascade | O(log N) сообщений |
-
-## 11. Порядок реализации
-
-1. **Выделить `db_cascade_from(si, from_pos)`** из тела `db_record_insert`.
-2. **Добавить параметр `do_cascade`** в `db_record_insert`. При `0` — только INSERT, cascade вызывается отдельно.
-3. **Добавить `synced_pos`** в `struct SI_PEER`. Инициализировать в 0.
-4. **Добавить `si_find_pos(si, ts, dh)`** — поиск позиции записи в глобальном порядке.
-5. **Изменить wire-формат** INIT_SYNC, INIT_RESP, SYNC_DONE (chain_hash → datahash, 32→8 байт).
-6. **Изменить обработчики**:
-   - `db_handle_init_sync`: новые размеры, datahash вместо chain_hash
-   - `db_handle_init_resp`: новые размеры, datahash вместо chain_hash, обновлять synced_pos
-   - `db_handle_send_data`: `do_cascade=0`, `db_cascade_from(fix_from)`, обновить synced_pos
-   - `db_handle_push`: `do_cascade=0`, скорректировать все synced_pos
-   - `db_handle_sync_done`: обновить synced_pos
-7. **Добавить `db_verify_chain(si)`** — вызвать при старте после `db_sync_instance_add`.
-8. **Многопировая синхронизация**: в `db_sync_peer_check_cb` выбирать пира с min synced_pos вместо первого попавшегося.

doc/dm_arch.md

@@ -0,0 +1,228 @@
+# DM: доставка сообщений и файлов
+
+Личные беседы принадлежат `src/dm/`. Общие CHAT-группы используются для знакомства,
+проверки ролей и маршрутизации; группа не становится идентичностью беседы.
+
+## Реализовано
+
+- История и постоянная исходящая очередь сообщений в общей SQLite ядра.
+- Доставка через живой маршрут router, включая BGP-транзит.
+- При отсутствии маршрута — подписанный PUT доступному суперузлу общей группы сторон.
+- Приём после проверки подписи и расшифровки, подтверждение только после commit.
+- Доставка с суперузла после возвращения получателя, независимо от отправителя.
+- Точное удаление промежуточного сообщения и сохранение квитанции для поздних повторов.
+- Подготовка, шифрование, проверка и durable публикация медиа в рабочих потоках.
+- Прямая передача файлов либо custody на отдельном M, доставка после restart и подтверждённое удаление.
+- TTL и квота M; вложения и статусы доставки в Qt и Android.
+- Голосовые Opus и видео MP4 с зашифрованными метаданными; общий ввод и отображение с каналами.
+
+## Идентичность и шифрование
+
+```text
+conv_hash   = SHA256("utun_dm_v" || min(node_a,node_b) || max(node_a,node_b))
+conv_id     = native_u64(conv_hash[0:8]) & 0x7FFFFFFFFFFFFFFF
+content_key = SHA256(X25519(my_private, target_public) || "utun_dm_content")
+msg_nonce   = SHA256(conv_id || author || seq)[..13]
+media_nonce = SHA256("utun_dm_media" || author || media_id || part)[..13]
+```
+
+Префикс conv_hash — 9 ASCII-байт без NUL. ID узлов подаются в хеш в порядке
+байтов хоста; native_u64 читает первые 8 байт хеша в том же порядке.
+Нулевой conv_id заменяется на 1.
+
+Сообщения и медиа используют один content_key target, без ключей отдельных файлов.
+AES-256-CCM: nonce 13 байт, tag 16 байт. Максимальная порция plaintext — 65535 байт;
+порция медиа — 32768 байт. UUID медиа новый для каждой подготовки. Повтор доставки
+использует неизменяемый ciphertext. Повторная подготовка после ошибки требует нового UUID.
+
+Каноническое тело сообщения:
+
+```text
+[conv:8][seq:8][ts:8][author:8][ct_len:1][ct][enc_len:2][ciphertext+tag][author_sig:64]
+```
+
+Автор подписывает все поля до sig. conv связывает автора с получателем.
+Для `ct=file` перед подписью добавляется descriptor `[UUID:16][plaintext_size:8][SHA256(ciphertext):32]`.
+В зашифрованном теле находится `attachment_info`; пути хранения строятся только из UUID.
+Размер plaintext сообщения ограничен 1024 байтами. seq — положительное int64.
+
+```text
+[kind:1][name_len:2][duration_ms:4][width:2][height:2][UTF8_name:name_len][waveform:100, только voice]
+```
+
+Поля метаданных многобайтной длины имеют big-endian формат. kind: 1=file,
+2=voice, 3=video. Имя — basename до 255 байт, без разделителей, управляющих символов
+и некорректного UTF-8. FILE имеет нулевые duration/dimensions; VOICE — положительную
+длительность и 100 символов уровней waveform; VIDEO — длительность и размеры.
+Длительность ограничена 24 часами, размеры — 16384. Метаданные проверяются до
+локального commit и до подтверждения получателем; S/M видят только ciphertext.
+
+Медиа ciphertext — последовательность порций с отдельным tag каждой порции.
+Последняя порция короче; пустой файл содержит один tag. Размер plaintext и SHA256
+ciphertext должны входить в подписанный manifest. Потоковая расшифровка проверяет все
+tags, точный размер и хеш; владелец публикует временный файл только после успеха
+и собственного durable сохранения.
+
+## Владение и данные
+
+- `dm_core`: беседы, история, outbox и подтверждение получателя.
+- `dm_mailbox`: промежуточные сообщения суперузла и квитанции.
+- `dm_crypto`: вывод conv_id, content_key и nonce сообщений без БД/сети.
+- `media_crypto`: общие CCM и потоковые файловые примитивы для DM и групповых вложений.
+- `dm_media`: файлы endpoint, загрузки и отдельная custody M.
+- `dm_mailbox_media`: durable задания S, выбор M и повтор удаления до DELETE_ACK.
+- `file_transfer`: подписанная передача байтов, backpressure и отдельный CM handle каждой операции.
+- `attachment`: формат, валидация и тип метаданных, без сети и БД.
+- `voice_file`: общий Opus-кодек отправки; `attachment_send` готовит файл в worker
+  и передаёт результат отдельно в `chat_core` либо `dm_media`.
+
+```text
+dm_conversations(conv_id, peer_node_id, peer_x25519, peer_ed25519, peer_name,
+                 group_id, last_out_seq, last_in_seq, created_at, last_ts)
+dm_messages(conv_id, dir, seq, ts, author, ct, data, sig)
+dm_outbox(conv_id, seq, body, retry_at)
+dm_pending_messages(recipient, sender, seq, msg, group_id, retry_at)
+dm_mail_receipts(recipient, sender, seq, receipt, group_id)
+```
+
+Запись исходящего сообщения, увеличение seq и запись неизменяемого body в outbox —
+одна транзакция. При ошибке откатывается всё, сообщение не выходит в сеть.
+Приём, создание/обновление беседы и история — также одна транзакция.
+
+Dedup — точный ключ (conv,dir,seq) с проверкой сохранённой подписи. last_in_seq —
+статистика максимального номера, не курсор подтверждения: seq=99 после seq=100
+сохраняется. Тело с другой подписью для уже сохранённого seq отклоняется.
+
+У каждой локальной очереди таймер 1с; порция обработки до 32 задач, повтор задачи
+через 5с. retry_at предотвращает голодание хвоста очереди. Перед отправкой проверяется
+backpressure router. Потеря пути сохраняет durable задачу; остановка отменяет таймеры,
+но сохраняет БД. При старте очередь продолжает работу.
+
+## Подтверждения и протокол
+
+Сервис `ETCP_RT_ID_DM=0x34`: MSG=1, RECEIPT=2.
+
+```text
+["DMACK001":8][conv:8][seq:8][author:8][recipient:8][SHA256(message):32][recipient_sig:64]
+```
+
+Квитанцию создаёт только получатель после commit. Подпись охватывает первые 72 байта.
+Отправитель удаляет outbox только после проверки подписи и точного хеша тела.
+История беседы сохраняется. Подтверждение транспорта router не заменяет квитанцию.
+
+Сервис `ETCP_RT_ID_DM_MAILBOX=0x35`:
+
+```text
+PUT=1     [recipient:8][message]
+DELIVER=2 [message]
+RECEIPT=3 [receipt:136]
+STORED=4  [conv:8][seq:8]
+```
+
+Все пакеты идут с подписью router; unsigned control отклоняется.
+PUT принимается только от автора, при роли supernode=yes у локального узла
+в общей группе автора и получателя. Роль берётся из подписанного adm_tags;
+node_type=4 — производная сетевой классификации, для авторизации не используется.
+storage=yes само по себе не даёт права хранить сообщения.
+
+STORED подтверждает durable запись суперузлом, outbox до квитанции получателя остаётся
+у автора. Суперузел повторяет DELIVER при появлении живого маршрута. RECEIPT проверяется
+по точному сохранённому телу; запись квитанции и удаление копии — одна транзакция.
+Квитанция пересылается автору. Поздний PUT возвращает её и не возрождает задачу.
+
+dm_mail_receipts содержит только служебные квитанции; доставленное содержимое
+с промежуточного узла удаляется. Ранее использовавшийся dm_mail/PULL/HELLO и
+диапазонные ACK не поддерживаются: это devel, совместимость не сохраняется.
+TTL текстовых сообщений не введён; недельный TTL из pm.txt относится к медиа.
+
+## Доставка медиа по pm.txt
+
+1. Общая передача байтов: явные peer/group/file/size, backpressure и CM handle
+   на всю активную операцию. Владение handle сохраняется после DOWN/TIMEOUT.
+   Используется `ETCP_RT_ID_FILE_TRANSFER=0x37`. Один callback читает/отправляет
+   не более 8 КиБ, продолжение через `call_soon`; inflight ограничен 16 пакетами.
+2. Отдельный owner dm_media: подготовка ciphertext, manifest, отправка/скачивание,
+   временные файлы, TTL и лимит хранения. Каталоги dm_media/ и dm_pending/ вне
+   группового обхода очистки orphan-файлов; групповые объявления HAVE_BLOCK не используются.
+3. Суперузел сначала durable регистрирует сообщение и media job, затем выбирает M.
+   M скачивает ciphertext у A и сообщает S подтверждённое хранение, место и expiry.
+4. Текстовая квитанция и квитанция медиа независимы. Получатель подтверждает медиа
+   после проверки, публикации файла и commit. S хранит задачу удаления у M до DELETE_ACK;
+   поздний STORED не возрождает завершённую доставку.
+5. TTL медиа `dm_media_ttl_sec` по умолчанию 604800 с; квота `dm_media_storage_mb`
+   по умолчанию 1024 МиБ. Настройки на M. Новая custody отклоняется при
+   недостатке квоты; уже подтверждённые копии не вытесняются молча раньше срока.
+6. Stop снимает новые задачи и закрывает transfer/CM handles, затем ждёт
+   media_async с живыми owner-контекстами. Группы уничтожаются после owners.
+
+Control `ETCP_RT_ID_DM_MEDIA=0x38`: OFFER, STORE, STORED, RECEIPT, DELETE,
+DELETE_ACK, EXPIRED, REJECT; точные форматы заданы в `dm_media.h` и реализациях owners.
+Подпись router обязательна. Media receipt содержит `DMFILE01`, conv, seq, author,
+recipient, UUID и SHA256 полного подписанного сообщения; B подписывает первые 88 байт.
+Отдельные таблицы `dm_files`, `dm_custody`, `dm_custody_done`, `dm_media_jobs`,
+`dm_media_holders` сохраняют состояния и tombstones. Все выданные grants M
+учитываются при удалении; повторный STORE не продлевает TTL.
+
+Qt и Android получают историю через события ядра: 41 — conv + JSON сообщений,
+45 — JSON бесед. Снимки ограничены 200 записями. Отправка вложения вызывает
+`dm_send_file` в uasync; длительная обработка выполняется в `media_async`.
+Android копирует выбранный URI и сохраняет полученный файл через `Dispatchers.IO`;
+Qt сохраняет файл из контекстного меню в отдельном потоке. Выбор «как файл» сохраняет
+оригинал; «как видео» в Qt использует общий FFmpeg worker и метаданные конечного MP4.
+Android записывает MP4 через CameraX; импорт MP4 проходит через платформенный
+MediaMetadataRetriever в IO. Другие контейнеры на Android отправляются как файлы.
+
+Голосовая запись отдаёт worker собственный PCM либо компрессор без копирования
+в GUI/uasync; worker выполняет flush, Opus-кодирование и вычисление waveform.
+Кодирование Qt и Android использует один `voice_file`. Адресат фиксируется до
+записи, выбора URI и подготовки; завершение не читает текущую беседу GUI.
+Подготовленный PM-файл и Android cache удаляются после копирования, ошибки или отмены;
+пользовательский исходник Qt остаётся во владении пользователя.
+
+Событие 46 `[target_len:1][target][job_UUID:16][state:1]` сообщает начало (0),
+готовность (1) и ошибку (2). Target канала — числовой ID, PM — `dm:<conv_id>`.
+Подготовка, доставка и воспроизведение имеют независимые состояния. UI отображает
+только задания текущей беседы. Состояния файла и delivery receipt приходят в JSON
+41; `content_type`, duration, dimensions и waveform преобразуются в общие роли
+сообщения. Канальные скачивания вызываются контроллером только для каналов;
+PM-файлы доставляются автоматически через `dm_media`.
+
+Android использует общие `ConversationComposer`/`ConversationMessages` для обеих
+бесед; Qt — `InputBar` и `MessageDelegate`. Превью Qt создаются в общем пуле
+с двумя workers; декодирование длинного Opus-файла выполняется вне GUI. Оба плеера
+проверяют заголовок, пакеты и end marker; Qt ограничивает PCM буфер 256 МиБ.
+
+## Проверки
+
+`test_dm`: симметрия ключа target, CCM round-trip, пустое тело, пределы длины,
+неверный ключ/tag, разделение nonce; потоковые файлы на границах 32 КиБ,
+неверные author/UUID/hash, обрезание и лишние байты.
+
+`test_dm_e2e`: реальные A–C–B соединения и BGP; нет физического A–B линка.
+Проверяет out-of-order, dedup/conflict, подписи, SQL rollback при приёме и enqueue,
+ACK чужого тела, отказ mailbox без роли, точное удаление и поздний PUT.
+Первый сценарий передаёт 40 offline-сообщений (больше порции pump) и перезапускает источник с pending outbox; второй перезапускает
+суперузел и доставляет первое сообщение при выключенном источнике.
+
+`test_dm_media`: реальные A/B/S/M с раздельными ролями supernode и storage;
+прямая передача, custody, restart S/M при выключенном A, точный файл на B,
+удаление копии и тела S, поздние STORE/STORED, TTL, отказ по квоте, неверная квитанция,
+SQL rollback регистрации, состояния JSON и отмена операции с CM handle.
+Голосовое передаётся напрямую; метаданные видео сохраняются после offline custody
+и restart S/M при выключенном источнике.
+
+`test_dm_worker`: повторное шифрование 8 МиБ не менее 0,5 с и проверка расшифровки;
+work выполняется вне uasync, done в его потоке, heartbeat продолжает работать.
+Destroy отменяет уже posted completion, callback вызывается ровно один раз.
+
+`test_attachment`: строгий формат, повреждения и граничные длины, реальное
+кодирование/декодирование 50 Opus-кадров, длительность и waveform.
+`test_attachment_send`: выбранная беседа после смены текущего target, освобождение
+PCM в worker, остановка до completion без регистрации и удаление отклонённого cache.
+Qt `test_voice_file`: реальные PCM/Opus, повреждённые файлы и отмена async decoder.
+
+Проверка 01.10.2026: чистые сборки Qt и Android APK; полный `check.sh` —
+117 PASS, 0 FAIL, 1 SKIP (auto_socket_dynamic требует root), proxy/burst/load PASS.
+Qt CTest: 7 PASS, 0 FAIL; Android APK собран после `clean`.
+В тесте worker максимальный интервал heartbeat составил 10,3 мс.
+Интерактивная проверка GUI на телефоне и десктопе не выполнялась.

doc/encrypted_attachments.md

@@ -0,0 +1,154 @@
+# Зашифрованные вложения группового чата
+
+В desktop chatgui после выбора файла или перетаскивания в чат рядом с его именем
+появляется флажок «Зашифровать вложение». Он применяется к выбранному файлу,
+изображению или видео. Удаление, замена файла и переход в другую беседу сбрасывают
+флажок. Выбор фиксируется вместе с адресатом при отправке, до подготовки.
+В DM флажок скрыт: используется существующее автоматическое E2E-шифрование лички.
+
+Android показывает зашифрованное вложение отдельной карточкой со статусом запроса
+ключа. После одобрения карточка обновляется на исходный файл, изображение, видео
+или голосовое. В интерфейс передаётся только расшифрованный путь; контейнер `.uenc`
+нельзя открыть или сохранить как готовое вложение. До расшифровки цитата показывает
+название «Зашифрованное вложение», после — обычный preview исходного вложения.
+Список чатов сохраняет общее название зашифрованного вложения вместо manifest.
+
+Автор генерирует независимые случайные crypto_UUID и ключ AES-256 на каждую
+подготовку. Ключ записывается в локальную SQLite до шифрования. Готовый контейнер
+передаётся через обычные media_index/media_delivery. UUID транспортного медиа
+и crypto_UUID имеют разные назначения: первый идентифицирует сетевые блоки,
+второй — контейнер и ключ. Повтор доставки передаёт прежний контейнер.
+
+## Подписанное сообщение и контейнер
+
+В подписанном сообщении `ct=application/x-utun-encrypted`, базовое имя тела —
+`<crypto_UUID:32hex>.uenc`. Остальные поля manifest описывают шифротекст:
+размер, SHA256 всего контейнера, UUID и подписи блоков. Ключ, исходное имя,
+MIME, waveform и остальные медиаметаданные в историю канала не записываются.
+
+Контейнер:
+
+```text
+magic "UTENC001":8
+crypto_UUID:16
+plaintext_size:8BE
+encrypted_metadata_size:2BE
+SHA256(encrypted_file_body):32
+encrypted_metadata:variable
+encrypted_file_body:variable
+```
+
+Метаданные содержат MIME в 32 байтах и сериализованный `attachment_info`.
+MIME — непустая NUL-строка длиной1..31 байт: ASCII33..126 без двойной кавычки
+и обратной косой черты. Общий `encrypted_file_validate_type` применяется в send,
+write и read; это проверка представления поля, без полного разбора MIME-грамматики.
+Send отклоняет неверное значение до создания задачи/ключа/worker, write — до файловых
+операций. Read проверяет расшифрованное аутентифицированное поле и при ошибке сохраняет
+прежние info/type. Сырые неверные строки в диагностику не выводятся.
+
+Каждая часть шифруется AES-256-CCM с тегом 16 байт и nonce 13 байт.
+Nonce метаданных использует `part=UINT64_MAX`; файл — порции 32768 байт
+с номерами от нуля. Общие примитивы находятся в `media_async/media_crypto`;
+формат существующего DM при их выделении не менялся.
+
+Получатель проверяет подписанный SHA256 полного контейнера, UUID, tag метаданных,
+все tags файла, точный размер и hash тела. Результат пишется во временный файл
+и публикуется после успешной проверки и durable rename. Подготовка файлов
+и криптография выполняются в media_async worker.
+
+`encrypted_file_write/read` возвращают закрытый проверенный `file_io_temp`,
+не изменяя конечное назначение. Задача владеет им до publish/discard; запись идёт
+в эксклюзивно созданный соседний файл с правами 0600 на POSIX. Одинаковые файлы,
+включая `/./`, hardlink и конечную ссылку назначения, отклоняются до подготовки;
+публикация повторно проверяет идентичность. При ошибке read не выдаёт новые метаданные.
+
+Режим `FILE_IO_DURABLE` действует весь срок temp: flush/sync открытого файла/close,
+затем rename и сохранение каталога. После успешного rename ошибка directory sync
+не откатывает установленный результат; temp уже отсоединён от владельца.
+Completion не удаляет файлы по заранее вычисленному имени: очистка учитывает,
+какие артефакты задача действительно создала или опубликовала.
+
+Реестр `file_io` защищает активные temp от очистки кеша, включая время после close.
+Восстановление до запуска workers и очистка после их завершения удаляют оставшиеся
+`<UUID>.uenc.tmp.<UUID>` / `<UUID>.file.tmp.<UUID>` в `media/decrypted`.
+Конечные файлы и имена других форматов этот проход сохраняет; активные temp другого
+instance того же процесса остаются защищены общим реестром.
+
+## Хранение и разрешения
+
+Локальные таблицы не регистрируются в db_sync или Merkle:
+
+- `attachment_keys`: ключ автора/получателя, связь с общим message_id,
+  crypto_UUID, hash и пути двух копий, расшифрованные метаданные и состояние.
+- `attachment_key_requests`: один запрос на `(channel,message_id,peer)`,
+  направление, решение и дата создания.
+- `attachment_key_outbox`: команда, адресат и время следующей попытки.
+
+Шифротекст хранится в `media/<channel>/<crypto_UUID>.uenc`, локальная открытая
+копия — в `decrypted/<channel>/<crypto_UUID>.file`. В media_files и объявлениях
+держателей остаётся только шифротекст, включая backfill после restart.
+Квота медиакеша учитывает обе копии; очистка кеша не удаляет ключ. При повторном
+открытии удалённая открытая копия восстанавливается с сохранённым ключом.
+
+После полной проверенной загрузки обычный клиент автоматически запрашивает
+ключ автора. Фоновая копия узла с подписанной ролью `storage=yes` запрос не
+создаёт; ручная пользовательская загрузка на таком узле запрашивает доступ.
+Сетевая классификация `peers.storage` для этого не используется.
+
+В шапке desktop-клиента кнопка «Запросы расшифровки» видна при наличии запросов без решения
+и показывает их число.
+Список содержит участника, вложение, дату и отдельные кнопки выдачи/отказа.
+Двойной клик переводит к исходному сообщению. После выдачи видны ожидание доставки
+и подтверждённая доставка ключа; отказ также сохраняется.
+
+## Адресный протокол
+
+Router-сервис `ETCP_RT_ID_ATTACHMENT_KEYS=0x42`. Каждый пакет обязан иметь
+`ROUTER_FLAG_SIGNED | ROUTER_FLAG_ENCRYPTED`; промежуточные узлы ключа не видят.
+Протокол не создаёт личную беседу и не публикует служебные сообщения в канал.
+
+```text
+magic "AK01":4 | command:1 | message_id:32 | crypto_UUID:16 | cipher_hash:32
+GRANT дополнительно содержит key:32
+
+REQUEST=1, REQUEST_ACK=2, GRANT=3, DENY=4, RESULT_ACK=5
+```
+
+Автор принимает запрос только на собственное опубликованное сообщение с
+сохранённым ключом. Участие запрашивающего проверяется по полному подписанному
+мемберу, join и дереву приглашений; удалённые мемберы отклоняются. Проверка
+повторяется при решении и перед каждой отправкой GRANT. Получатель принимает
+ответ только от автора, по своему существующему запросу и точной идентичности
+контейнера. Конфликтующие ключи и результаты отклоняются.
+
+REQUEST_ACK отправляется после сохранения запроса. GRANT/DENY появляются
+в outbox только после сохранения решения. Полученный ключ сохраняется до
+RESULT_ACK и до запуска расшифровки. Повторы возвращают прежнее решение и не
+создают новых строк. Таймер обрабатывает ограниченную порцию очереди с
+backpressure и повтором через 5 секунд; restart продолжает очереди.
+
+Для доставки нужен живой маршрут обеих сторон: офлайн-mailbox этого сервиса
+не реализован. Запрос ждёт появления автора; решение ждёт появления получателя.
+Уже выданный ключ невозможно отозвать у получателя. Защита содержимого не
+скрывает автора, канал, время и размер шифротекста. Автоматическая публикация
+транскрипции зашифрованного голосового в канал не запускается.
+
+## Проверки
+
+`test_encrypted_file`: границы порций, пустой файл, metadata roundtrip,
+неверные ключ/автор/UUID/hash, подмена метаданных с пересчитанным внешним hash,
+лишние байты, alias обоих API, сохранность существующего назначения/метаданных,
+23 сценария отказов I/O с контролем fd/temp, включая ошибку после rename.
+Для MIME проверяются все256 значений первого байта, NULL и границы поля,
+восемь ранних отказов writer с сохранением файлов/output, три допустимых roundtrip
+и семь аутентифицированных некорректных wire-полей с сохранением info/type/target.
+`test_media_primitives` проверяет оба режима temp и границу durable-публикации;
+`test_attachment_send` проверяет восемь отказов MIME до ключей/worker/файлов,
+затем останавливает сервис после настоящего crypto rename до completion.
+
+`test_encrypted_attachment`: реальные A–S–B/C, скачивание с S при выключенном A,
+перезапуски автора с запросами и получателя с ключом, выдача B и отказ C,
+отсутствие ключа на S/C, отрицательные control-пакеты, повтор GRANT,
+восстановление удалённого plaintext без нового согласия и удаление канала.
+При startup/restart дополнительно проверяются оба дерева: stale temp удаляются,
+открытый и закрытый активные temp, конечные файлы и чужие имена сохраняются.

doc/etcp_arch.md

@@ -1,4 +1,8 @@
-Архитектура etcp:
+> Исторический документ: описания NAT, модулей и ограничения обмена маршрутами ниже не отражают текущую реализацию.
+> Актуальные правила группового обмена маршрутами — в [topo_group.h](../src/routing_layer/topo_group.h),
+> модель узла — в [node_snapshot.md](node_snapshot.md), протокол роутера — в [etcp_router_doc.md](../src/routing_layer/etcp_router_doc.md).
+
+Архитектура etcp:
 
 ETCP устанавливает только одно подключение между двумя узлами. Это подключение может добавлять-убирать каналы связи (динамически) без разрыва соединения.
 Также каналы связи мониторятся и трафик распределяется между доступными каналами. Если канал определяется как недоступен - он исключается из обмена.

doc/etcp_config.txt

@@ -1,10 +0,0 @@
-В конфиге явно прописываются сокеты с ip и портом.
-Через эти сокеты идёт весь трафик, случайные порты клиент не использует - только эти сокеты.
-Соответственно, возможен только один линк между двумя пирами по одному каналу.
-
-виртуальные сокеты - плохо т.к. используются ip/port для поиск подключения
-
-
-
-./configure --with-openssl    - openssl
-./configure --without-openssl - tinycrypt

doc/etcp_full_suite_findings.md

@@ -0,0 +1,178 @@
+# Разбор полного прогона 2026-09-27
+
+Исходный результат `./check.sh` вне песочницы: 92 passed, 5 failed, 1 skipped (98 тестов).
+Песочница запрещает сетевые сокеты; её результаты не использовались для оценки протокола.
+
+Промежуточный прогон: 96 passed, 1 failed, 1 skipped; оставался `test_chat_join_e2e`.
+После KEY_REGISTER_ACK и исправления невыровненных чтений повторный полный
+`make check -j4`: **97 passed, 0 failed, 1 skipped (98)**.
+Лог: `/tmp/utun-ack-final-check.log`. Исходное падение отдельного root-теста и
+последующая доработка описаны ниже. После исправления autosockets общий набор дал
+97 PASS / 1 SKIP, а `check-proxy`, `check-burst`, `check-load` прошли:
+`/tmp/root-fix-full-check.log`.
+
+`test_etcp_lifecycle`, `test_etcp_link_stress`, `test_conn_mgr_phases` дополнительно
+прошли ASan/UBSan/LeakSanitizer. Инструментированы тесты и изменённые транспортные/
+маршрутные модули, остальные объекты библиотек взяты из обычной сборки.
+Логи: `/tmp/ncd-late-asan.log`, `/tmp/link-role-asan.log`, `/tmp/cm-phases-asan.log`.
+
+## Исправленные причины
+
+- `test_conn_mgr_phases`: после TIMEOUT фазы DIRECT NCD навсегда подавлял UP,
+  хотя conn_mgr сохранял handle для REVERSE. В логе физический ETCP уже UP,
+  но conn_mgr продолжал DIRECT_REQ до своего таймаута. TIMEOUT теперь обозначает
+  истечение срока первой попытки, CLOSED — окончательное завершение. Удерживаемый
+  handle получает поздний UP. Отдельный lifecycle-регрессионный тест воспроизводит
+  TIMEOUT → INIT/UP (одно уведомление) → DOWN → UP; до исправления он падал.
+- `test_etcp_link_stress`: ожидал reset всей сессии при коллизии дополнительного
+  линка. Проверка заменена на сохранение эпох, отсутствие reset и дублей линков,
+  доставку и ACK сообщений через новый линк. Прежний тест забирал сырые фрагменты
+  вместо normalizer и мог считать служебные пакеты полезным трафиком. Теперь он
+  использует отдельный ETCP service и проверяет каждый байт и порядок сообщений.
+  Эта проверка выявила ошибку реализации: при принятии встречного INIT сохранённый
+  исходящий линк не менял `is_server`. Роль обновляется при отправке INIT_RESPONSE.
+- `test_bgp_route_exchange`: после разрыва B–C recovery успешно строил C–A,
+  нарушая предположение теста о фиксированной цепочке. Теперь A и C принимают
+  только ключ B: все прежние проверки withdraw/restore сохранены, обход запрещён
+  условиями тестовой сети. Автоматический обход отдельно проверяет `test_topo_recovery`.
+- `test_tcp_io`: адрес 192.0.2.1:81 в окружении устанавливал TCP-соединение,
+  поэтому connect timeout закономерно не срабатывал. Теперь используется локальный
+  listener с заполненной accept-очередью, проверяется ETIMEDOUT. Перед уничтожением
+  uasync тест завершает отложенное освобождение TCP и проверяет баланс таймеров.
+
+Диагностика тестов включается `UTUN_TEST_DEBUG=1`; обычный запуск не включает DEBUG.
+Остаточные DATA после удаления соединения могут быть undecryptable и сами по себе
+не означают ошибку транспорта.
+
+## Исправлено: гонка регистрации приглашения
+
+`test_chat_join_e2e`, happy path A != C, падал из-за отсутствия подтверждения KEY_REGISTER.
+Раньше `chat_invite_build_link()` вызывал `chat_join_register_key()` и сразу возвращал ссылку.
+Успех `etcp_route_send()` означает постановку в очередь. Он не подтверждает обработку
+ключа посредником C. Параллельное подключение J–C может завершиться раньше доставки A–C.
+
+Доказательство: `/tmp/join-e2e-debug.log`, один ключ `90c4b081833450a0`:
+
+- 01:39:02.437851 — A пишет `join-key registered`, фактически ключ только поставлен в отправку.
+- 01:39:02.446527 — C отвергает JOIN_INFO_REQ: ключ ещё неизвестен.
+- 01:39:02.449724 — C сохраняет этот ключ, но J уже получил терминальный ERROR.
+
+Теперь C отвечает KEY_REGISTER_ACK только после сохранения ключа. A сопоставляет
+channel/target/key и выдаёт ссылку после успешного ACK и локального сохранения ключа.
+Отрицательный ACK завершает запрос ошибкой. Чужие, неподписанные, незашифрованные,
+повторные и запоздалые подтверждения не могут завершить другой запрос.
+
+Контракт асинхронных API `chat_join_register_key` / `chat_invite_build_link`:
+NULL означает ошибку запуска без callback; принятый запрос даёт ровно один callback.
+Обычное завершение происходит после возврата API, включая self. Cancel/destroy
+завершают запрос синхронно с CANCELLED. Handle недействителен после callback.
+Для удалённого узла дедлайн 5 секунд; доставку и повтор потерянных пакетов обеспечивает
+надёжный router. Повторная регистрация того же ключа тем же инвайтером обновляет TTL;
+замена инвайтера для существующего ключа запрещена. Отмена может оставить ключ на C
+до истечения TTL, но A не авторизует по нему вход, поскольку локально такой ключ
+сохраняется только при успешном завершении.
+
+GUI получает request_id в событии и игнорирует устаревшие результаты. Новый запрос
+отменяет предыдущее ожидание GUI. Headless связывает ответ с JSON id и отменяет все
+ожидания отключившегося клиента. Ни один из путей не запускает вложенный event loop.
+
+Дополнительные исправления:
+
+- Устранён double-free при ошибке `etcp_route_send`: пакет уже освобождён роутером.
+- Headless прекращает разбор пакета после `quit`; последующая команда не создаёт
+  запрос на уже закрытом клиенте. При destroy отменяются cleanup_timer и запросы,
+  удаляются клиентские сокеты и освобождается контекст.
+- UBSan обнаружил невыровненное чтение group_id из `d + 1` в chat_sync. Оно и три
+  аналогичных диагностических чтения заменены на memcpy.
+- Тест chat_join теперь останавливает вручную запущенный member_sync;
+  проверяется баланс выделения/освобождения таймеров.
+
+Проверки:
+
+- `test_chat_join`: 31/31, включая задержанный/отсутствующий ACK, таймаут,
+  неверные channel/peer/key/flags/размер/status, дубликат, отказ хранения из-за
+  конфликта инвайтера, отмену, shutdown, параллельные ключи и ошибку отправки.
+- `test_chat_join_e2e`: 3/3 (A≠C, A=C, неверный ключ). C принудительно откладывает
+  регистрацию на 200 мс; проверяется отсутствие ссылки до обработки регистрации.
+  Дополнительно проверяются подавление старого GUI-запроса и реальный headless
+  control socket: параллельные ответы, валидность ссылок, quit и команда после него.
+- ASan/UBSan: оба теста проходят. LeakSanitizer и баланс таймеров проверены в
+  test_chat_join; E2E использует fork/_exit, поэтому сам по себе не проверяет утечки
+  при завершении дочерних процессов. Инструментированы изменённые chat-модули и
+  transport/routing, остальные объекты взяты из обычной библиотеки.
+  Логи: `/tmp/utun-ack-join-asan.log`, `/tmp/utun-ack-e2e-asan.log`.
+
+## Отдельный root-тест auto_socket_dynamic
+
+Запуск в `sudo unshare --net` с поднятым loopback закончился TIMEOUT через 30 секунд.
+Лог: `/tmp/utun-ack-root-checks.log`. Это не PASS основного набора: в нём тест пропущен.
+
+В конфиге теста включён auto_sockets, но не отключён стандартный фильтр
+`auto_socket_skip_no_default_route=1`. Dummy-интерфейсы теста не имеют default route,
+а `auto_socket.c:reconcile_iface()` исключает такие интерфейсы. Лог показывает
+`no links created`, затем TIMEOUT. Исправленный тест создаёт собственный network
+namespace, поднимает loopback и добавляет default route только клиентским dummy.
+Фильтр остаётся включённым; отдельно проверяется исключение серверного dummy,
+иначе его сокет скрывал бы полный обрыв клиентской сети.
+
+Кроме того, тест сохраняет handle общего дедлайна, traffic_send и traffic_monitor
+в одну переменную timeout_handle; фазовые таймеры вообще не сохраняются. При выходе
+не отменялись все таймеры; зафиксирован остаток 9 таймеров (665/656). В обработчиках
+трафика освобождался entry без queue_dgram_free. Теперь у каждого таймера свой slot,
+waiters отменяются до teardown, payload освобождается, deferred cleanup завершается
+до проверки баланса таймеров, сокетов и `u_get_allocated_count()`.
+
+Новый генератор шлёт 1024-байтовые пакеты независимо в обе стороны, по одному через
+threshold waiter, с бюджетом 64 пакета на tick. Проверяются содержимое, строгий seq,
+ограниченность TX/RX очередей, реальное срабатывание backpressure, остановка
+генераторов при полном обрыве и полное опустошение после восстановления. NCD handle
+удерживает логическую сессию: смена интерфейса не является разрешением терять её данные.
+Остатки после действительно удалённого соединения — отдельный допустимый случай.
+
+Прогон нагрузки обнаружил ошибки, скрытые прежними проверками:
+
+- `tcp_socket_add` не сохранял `netif_index`: монитор принимал interface-bound сокет
+  за сокет default route и менял его адрес при событиях другого интерфейса.
+- Удаление TCP модели искало её по имени уже удалённого интерфейса и порту из БД.
+  Теперь запись интерфейса хранит имя и прямую ссылку на модель; один путь закрывает
+  listener, линки и модель. Портовые записи удаляются с сохранённым именем.
+- `tcp_socket_remove` не закрывал линки, созданные вне NCD. Теперь закрывает все
+  связанные линки до освобождения модели; root-тест создаёт такой линк отдельно.
+- Поиск UDP модели не исключал TCP. Добавлена проверка типа сокета.
+- При selective ACK sender мог выдавать новые seq за границей `MAX_INFLIGHT_SIZE`
+  относительно cumulative ACK. Теперь генерация seq останавливается на границе,
+  cumulative ACK возобновляет очередь даже при отсутствии уже selectively-acked записей.
+  Тесты проверяют блокировку, возобновление и uint32 wrap. ACK не может подтвердить
+  ещё не назначенный seq; декодирование старшего байта seq/ACK не делает signed shift.
+- Timestamp Q16 умножался как signed int и переполнялся на циклических/отрицательных
+  смещениях. Перевод выполняется в uint32. Jitter раньше всегда получал нулевую разницу:
+  предыдущий RTT читался после перезаписи; теперь берётся до неё, EWMA использует int64.
+- UBSan выявил невыровненные canary/указатели в `mem.c` и `memory_pool.c`. Метаданные
+  читаются/пишутся через memcpy; покрыты размеры блоков 1..17 и повторное использование пула.
+- Повторный общий прогон поймал `test_etcp_connect`: PID-порты пересекались с занятым
+  UDP-портом (`EADDRINUSE`). Теперь сервер bind-ится на порт 0, клиент получает фактический
+  порт через getsockname; собственного алгоритма поиска свободного порта нет.
+
+Root ASan/UBSan/LSan: PASS, 153335 / 175912 пакетов, reinit=0, все очереди пусты,
+баланс памяти/таймеров/сокетов совпал (`/tmp/root-fix-asan.log`). Инструментированы
+тест, ETCP/session/router/NCD/autosocket/STCP/normalizer, очереди, event loop и аллокаторы;
+прочие объекты архивов обычные. Unit-логи: `/tmp/root-session-asan.log`,
+`/tmp/root-memory-asan.log`. LSan запускается вне sandbox: под ptrace он не работает.
+
+Финальная чистая обычная сборка: `./check.sh` — **97 PASS / 0 FAIL / 1 SKIP**;
+proxy, burst и load — PASS (`/tmp/root-fix-final-check.log`). Отдельный root-тест —
+PASS, 188069 / 191552 пакета, все очереди пусты, reinit=0, баланс ресурсов совпал
+(`/tmp/root-test-final.log`). После добавления drain отложенной очистки
+`test_etcp_connect` повторно прошёл без остаточных таймеров (`/tmp/root-connect-final.log`).
+
+Подробные socket/connection INFO включаются только через `UTUN_TEST_DEBUG=1`.
+`ENETUNREACH` непосредственно при принудительном удалении IP/интерфейса ожидаем до
+обработки netlink; тест требует последующей доставки всех данных. Ошибки выхода
+за receive window недопустимы и после исправления sender gate не наблюдаются.
+
+## Попутная проблема диагностики
+
+`lib/debug_config.c:debug_parse_config()` требует `:`, хотя документация описывает `=`.
+Кроме того, функция всё ещё вычисляет индекс через битовую маску, хотя категории
+теперь являются индексами. Исправление в этот набор не включено; тесты используют
+`debug_set_category_level()` напрямую.

doc/etcp_protocol.txt

@@ -1,75 +1,193 @@
 Формат кодограммы:
 ------------------
-пакеты идут по следующему пути:
-пакет кем-то помещается в входную очередь (ETCP input_queue).
-Когда load balancer готов отправить следующий пакет он делает вызов etcp_request_pkt в etcp.c/h и etcp либо формирует следующую кодограмму или встаёт в состояние async ожидания (возвращая null):
-  - либо wait ETCP input_queue (если нечего передавать)
-  - либо wait SACK + wait timeout (если sack очередь полная и нет необслуженных запросов ретрансмиссий). после истечения wait timeout он помечает используя round-robin очередной пакет как "нужна ретрансмиссия".
-из async ожидания он может вызвать etcp_loadbalancer input_from_etcp и передать пакет на отправку.
-как формируется пакет:
-  1. выбираем канал передачи (etcp_loadbalancer_select_link)
-  2. если есть место в rwin (объём inflight данных) то берем очередной пакет из ETCP input_queue и его отправляем
-  3. если пакет найден или есть неподтверждённые ACK:
-     1. вызываем функцию формирования опциональных секций (ACK, channel timestamp) - они записываются в начало
-     2. в конец добавляем секцию 0x00 с данными пакета
-  при отправке пакета помечаем в inflight списке с какого интерфейса он отправлен
-Функция прикрепления опциональных секций:
-  - запрашивает выбор канала передачи.
-  - добавляет накопившиеся ACK
+Кодограмма сервиса через etcp_send попадает в normalizer; его фрагменты поступают в
+input_queue, затем в indexed input_send_q с назначенным seq.
+Очереди, ACK/RTO, изменение окна и готовность линка вызывают etcp_conn_wake_sender.
+Один call_soon обслуживает накопленные события без рекурсивного входа и задержки таймером.
+При OOM выделения сетевого пакета очередь сохраняется; retry назначается через 10ms.
+close/reset отменяет ожидающий запуск. Не подтверждённая сессия не передаёт DATA/ACK;
+HELLO/CHALLENGE/CONFIRM и keepalive передаются своим независимым путём.
+
+Формирование пакета:
+  1. Просмотреть input_send_q без извлечения: первый готовый повтор, иначе первый готовый новый DATA.
+     Заблокированная запись пропускается; порядок остальных записей не меняется. Поиск не резервирует окно,
+     не выдаёт номер попытки и не меняет историю/RR. Если кандидата нет, можно подгрузить один новый фрагмент
+     и повторить просмотр. Общий бюджет учитывает DATA-байты send_q+wait_ack; приёмное окно по till сохраняется.
+     После callback подгрузки проверяются reset_count/close/сессия, включая удаление прежнего burst-линка.
+  2. Выбрать инициализированный UP-линк с готовым shaper и местом для целого DATA:
+     inflight_bytes + длина DATA <= inflight_lim_bytes. Проверка выполняется без переполнения.
+     Среди допустимых выбирается минимум inflight_bytes, при равенстве — round-robin.
+     Для повтора обход начинается после last_link самого фрагмента: сначала неиспользованные допустимые пути.
+     История — битовая карта256 локальных слотов,32 байта на логический пакет; wire-формат не меняется.
+     Пока остался неиспользованный путь, занятый по cwnd/pacing, этот пакет ждёт, а send_q просматривается дальше.
+     Когда все допустимые пути использованы, разрешён следующий обход. Очистка истории и новый бит фиксируются
+     только после принятия send; отказ send не расходует обход. Перед удалением линка очищаются его курсор/бит
+     во всех логических записях до освобождения слота и callbacks, которые могут повторно выдать тот же local_link_id.
+     При наличии незастрявшего initialized+UP пути застрявшие исключены из повторов, даже если альтернатива занята.
+     Если застряли все, доступны все UP-пути. Прежний путь разрешён лишь при отсутствии других допустимых;
+     иначе ждём альтернативу. DOWN последней альтернативы пробуждает отправителя.
+  3. Наступивший по сроку или срочный ACK обслуживает тот же линк, который принял DATA,
+     без ограничения DATA-cwnd/pacing. Готовый DATA другого линка уступает этому ACK;
+     DATA того же линка забирает ACK piggyback. Если DATA не помещается, он остаётся в очереди.
+     Кумулятивный till можно отправить по любому рабочему пути. ACK-only не увеличивает нагрузку DATA-shaper;
+     физическая очередь канала остаётся общей, её накопление ограничивают DATA-cwnd/pacing BBR.
+  4. Выделить ETCP_DGRAM до удаления DATA из очереди и изменения счётчиков.
+     Выделить физическую попытку с новым attempt_no для этого seq и зарезервировать окно выбранного линка.
+     Только успешное принятие транспортом фиксирует время, last_link, историю/RR и перенос DATA в input_wait_ack.
+     Ошибка send снимает резерв; логический DATA остаётся готовым без сетевого loss sample.
+     Пакет содержит ACK, опциональные timestamp/измерительные секции и последнюю секцию PAYLOAD.
+  5. В активной ограниченной burst-серии pacing обходится; DATA всё равно должен
+     помещаться в окно, иначе серия отправляет FILLER. ACK/FILLER окно DATA не занимают.
+     Если готовый повтор относится к другому пути, серия идёт FILLER: новые DATA его не обгоняют.
 При приёме пакета (от etcp_connections):
   - последовательно сканируем секции и отдаём их на обработку нужным обработчикам:
-    - ack (0x01): помечаем в inflight пакеты как подтверждённые и проставляем время подтверждения. также снимаем блокировку отправки
-    - timestamp (0x06): обновляем last RTT, пересчитываем RTT avg10 и jitter по каждому линку; обновляем recv_dt_avg для раздельного измерения времени передачи/приёма
-    - [0x00] payload: добавляем пакет в нужное место сборочного linked-list (сверяем по ID если дубликат - игнорируем). также добавляем ACK запись в ack_q для отправки.
+    - ack (0x01): пара seq+attempt_no подтверждает физическую попытку только принявшего ACK линка;
+      seq отдельно подтверждает логическую доставку. till освобождает логические записи, без BBR/снятия чужого flight.
+    - timestamp (0x06): обновляем RTT и EWMA |ΔRTT| пути; recv_dt_avg хранит поправки времени TX/RX в Q16.
+      У conn rtt_last — среднее RTT линков, rtt_avg_10 — их максимум (имя историческое).
+      BBR использует отдельные DATA RTT/jitter по ACK физических попыток; RTO также учитывает rtt_last своего линка.
+    - [0x00] payload: сохраняем фрагмент в recv_q либо распознаём уже сохранённый/доставленный seq.
+      Только после этого ставим ACK с seq+attempt_no в ack_q принявшего линка; OOM до сохранения не подтверждается.
   после сканирования проверяем появились ли в linked-list собранные данные которые можно переместить в выходную очередь. и перемещаем если есть.
 
-пересканирование inflight:
-  - запускается при добавлении пакета в очередь ожидания ACK (wait_ack_cb). устанавливается таймер на первый неистекший пакет.
-  - если время последней отправки > RTT_avg10*K1+jitter*K2 (коэффициенты K1=32, K2=32, деление на 16) то пакет заново отправляется
-  - очередь FIFO (сортирована по timestamp добавления = времени отправки), сканирование прекращается на первом неистекшем пакете
-  - по истечению таймера (ack_timeout_cb) снова вызывается проверка очереди
+Таймер попыток каждого линка (etcp_tx.c):
+  - RTO = clamp(ceil(1.2*RTT_for_RTO + 1.5*data_jitter_us + 3000), 10000, 1000000) мкс,
+    RTT_for_RTO=max(data_rtt_us,100*rtt_last): DATA EWMA и последний timestamp/keepalive RTT своего линка.
+    Целочисленный расчёт использует uint64 и округляет вверх до целой микросекунды.
+    RTT использует собственный DATA ACK минус receiver_delay; EWMA RTT=1/8, jitter=1/4 |RTT-EWMA|.
+    Первый DATA RTT задаёт jitter=RTT/2. Timestamp-RTT задаёт нижнюю границу срока, чтобы после роста задержки
+    попытки доживали до ACK и DATA-измерения продолжались; BBR RTT/min_rtt по этому сигналу не обновляются.
+    Без обоих измерений RTO=1с.
+  - FIFO содержит физические попытки в порядке принятия транспортом. Таймер назначается по старейшей;
+    при изменении RTO проверяется новый срок. Timestamp handler пересчитывает таймер сразу после обновления RTT,
+    включая сокращение без новых DATA/ACK. Допускается оставить уже запланированную более раннюю проверку.
+    uasync округляет задержку вверх до миллисекунды; callback может выполниться позже расчётного срока.
+  - Истечение снимает только собственный физический flight и сообщает loss собственному BBR.
+    Если логический seq ещё не доставлен и других активных копий нет, он возвращается в input_send_q.
+    Уже доставленный seq не возвращается, даже если его физическая копия истекла позже.
+
+Обычный ACK-only ждёт received_at_us старейшей записи своего пути + 2000мкс.
+Piggyback на готовом DATA передаёт ACK сразу. Готовый ACK может включать более свежие записи:
+срок проверяется по голове пакета, а не отдельно для каждой записи внутри него.
+Среди готовых обычных ACK выбирается самый старый срок; срочный ответ на ACK_REQUEST имеет приоритет.
+Короткая ограниченная измерительная burst-серия завершается до перехода к ACK другого пути.
+Продвижение логической границы также задаёт срок 2мс от первого неподтверждённого продвижения;
+следующие DATA его не отодвигают. Любой принятый пакет с актуальным till снимает этот запрос.
+Один ack_resp_timer соединения обслуживает минимум сроков очередей рабочих путей и логической границы.
+После piggyback/частичной отправки срок пересчитывается по оставшимся головам. Новый RX между
+timer и отложенным sender не задерживает старые ACK: готовность проверяется по абсолютному времени.
+При DOWN очередь пути не создаёт таймер; после UP её старый наступивший срок действует сразу.
+OOM ACK-таймера логируется и включает существующий срочный ответ, сохраняя received_at_us для RTT.
+Reset/close отменяют таймер и очищают сроки; DATA/RTO/BBR и wire-формат этим механизмом не меняются.
 
 inflight - две очереди (ll_queue):
   - input_send_q: список пакетов ожидающих отправку
   - input_wait_ack: список неподтвержденных пакетов ожидающих ack
-  При отправке пакет перемещается из input_send_q в input_wait_ack.
-  При ретрансмиссии пакет перемещается из input_wait_ack обратно в input_send_q.
+  При принятии отправки транспортом пакет перемещается из input_send_q в input_wait_ack.
+  При необходимости повтора пакет перемещается из input_wait_ack обратно в input_send_q.
   доп. свойства пакетов (struct INFLIGHT_PACKET):
   - указатель на ETC_LINK последней отправки (last_link)
   - timestamp последней отправки (last_timestamp)
   - число отправок (send_count)
-  - send_hist[8] - история через какие линки отправлялся (индекс линка)
-  - inflight_bytes/inflight_packets per-link отслеживается в ETCP_LINK
-Размер буфера inflight лимитируем как сумму по всем активным линкам optimal_inflight.
-optimal_inflight расчитывается из RTT и bandwidth линка.
-
-bandwidth по каждому линку адаптивно подстраиваем:
-Периодически в stats_timer_cb собираем статистику окна (rtt_avg10, ретрансмиссии, переданные пакеты).
-BW рассчитывается как: inflight_lim_bytes * 8 / rtt_min (в секундах) * 8 / 1024 * 1.3 (Kbits/sec).
-Размер inflight_lim_bytes плавно подстраивается вверх/вниз в зависимости от того, растёт ли RTT.
-Burst-измерения bandwidth (0x07, 0x08) зарезервированы, но на данный момент не реализованы.
+  - send_hist[8] — local_link_id последних попыток, только диагностика
+  - last_attempt_id — внутренний составной ключ (seq<<16)|attempt_no последней принятой отправки
+  - attempt_count — выданные номера попыток данного seq, общие для всех каналов, включая неудачные send
+  - active_attempts — число ещё учитываемых физических копий
+  - Payload принадлежит только логической записи. Попытка ETCP_TX_ATTEMPT хранит seq и неизменные снимки, без payload.
+    inflight_bytes/inflight_packets линка равны сумме DATA-длин/числу записей в его attempts, включая резерв send.
+    ACK/till может уже удалить логический объект, пока другая физическая копия продолжает занимать своё окно.
+    Повторный ACK неизвестной/истёкшей попытки не вычитает flight и не создаёт BBR sample.
+    ACK известного ID с другим seq отклоняется целиком; неизвестный ID допускает только логическое подтверждение seq.
+    Удаление линка обнуляет last_link в обеих очередях до освобождения его памяти.
+Общий optimal_inflight равен сумме лимитов всех линков, с насыщением UINT32_MAX;
+это дополнительный backpressure подачи новых фрагментов, не замена индивидуальных окон.
+Отдельно ограничиваем размах sequence относительно кумулятивного ACK: новый seq выдаётся
+только если (uint32_t)(next_tx_id - rx_ack_till) <= MAX_INFLIGHT_SIZE (16384).
+Selective ACK освобождает отдельную inflight-запись, но не продвигает эту границу:
+приёмник пока не может освободить пакеты за дыркой. Кумулятивный ACK возобновляет
+input_queue даже если подтверждённые записи уже удалены по selective ACK.
+При заполненном sequence-окне собственный таймер запрашивает актуальный till секцией ACK_REQUEST.
+Получатель отвечает через запрашивающий путь, даже без ожидающих DATA/ACK-элементов.
+При продвижении frontier, reset/close таймер отменяется. Это восстанавливает поток при потере последнего till.
+Память физических попыток ограничена: 16384 на линк, 32768 на соединение; исчерпание блокирует DATA до освобождения.
+Очередь ACK каждого линка ограничена 16384 записями; переполнение логируется, DATA остаётся сохранённым для повтора/till.
+ACK ограничивается последним назначенным seq (next_tx_id - 1); сравнения учитывают uint32 wrap.
+BBR каждого линка получает ACK/loss samples и возвращает cwnd и pacing rate.
+Скорость — доставленные байты за max(интервал отправки, интервал доставки), по снимкам при отправке.
+Интервал между соседними ACK не используется: ACK одной пачки могут обрабатываться в один tick.
+ACK с подтверждениями также возвращает точку приёма своего пути: накопленные DATA-байты и монотонное время
+последнего увеличения счётчика. В счётчик входят допустимые сохранённые/уже доставленные DATA, включая копии;
+OOM до сохранения и отвергнутые DATA его не меняют. Считаются байты полезной нагрузки секции, без заголовков.
+При отправке попытка запоминает известную точку. ACK действующей попытки продвигает точку пути;
+повторный/чужой ID её не меняет, переставленные ACK не откатывают. Противоречивая пара логируется и игнорируется.
+При положительных дельтах interval=max(send_us,ceil(delivered*delta_rx_us/delta_rx_bytes)).
+Приёмный интервал заменяет ACK clock: обратная очередь больше не завышает BW сжатием ACK
+и не занижает его растяжением. Send-интервал сохраняет защиту от сжатия приёмного времени.
+Без достоверной приёмной базы/положительных дельт используется max(send_us,ack_us).
+Счётчики и времена — uint64, часы двух сторон не сравниваются; нужны только дельты одних часов.
+Если интервал не представим в uint32, sample не используется для BW вместо насыщения, завышающего скорость.
+После пустого физического flight база начинается заново, чтобы простой не занижал скорость следующей передачи.
+Reset потока обнуляет точки приёма; исчерпание локального 64-битного счётчика закрывает соединение с ERROR.
+RTT/min_rtt, формула RTO, политика окна и дедлайн ACK не корректируются приёмной точкой.
+Внутренняя полоса — байты/мкс Q16; pacing — байты/с, BDP — байты, без повторного множителя MSS.
+Минимальное окно BBR — четыре DATA-фрагмента normalizer; максимальное — bbr_max_cwnd (по умолчанию 1048576).
+8192 — нижняя допустимая граница настройки bbr_max_cwnd; транспорт не повышает до неё текущее окно.
+PROBE_RTT осушает flight до max(4*MSS, 0.5*BDP), выдерживает >=200мс и раунд ACK, затем восстанавливает окно.
+RTT-фильтры обновляются при обработке ACK. Короткий минимум принимает меньший достоверный RTT
+либо текущее измерение после истечения 5с; RTT=0 означает отсутствие измерения.
+Долгий min_rtt принимает короткий минимум, если он не больше прежнего, либо истекли его 10с.
+Вместе со значением копируется метка короткого фильтра: повторное использование кеша не задаёт текущее время.
+Завершение PROBE_RTT возобновляет короткое окно. Окна истекают строго после своей границы;
+hold завершается при достижении срока и завершённом ACK-раунде. Метки RTT и срок hold — полные uint64 TB (100мкс).
+MSS — размер DATA-фрагмента normalizer без заголовков; начальное окно UDP и STCP равно 4*MSS с верхним лимитом конфига.
+В PROBE_BW действует дополнительный целевой бюджет очереди 20мс: всё окно, включая резервы ACK и PROBE_UP,
+ограничивается max(4*MSS, BDP + BW*20мс) по min_rtt. STARTUP/DRAIN не ограничивают окно этой формулой,
+но целый раунд RTT выше min_rtt+бюджет завершает STARTUP и переводит его в DRAIN.
+Shaper списывает только DATA-байты: единицы совпадают с delivery sample и pacing BBR.
+Это цель по оценкам BBR; минимум окна, изменение полосы и очереди обратного пути могут давать большую задержку.
+Отказ из-за нехватки окна сохраняет cwnd_limited до следующего ACK: вычитание ACK
+не должно скрывать этот факт от BBR. app_limited учитывает ожидающие очереди и
+pending/частичный буфер normalizer; ограничение окном не означает отсутствие данных.
+Потеря для BBR учитывается при RTO, фактическая повторная передача — при новой попытке.
+Три RTO физических DATA-попыток без ACK-прогресса ставят локальный флаг tx_stalled, в том числе в одном вызове таймера.
+До установки флага действующий ACK своего пути сбрасывает серию RTO. После установки сброс возможен только по ACK
+попытки, принятой транспортом после момента установки флага; старый/чужой/уже снятый attempt не доказывает восстановление.
+tx_stalled ограничивает выбор повторов при наличии альтернативы; UP, новые DATA, ACK/keepalive и формула RTO сохраняются.
+Reset линка снимает флаг и серию RTO. Новых очередей, копий payload и таймеров детектор не создаёт.
+При уменьшении окна уже отправленные пакеты остаются в учёте; новые DATA ждут ACK/RTO.
+Измерительные секции burst 0x07/0x08 и FILLER поддерживаются реализацией.
 
 
 **** Формат кодограмм для etcp.c/h ****
 Каждая кодограмма состоит из обязательного заголовка и опциональных секций:
 1. Обязательный заголовок всего пакета (3 байта) добавляется при передаче, есть во всех пакетах:
-   [Timestamp high][Timestamp low][flags/flag_up]
-   - Timestamp: uint16_t, время отправки в единицах 0.1 мс (циклическое). при переповторах время обновляется
+   [Timestamp:2][flags/flag_up:1]
+   - Timestamp: uint16_t, время отправки в единицах 0.1 мс (циклическое), при повторе обновляется.
+     Копируется из памяти в порядке байтов хоста; на используемых little-endian платформах передаётся LE.
    - flag_up: uint8_t, bit0 = up/down (recv_keepalive) — признак живой приёмной стороны
 
    шифруется строго ВСЁ включая ВСЕ заголовки (кроме обфусцированного publickey в INIT-пакетах).
    timestamp вставляется ВСЕГДА ВО ВСЕ КОДОГРАММЫ (скрыто в шифрованном заголовке).
-   Итого шифруется: 3 байта заголовка + (data_len - noencrypt_len) байт данных.
-2. Опциональные секции (одна или несколько) добавляются в etcp.c (внутри data[], без доп. заголовка):
+   Для DATA/ACK после этих 3 байт добавляется обязательный заголовок сессии:
+   [0x09][sender_epoch(8 BE)][receiver_epoch(8 BE)], затем идут секции из etcp.c.
+   Итого шифруется: 3 + 17 + data_len байт для DATA/ACK;
+   для остальных кодограмм — 3 + (data_len - noencrypt_len) байт.
+   Формат и подтверждение эпох описаны в разделе «Подтверждение транспортной сессии» ниже.
+2. Опциональные секции (одна или несколько) добавляются в etcp.c внутри DATA/ACK после заголовка сессии:
    а) Подтверждения (ACK) - заголовок 0x01:
-      [0x01][count][last_delivered_id(4 байта LE)][rx_dup_count(2 байта LE)][[seq(4 LE)][recv_ts(2 LE)][dly(2 LE)] × count]
-      - count: количество ACK записей (1 байт; до 32 ограничено размером пакета)
+      [0x01][count][last_delivered_id(4 байта LE)][rx_dup_count(2 байта LE)][[seq(4 LE)][attempt_no(2 LE)][delay_us(4 LE)] × count]
+      - count: количество ACK записей (1 байт; до 255, дополнительно ограничено MTU и оставшимся местом)
       - last_delivered_id: uint32_t — последний ID, доставленный получателю (по этот ID всё собрано подряд)
       - rx_dup_count: uint16_t — счётчик принятых дубликатов (локальный, для вычисления tx_dup_count на удалённой стороне)
       - seq: uint32_t — номер подтверждаемого пакета
-      - recv_ts: uint16_t — локальный timestamp приёма пакета (в единицах 0.1 мс)
-      - dly: uint16_t — задержка между приёмом пакета и отправкой ACK (для расчёта RTT)
-      Каждая запись = 8 байт.
+      - attempt_no: uint16_t — номер физической попытки данного seq, 1..65535; возвращается только тем же путём
+      - delay_us: uint32_t — задержка между приёмом DATA и формированием ACK, мкс; UINT32_MAX исключает RTT sample
+      При count>0 после всех записей обязательно добавляется [rx_data_bytes(8 LE)][rx_data_time_us(8 LE)].
+      Это точка приёма всего пути на момент формирования ACK, а не отдельной подтверждаемой попытки.
+      Время — монотонные микросекунды получателя при последнем положительном приросте DATA-байтов; 0/0 — точки нет.
+      Каждая запись = 10 байт, база ACK = 8 байт; полный размер = 8+10*count+(count>0 ? 16 : 0).
+      count=0 допустим для передачи till, точки приёма не содержит. До обработки проверяется вся длина ACK.
+      ACK_REQUEST: [0x0a], одна секция длиной 1 байт, запрос повторной отправки актуального till.
    в) channel timestamp (добавляется после выбора канала передачи, если есть свежие данные):
       [0x06] [RET_Timestamp(2 байта LE)] [RECV_Rel_Timestamp(2 байта LE)]
       - RET_Timestamp: uint16_t = last_recv_timestamp + (now - last_recv_local_time)
@@ -77,12 +195,20 @@ Burst-измерения bandwidth (0x07, 0x08) зарезервированы,
       - RECV_Rel_Timestamp: uint16_t = last_recv_local_time - last_recv_timestamp
         (относительное смещение между локальным и удалённым временем)
       Всего 5 байт. Добавляется только если last_recv_updated=1 (был принят пакет с момента последней отправки)
-      и если прошло не более ~100ms (dt < 1000000 таймбаз).
+      и если прошло менее 100с (dt < 1000000 таймбаз). Результат rtt_last задаёт нижнюю границу RTT для RTO;
+      DATA RTT и min_rtt BBR обновляются только ACK действующих физических попыток.
 3. Полезная нагрузка - заголовок 0x00 (одна секция и всегда последняя):
-      [0x00] [ID 4 байта LE] [данные...]
-     - ID: uint32_t, 32-битный циклический номер пакета
+      [0x00] [ID 4 байта LE] [attempt_no 2 байта LE] [данные...]
+     - ID: uint32_t, номер фрагмента 1..UINT32_MAX в пределах одной эпохи потока.
+     - attempt_no: uint16_t, номер 1..65535, общий для всех каналов одного ID.
+       Номер выдаётся при создании попытки и не возвращается при отказе send; исходный seq при повторе сохраняется.
+       После номера65535 следующая попытка аварийно меняет эпоху через REINIT; счётчик не оборачивается.
+       Перед выдачей seq=0 после UINT32_MAX поток также меняет эпоху: пара seq/attempt_no не повторяется внутри эпохи.
+       Смена эпохи отбрасывает прежний поток, владельцы восстанавливают свои операции по REINIT, как при фатальном OOM.
+       Старые DATA/ACK отклоняются заголовком сессии до разбора. Заголовок PAYLOAD занимает7 байт.
+       Внутренние хеш-очереди сохраняют64-битный ключ (seq<<16)|attempt_no; он не передаётся по сети целиком.
 Пакет может содержать несколько опциональных секций (например, ACK + channel_timestamp + данные),
-всегда в порядке: ACK, channel_timestamp, payload; payload всегда последний.
+Порядок: ACK, возможный ACK_REQUEST, измерительные/временные секции и FILLER, затем payload последним.
 Разбор секций — последовательное сканирование с известными размерами (нет явного поля длины секции).
 
 цель протокола:
@@ -93,97 +219,223 @@ Burst-измерения bandwidth (0x07, 0x08) зарезервированы,
 При прохождении трафика через этот модуль подсчитываются метрики (для каждого канала отдельно):
 - RTT последнего пакета и время отправки последнего пакета
 - общее количество отправленных/принятых байт
-- количество перезапросов (по каждому каналу отдельно) в пакетах. когда etcp модуль принял запрос ретрансмиссии он смотрит с какого интерфейса был отправлен этот пакет (это запоминается при отправке) и увеличивает счетчики.
+- число фактических повторных отправок; потери для BBR учитываются отдельно при истечении физических попыток.
 - обновление текущего количества неподтвержденных данных inflight (в пакетах и байтах) - сколько по этому каналу отправленных и неподтвержденных на текущий момент
 Планировщик/балансир каналов (etcp_loadbalancer.c/h):
-для каждого канала ограничение полосы с тестированием отклика:
-- полосу ограничиваем по объему данных - полному числу байт ethernet пакта (добавляем размер заголовков)
-  Ограничение реализуем следующим образом:
-   - в структуре есть счётчик времени (квантизация стандартная 0.1ms) по которое канал загружен данными. И суб-разряды (nanotime) этого счетчика 0.1ns - 0.1ms (считает по модулю 1000000 и переполнения добавляет в основной счетчик) чтобы при высоких скоростях не было потери точности.
-   Этим счётчиком контролируется полоса: при передаче к нему добавляется расчётное время передачи текущего ethernet пакета (используя текущий bandwidth считаем время передачи одного байта (float) и умножаем на число байт, переводим в таймбазу nanotime). А если при передаче время меньше current_time - delta_time (delta_time - константа в define, x0.1ms) то он устанавливается как current time-delta_time. (при неактивности обновляем время)
-   счетчик нужен для контроля можно ли передавать следующий пакет ("расчётное время передачи");
-когда etcp пытается отправить пакет через линк, то если в линке не инициализировано подключение и он клиент - то он отбрасывает этот пакет и запускает процесс установки соединения.
-также процесс установки соединения инициируется при добавлении канала (в etcp_link_new) если это client.
+Окно и pacing проверяются до извлечения DATA из очереди; без допустимого UP-линка фрагмент остаётся в очереди.
+У каждого линка собственный shaper по точной bbr_pacing_rate в байтах/с:
+- После успешного send списываются только payload_len DATA-байтов, без заголовков и ACK.
+- Основной счётчик времени имеет единицу 0.1 мс; sub-разряды — 0.1 нс, модуль 1000000.
+  Прибавка равна ceil(payload_len * 10000000000 / bbr_pacing_rate), вычисляется целочисленно в uint64.
+- Накопленный кредит после простоя ограничивается 1 мс. При смене ставки пересчитывается оставшийся долг;
+  таймер снимается и при необходимости назначается заново. При нулевой ставке pacing не ограничивает отправку.
+- Положительный долг должен быть строго меньше 1 мс. Таймер ждёт первого допустимого TB:
+  shaper_load_time_tb - SHAPER_BURST_DELAY_TB + 1; дробь меньше TB не меняет эту строгую границу.
+  uasync округляет срок вверх до миллисекунды; callback повторно проверяет готовность перед уведомлением.
+- ACK/control и измерительная burst-серия не списывают DATA-pacing. Окно DATA проверяется и в burst.
+Конструктор исходящего UDP-линка запускает INIT сразу; TCP использует отдельный STCP connect/handshake.
 процесс установки соединения (рукопожатие):
 - клиент отправляет init запрос и выставляет таймаут
-- по таймауту повторяет init запросы с экспоненциально растущим интервалом (начальный 500ms, макс 50s, +25% каждые 10 попыток), ведется счетчик запросов init.
+- по таймауту повторяет INIT: начальный интервал 500 TB = 50 мс, максимум 50000 TB = 5 с;
+  каждые 10 отправок интервал увеличивается на interval/4 + 1 TB. TB здесь равен 0.1 мс.
 - когда клиент получает init подтверждение — снимает таймаут, выставляет link_state=connected, запускает keepalive.
-- сервер при получении init запроса: если линк существует и session_id совпал — отвечает без сброса (0x05); если session_id новый — выполняет etcp_conn_reinit и отвечает со сбросом (0x03).
-При добавлении нового канала: если link_state=1 (handshake) — посылаем INIT со сбросом (0x02); если link_state=2 (reconnect) — без сброса (0x04).
+- каждая сторона сообщает в INIT собственный reset_id (64 бита, BE); ответ не повторяет эпоху запроса.
+- первая неизвестная эпоха пира сохраняется из handshake. Смена уже известной эпохи запускает challenge;
+  только подходящий CONFIRM сбрасывает поток и заменяет эпоху пира, сохраняя собственную.
+- повтор INIT и коллизия встречных подключений сами по себе не сбрасывают поток.
+При добавлении нового канала: если link_state=1 (handshake) — посылаем INIT_REQUEST (0x02);
+если link_state=2 (reconnect) — INIT_REQUEST_NOINIT (0x04). Коды INIT не заменяют подтверждение смены эпохи.
 link_state: 0=just init, 1=handshake, 2=reconnect, 3=connected.
 
 **** Формат кодограмм для etcp_connections.c/h ****
 Кодограммы с этими секциями обрабатываются в etcp_connections (в этих кодограммах всегда одна секция-тип пакета). В обязательном заголовке (timestamp+flag_up) ID не используется.
 
 Типы пакетов:
-    0x02 — ETCP_INIT_REQUEST (со сбросом etcp сессии)
-    0x03 — ETCP_INIT_RESPONSE (подтверждение со сбросом)
-    0x04 — ETCP_INIT_REQUEST_NOINIT (без сброса)
-    0x05 — ETCP_INIT_RESPONSE_NOINIT (подтверждение без сброса)
+    0x02 — ETCP_INIT_REQUEST (начальный handshake линка)
+    0x03 — ETCP_INIT_RESPONSE (вариант ответа INIT)
+    0x04 — ETCP_INIT_REQUEST_NOINIT (восстановление линка, также разрешение коллизии)
+    0x05 — ETCP_INIT_RESPONSE_NOINIT (вариант ответа INIT)
     0x06 — ETCP_PING (проверка доступности)
     0x07 — ETCP_PONG (ответ на пинг)
+    0x08 — ETCP_KEEPALIVE
+    0x09 — ETCP_SESSION_DATA (обёртка секций DATA/ACK с эпохами)
+    0x0a — ETCP_SESSION_HELLO
+    0x0b — ETCP_SESSION_CHALLENGE
+    0x0c — ETCP_SESSION_CONFIRM
+    0x0d — ETCP_TCP_ADDRESS (STCP: code + family(4/6) + observed IP(16), без порта)
+
+    Варианты ответа 0x03/0x05 не определяют смену эпохи: клиент в обоих случаях обрабатывает reset_id одинаково.
 
     1) Init запрос (0x02 / 0x04):
-       [code(1)] [my_node_id(8 BE)] [session_id(4 BE)] [mtu_local(2)] [keepalive_interval(2)]
-       [recovery_interval/100(2)] [local_link_id(1)] [sock_id(1)] [only_local(1)] [type(1)]
+       [code(1)] [node_id(8 BE)] [reset_id(8 BE)] [mtu(2 BE)] [keepalive(2 BE)]
+       [recovery(2 BE)] [link_id(1)] [socket_id(1)] [only_local(1)] [type(1)]
+       [src_ipv4(4)] [src_port(2 BE)] [collision(1)] [ed25519_pubkey(32)] [device_type(1)]
        [random_padding...] [salt(SC_PUBKEY_ENC_SALT_SIZE)] [obfuscated_pubkey(SC_PUBKEY_SIZE)]
-       - code: 0x02 (со сбросом) или 0x04 (без сброса)
+       Фиксированное тело до padding — 67 байт (ETCP_INIT_REQUEST_PKT).
+       - code: 0x02 или 0x04, вариант handshake линка
        - node_id: 64 бита, идентификатор узла (big-endian)
-       - session_id: 32 бита, случайный ID сессии генерируется клиентом (big-endian)
-       - mtu_local: uint16_t локальный MTU
-       - keepalive_interval: uint16_t интервал keepalive в мс
-       - recovery_interval: uint16_t = recovery_interval/100 (в таймбазах 0.1мс / 100)
-       - local_link_id: uint8_t (0-255), назначается отправителем
-       - sock_id: uint8_t, уникальный ID сокета отправителя
+       - reset_id: uint64_t, собственная локальная эпоха потока клиента (big-endian)
+       - mtu: uint16_t локальный MTU
+       - keepalive: uint16_t интервал keepalive в мс
+       - recovery: uint16_t = link->recovery_interval/100 (исходная единица — 0.1 мс)
+       - link_id: uint8_t (1-255), назначается отправителем; ноль запрещён
+       - socket_id: uint8_t, уникальный ID сокета отправителя
        - only_local: uint8_t, флаг "только локальные подключения"
-        - type: uint8_t, тип сокета (CFG_SERVER_TYPE_UNKNOWN=0/PUBLIC=1/NAT=2/PRIVATE=3/LOCAL=4)
+       - type: uint8_t, конфигурационный тип сокета CFG_SERVER_TYPE_*
+       - src_ipv4/src_port: адрес интерфейса отправителя; для IPv6 src_ipv4=0, порт сохраняется;
+         при SOCKS5 оба поля нулевые. Это заявленный адрес, а не наблюдение внешнего NAT-адреса.
+       - collision: 1 — отправитель разрешает встречное подключение, заявляя роль master для линка
+       - ed25519_pubkey: публичный ключ Ed25519 отправителя, 32 байта
+       - device_type: CLIENT_TYPE_SERVER/DESKTOP/MOBILE
        - random_padding: случайные байты до размера handshake (защита от fingerprinting)
-       - salt + obfuscated_pubkey: публичный ключ с обфускацией (не шифруется AES,
-         но скрывается XOR с salt и собственным публичным ключом). Передаётся в конце пакета
+       - salt + obfuscated_pubkey: ключ отправителя XOR SHA256(salt || публичный ключ получателя).
+         Этот блок не шифруется AES, передаётся в конце пакета
          в noencrypt_len байтах (не попадает под AES-шифрование)
-       Инициирует новый connection для tcp instance. Если tcp instance нет (первое подключение) - создаёт.
-       Между нодами только одно подключение, но можно добавлять каналы.
+       INIT устанавливает UDP-линк: создаёт или переиспользует общий ETCP_CONN к пиру.
+       Между узлами одно ETCP-соединение с несколькими линками; TCP-линк использует STCP handshake.
 
     2) Init подтверждение (0x03 / 0x05):
-       [code(1)] [my_node_id(8 BE)] [session_id(4 BE)] [mtu_local(2)] [local_link_id(1)]
-       [remote_socket_id(1)] [only_local(1)] [type(1)] [peer_ipv4(4)] [peer_port(2)]
-       [random_padding...]
-       - code: 0x03 (со сбросом) или 0x05 (без сброса)
+       [code(1)] [node_id(8 BE)] [reset_id(8 BE)] [mtu(2 BE)] [link_id(1)]
+       [remote_socket_id(1)] [only_local(1)] [type(1)] [peer_ipv4(4)] [peer_port(2 BE)]
+       [ed25519_pubkey(32)] [device_type(1)] [keepalive(2 BE)] [random_padding...]
+       Фиксированное тело до padding — 64 байта (ETCP_INIT_RESPONSE_PKT).
+       - code: 0x03 или 0x05, вариант ответа INIT; сам по себе не сбрасывает поток клиента
        - node_id: 64 бита, big-endian
-       - session_id: 32 бита, big-endian (должен совпасть с запросом клиента; если нет — клиент игнорирует)
-       - mtu_local: uint16_t локальный MTU сервера
-       - local_link_id: uint8_t идентификатор канала сервера
-       - remote_socket_id: uint8_t (копируется из запроса)
+       - reset_id: uint64_t, собственная локальная эпоха потока сервера (big-endian), не эхо запроса
+       - mtu: uint16_t локальный MTU сервера
+       - link_id: uint8_t идентификатор канала сервера, 1..255
+       - remote_socket_id: uint8_t (ID серверного сокета; ID клиентского сокета известен серверу из запроса)
        - only_local: uint8_t флаг сервера
        - type: uint8_t тип сокета сервера
-       - peer_ipv4: 4 байта (IPv4 адрес клиента как его видит сервер — для NAT traversal)
-       - peer_port: 2 байта (порт клиента как его видит сервер)
+       - peer_ipv4: 4 байта (IPv4 адрес клиента как его видит сервер, в сетевом порядке)
+       - peer_port: uint16_t (порт клиента как его видит сервер, big-endian)
+         При IPv6 оба поля нулевые.
+       - ed25519_pubkey: публичный ключ Ed25519 сервера, 32 байта
+       - device_type: CLIENT_TYPE_SERVER/DESKTOP/MOBILE
+       - keepalive: uint16_t интервал keepalive сервера в мс
        - random_padding: случайные байты
 
     3) PING (0x06):
-       [0x06] [node_id(8 BE)] [nonce(8 BE)] [user_data_len(2 BE)] [user_data...]
+       [0x06] [flags(1)] [node_id(8 BE)] [nonce(8 BE)] [user_data_len(2 BE)] [user_data...] [padding...]
        [salt(SC_PUBKEY_ENC_SALT_SIZE)] [obfuscated_pubkey(SC_PUBKEY_SIZE)]
        Отправляется с отдельным crypto-контекстом (не связан с ETCP-сессией).
        Используется для проверки доступности узла и NAT-тестирования.
 
     4) PONG (0x07):
-       [0x07] [node_id(8 BE)] [nonce(8 BE)] [resp_data_len(2 BE)] [response_data...]
+       [0x07] [flags(1)] [node_id(8 BE)] [nonce(8 BE)] [resp_data_len(2 BE)] [response_data...] [padding...]
        [salt(SC_PUBKEY_ENC_SALT_SIZE)] [obfuscated_pubkey(SC_PUBKEY_SIZE)]
        Ответ на PING. nonce копируется из запроса для сопоставления.
+       Nonce генерируется CSPRNG. Проверяются также ключ отправителя, source IP:port,
+       ID и поколение принимающего сокета. Флаг OBSERVE (0x04) запрашивает ответ
+       address(19) || tag(25): family(4/6), IP(16), port(2, BE), NAT2UDP!(8),
+       socket_id(1), generation(8, BE), round(8, BE).
+       ADDRESS_CHECK (0x08) — аутентифицированное входящее испытание endpoint.
+       Модель NAT и алгоритм владельца: doc/nat_detection.txt.
 
-При получении init получатель пакета должен:
-- reset ETCP_LINK с этим ip_port если он есть
-- создать новый ETCP_CONN с этим node_id. если уже существует подключение с этим node_id - проверить ключи на совпадение.
-приём кодограмм из UDP выглядит так:
-uasync select -> etcp_connection.c etcp_connections_read_callback: memory_pool_alloc, decrypt (or init) -> etcp_conn_input (etcp.c/h - сам tcp механизм) -> ETCP_CONN output_queue
+До изменения транспорта INIT_REQUEST проверяет полное 67-байтовое тело и соответствие node_id
+аутентифицированному X25519-ключу. Оба направления INIT отклоняют link_id=0 и MTU меньше
+ETCP_MIN_UDP_MTU(family): 191 байт для IPv4, 211 для IPv6. MTU больше 1500 ограничивается сверху.
+Получатель создаёт или переиспользует ETCP_CONN и подходящий линк;
+для существующего соединения проверяет совпадение ключа пира. Эпоха из INIT учитывается
+через etcp_conn_apply_peer_reset_id, без немедленного сброса потока при смене известной эпохи.
+Принятый INIT обновляет recv_keepalive, время последнего RX и входной remote_keepalive=flag_up
+до переиспользования буфера для ответа. INIT с flag_up=0 снимает прежний UP UDP-линка:
+получение запроса доказывает только входящую достижимость, обратный путь ещё не подтверждён.
+Ответ и keepalive отправляются и при DOWN, чтобы холодное подключение и восстановление
+могли завершить двустороннюю проверку. При DOWN одного линка соединение остаётся UP,
+если есть другой работоспособный линк. Повтор неизменного состояния не создаёт нового DOWN/UP.
+INIT_RESPONSE должен содержать полное обязательное тело (64 байта без timestamp/flag_up)
+и node_id, соответствующий аутентифицированному ключу пира. Усечённый ответ или чужой node_id
+отклоняются до изменения живости, эпохи и параметров линка. Дополнительный padding разрешён.
+Входящий conn с известным ключом индексируется по node_id до callback создания линка.
+Отмена входящего линка из callback не закрывает conn, если у него появился другой линк или NCD-владелец.
+Close немедленно отключает линк и ресурсы, но память удерживается active_users до выхода внутренних стеков RX/переходов/callbacks.
+Приём UDP: uasync -> etcp_connections_read_callback_socket -> etcp_process_packet ->
+etcp_packet_decrypted (проверки и снятие SESSION_DATA) -> etcp_conn_input -> normalizer/output_queue.
 
-Keepalive: пакет без секций (только timestamp+flag_up в шифрованном заголовке, data_len=0).
-keepalive пакеты шлют и клиент и сервер с заданным интервалом если нет полезного трафика.
+Keepalive: [0x08] [flags(1)] [period_ms(2 LE)] [sleep_fields?:4] [padding...].
+При KA_FLAG_SLEEP добавляются active_remaining(2 LE) и sleep_duration(2 LE), оба в единицах 0.1 с.
+Полезное тело занимает 4 байта без SLEEP или 8 байт с SLEEP; остальные байты — padding.
+Обычные keepalive периодически шлют обе стороны; полезный TX сбрасывает адаптивный период к базовому.
+Сон одной из сторон останавливает обычный таймер. UDP-анонс сна подтверждается флагом SLEEP_ACK,
+повторяется до ACK/исчерпания попыток; TCP отдельного подтверждения сна не требует.
+RX watchdog работает отдельно в normal и standby и не продлевается собственными отправками.
 Сервер прекращает слать keepalive если линк потерян (ждёт keepalive от клиента).
 flag_up в заголовке устанавливается в значение recv_keepalive (признак что локальная сторона принимает пакеты).
 
+Padding keepalive, PING/PONG и STCP-handshake:
+- ETCP_CONN хранит собственный диапазон min/max и независимый таймер для всех своих линков.
+- UTUN_INSTANCE хранит отдельный диапазон и таймер для PING/PONG без существующего ETCP_CONN.
+- При создании владельца и каждом обновлении: min=rand(0,30), max=min+rand(32,128), границы включительные.
+- Следующее обновление назначается через rand(50,300) секунд. При закрытии владельца таймер отменяется.
+- Каждый пакет независимо выбирает длину rand(min,max); padding заполняется нулями ДО шифрования.
+- UDP PING/PONG: padding шифруется перед CRC/tag; открытый salt+pubkey остаётся в конце датаграммы.
+  user_data_len/resp_data_len обозначают только полезные данные. PONG не копирует padding запроса.
+- STCP: salt(8)+pubkey(32) открыты, затем 51 байт зашифрованного handshake и padding_size байт
+  нулевого padding, зашифрованного продолжением того же CTR. Приём продвигает CTR через padding;
+  padding_size=0 сразу завершает handshake. При ETCP_CONN клиент читает актуальный диапазон при отправке;
+  без ETCP_CONN сохраняет выбранную длину при запуске. Сервер выбирает длину независимо по пиру/instance.
+- Каждый STCP-поток использует соль своего отправителя: клиентскую для client→server, серверную для server→client.
+  CTR IV = первые 12 байт SHA256(session_key || stream_id_LE || salt(8) || "uTun3-stream") + четыре нулевых байта.
+  Отправка инициализируется после генерации своей соли, приём — после чтения соли пира, до расшифровки тела.
+  После handshake CTR непрерывно продолжается через padding и DATA, без повторной инициализации на кадр.
+- Padding не должен превышать 158 байт. Для UDP длина ограничивается оставшимся MTU;
+  если не помещается даже min, отправка завершается ошибкой без обрезания пользовательских данных.
+- Диагностика диапазонов/обновлений/PING/PONG: etcp=debug; keepalive: keepalive=debug.
+
 Клиент: если все линки =down то начинается процедура восстановления связи:
 - клиент посылает init без сброса (0x04), link_state=2
-- сервер как получает init проверяет session_id:
-  - если session_id совпадает — шлёт подтверждение без сброса (0x05)
-  - если session_id изменился (клиент перезапустился) — шлёт подтверждение со сбросом (0x03)
+- сервер восстанавливает физический линк и отвечает INIT_RESPONSE/INIT_RESPONSE_NOINIT со своей эпохой.
+- прежняя эпоха пира не меняет поток; смена известной эпохи подтверждается через CHALLENGE/CONFIRM.
+  Код ответа 0x03/0x05 не является подтверждением смены эпохи.
+
+**** Подтверждение транспортной сессии (etcp_session.c/h) ****
+Physical UDP INIT / STCP handshake establishes an authenticated link. A stream reset
+uses the same control protocol on every initialized UDP or TCP link, bypassing the
+normalizer and reliable DATA/ACK queues. A stream reset does not generate physical DOWN/UP.
+
+Encrypted DATA/ACK plaintext after timestamp(2) + flag_up(1):
+    09 | sender_epoch:u64be | receiver_epoch:u64be | existing ACK/DATA sections
+The extra 17 bytes participate in the MTU budget. Unwrapped DATA/ACK and frames with
+an epoch mismatch are discarded before stream state or link liveness is updated.
+
+Control frames (all 25 bytes after timestamp/flag):
+    0a HELLO     | sender_epoch | receiver_epoch | 0
+    0b CHALLENGE | sender_epoch | receiver_epoch | random_cookie:u64be
+    0c CONFIRM   | sender_epoch | receiver_epoch | echoed_cookie:u64be
+
+Each connection owns one pending peer epoch, fresh challenge, and retry timer.
+The first nonzero peer epoch from a physical handshake is stored directly if unknown.
+HELLO and a change to an already known epoch advertised by INIT only request a challenge. Only a
+CONFIRM for the current local epoch and pending random challenge commits a peer
+epoch. Changing the peer epoch resets the stream but preserves our own epoch.
+A local fatal reset generates a new local epoch and blocks DATA until confirmation.
+Both sides may reset concurrently. Loss of any control frame is recovered by a
+500 ms retry on all initialized links. After 10 s an unconfirmed local reset closes
+the connection; an unconfirmed candidate alone is discarded without closing a
+working session. Close cancels the timer before destroying links.
+
+TCP may initially receive peer epoch zero because the server creates ETCP_CONN
+only after STCP handshake. It completes the same session confirmation before INIT/UP.
+REINIT notifies stream consumers without tearing down physical ownership. The
+router retains end-to-end inflight; BGP repeats JOIN_GROUP and TABLE_REQUEST because
+its previous control messages may have been discarded by the stream reset.
+
+Отказы памяти и прерывание потока:
+- OOM до сохранения RX DATA в recv_q не создаёт ACK; отправитель повторяет DATA.
+- ACK означает принятие в текущий транспортный поток, а успешный etcp_send —
+  передачу владения транспорту. Оба не гарантируют завершение операции сервиса
+  после прерывания сессии. Надёжность операции через REINIT обеспечивает её владелец.
+- OOM после принятия данных в normalizer или при подготовке TX inflight вызывает
+  fatal REINIT: новая локальная эпоха, блокировка DATA, отбрасывание старых очередей,
+  частичных кодограмм и физических попыток. Старые payload не воспроизводятся.
+  Физические линки сохраняются; очистка очередей/reset не выделяет память.
+- Активный обработчик освобождает собственный извлечённый фрагмент ровно один раз;
+  после reset/close из callback он прекращает разбор старой кодограммы/пакета.
+- Согласование новой эпохи выполняется после очистки. OOM control-пакета оставляет
+  повтор активным, без продления исходного срока 10с. Отказ обязательного session-
+  таймера или генерации локальной эпохи закрывает соединение с диагностикой.
+  Если невозможно выделить даже обязательный deferred-close token внутри callback,
+  процесс завершается через abort: соединение не оставляется в зависшем состоянии.
+- После подтверждения эпох владельцы получают REINIT и восстанавливают операции
+  своего протокола; при невозможности согласования соединение закрывается.

doc/etcp_router_arch.md

@@ -1,324 +1,149 @@
-# ETCP Router Architecture
+# Архитектура ETCP Router
 
-## Структуры данных
+Маршрутизатор связывает сервис с удалённым узлом через группу, не привязывая логическую
+сессию к одному физическому ETCP. Ключ канала — `(group_id, remote_node_id, svc_id)`.
+Wire-формат и сервисный API подробно описаны в [etcp_router_doc.md](../src/routing_layer/etcp_router_doc.md),
+объявления — в [etcp_router.h](../src/routing_layer/etcp_router.h).
 
-```
-ETCP_ROUTER_CONN (один на пару remote_node_id + svc_id)
-┌─────────────────────────────────────────────────────┐
-│  ll_entry  (хеш-индекс: remote_node_id[8] + svc_id[1]) │
-│  remote_node_id: u64                                 │
-│  svc_id:         u8                                  │
-│  last_dgram_ts:  u16  (timestamp последней датаграммы) │
-│                                                      │
-│  tx_seq:  u32   следующий seq для отправки            │
-│  rx_seq:  u32   ожидаемый seq для сборки              │
-│  tx_acked: u32  сколько наших пакетов подтвердил remote │
-│  last_sent_ack_seq: u32  последний отправленный ACK    │
-│                                                      │
-│  recv_q:  ll_queue*  очередь reorder (хеш по seq[4])  │
-│  send_q:  ll_queue*  очередь при переполнении inflight │
-│                                                      │
-│  ack_timer:          void*   периодический 100ms      │
-│  idle_ack_timer:     void*   idle таймаут 500ms       │
-│  send_resume_timer:  void*   retry send_q 50ms        │
-│  send_blocked:       u8      inflight полон           │
-└─────────────────────────────────────────────────────┘
+## Отправка и приём
 
-SVC_ROUTE_HDR (22 байта)
-┌──────┬────────────────┬────────────────┬───────┬────────┬──────────┐
-│ cmd  │  dst_node_id   │  src_node_id   │  seq  │ svc_id │ payload  │
-│  u8  │      u64       │      u64       │  u32  │  u8    │  ...     │
-└──────┴────────────────┴────────────────┴───────┴────────┴──────────┘
-
-  seq в data-пакетах = tx_seq (счетчик отправленных)
-  seq в ACK-пакетах   = rx_seq (ожидаемый следующий)
-  CLOSE-флаг = 0x80000000 в seq, RST-флаг = 0x40000000
+```mermaid
+flowchart TD
+    Producer["Сервис: payload + mode"] --> Send["send_q: plaintext, seq, mode"]
+    Send --> Session{"peer_reset_id подтверждён?"}
+    Session -- нет --> Hello["HELLO / challenge / confirm"]
+    Hello --> Session
+    Session -- да --> Route["Текущий маршрут: conn_mgr → BGP, либо прямой глобальный ETCP"]
+    Route --> Wait["Waiter физической send_input_q"]
+    Wait --> Encode["route_crypto_encode: encrypt → sign"]
+    Encode --> Inflight["inflight_q: неизменяемое тело без visited-list"]
+    Inflight --> Path["Добавить source ID"]
+    Path --> ETCP["etcp_send / normalizer"]
+    Inflight -- RTO 300 ms --> Wait
+    ETCP --> Network["Сеть / транзитные узлы"]
+    Network --> Check["Проверить visited-list"]
+    Check --> Destination{"dst=self?"}
+    Destination -- нет --> Transit["Добавить self один раз, BGP next hop / transit FIFO"]
+    Transit --> Network
+    Destination -- да --> Decode["Crypto policy + verify/decrypt + проверка эпох"]
+    Decode --> Incoming["incoming_q: plaintext"]
+    Incoming --> Reorder["recv_q: reorder по seq"]
+    Reorder --> Ready{"receive_ready разрешает?"}
+    Ready -- нет --> Busy["Сохранить пакет, ACK RECEIVE_BUSY"]
+    Busy --> Resume["resume_receive: отложенное продолжение"]
+    Resume --> Reorder
+    Ready -- да --> Callback["Callback сервиса получает entry"]
+    Callback --> Ack["rx_seq++ → ACK текущей границы"]
+    Ack --> Release["Отправитель снимает подтверждённый inflight"]
 ```
 
-## Send Path (отправка данных)
+Каждая кодограмма имеет самостоятельный seq; это не байтовый поток.
+send_q ограничена 64 пакетами при обычной отправке, `force` обходит этот порог.
+Inflight по умолчанию — 256, при minRTT probe — 4. Получатель ограничивает reorder
+окном max_inflight и суммарным размером очередей max_inflight+1 записей.
 
-```
-                    etcp_route_send(inst, dst, entry)
-                    etcp_router_conn_send(rconn, data, len)
-                              │
-                              ▼
-                    ┌─────────────────────┐
-                    │ rconn = find/get    │  поиск по (dst, svc_id)
-                    │ авто-создание если │  или etcp_router_conn_get()
-                    │ ещё нет            │
-                    └────────┬────────────┘
-                             │
-                             ▼
-              ┌──────────────────────────────┐
-              │ inflight < ROUTER_MAX(256)?  │
-              │ tx_seq - tx_acked < 256 ?    │
-              └──────┬───────────┬───────────┘
-                     │ YES       │ NO (inflight полон)
-                     ▼           ▼
-          ┌──────────────┐  ┌─────────────────────┐
-          │router_send_one│  │ router_enqueue_send │ → send_q (FIFO)
-          │  (прямая)     │  │   (в очередь)       │   send_blocked = 1
-          └──────┬────────┘  └─────────┬───────────┘   send_resume_timer (50ms)
-                 │                     │
-                 ▼                     │
-     ┌────────────────────┐            │
-     │ tx_seq++           │            │
-     │ hdr.dst = dst      │            │
-     │ hdr.src = node_id  │            │
-     │ hdr.seq = tx_seq   │            │
-     │ hdr.svc_id = svc   │            │
-     │                     │            │
-     │ etcp_send(conn, e)  │            │
-     └────────────────────┘            │
-                                       │
-          ┌────────────────────────────┘
-          │  (при получении ACK от remote)
-          ▼
-   ┌────────────────────┐
-   │ router_drain_send_q│  вызывается из ACK handler
-   │                     │  или по send_resume_timer
-   │ while inflight < 256│
-   │   e = send_q.pop()  │
-   │   router_send_one(e)│
-   │                     │
-   │ если send_q пуст:   │
-   │   send_blocked = 0  │
-   └────────────────────┘
+Все события выполняются в uasync-потоке. Штатный normalizer откладывает physical waiters,
+а callbacks производителей send_q могут выполняться синхронно при освобождении места.
+Поэтому код отправки повторно проверяет состояние/эпохи после callback.
+
+## Эпохи логического канала
+
+Полный сетевой пакет:
+
+`[57-byte SVC_ROUTE_HDR][payload][signature?][visited_ids:8*N][count:1]`
+
+Числа в заголовке — native endian. flags — отдельный байт; биты seq не заняты флагами.
+Заголовок включает group/src/dst/service, seq/timestamp и поля reset_id/peer_reset_id/challenge.
+visited-list содержит 1..64 ID, находится вне подписи/шифрования и проверяется на каждом переходе.
+
+Первичное согласование двух сторон имеет вид:
+
+```mermaid
+sequenceDiagram
+    participant A as Узел A, local=a
+    participant B as Узел B, local=b
+    A->>B: HELLO(reset=a, peer=0)
+    B->>A: CHALLENGE(reset=b, peer=a, cB)
+    A->>B: CONFIRM(reset=a, peer=b, cB)
+    A->>B: CHALLENGE(reset=a, peer=b, cA)
+    B->>A: CONFIRM(reset=b, peer=a, cA)
+    Note over A,B: Каждый узел принимает peer ID только после ответа на свой pending challenge
 ```
 
-## Receive Path (приём данных)
+Получение HELLO/CHALLENGE с неизвестной эпохой само по себе не сбрасывает работающий канал.
+Переставленные/старые CONFIRM не совпадают с pending ID/challenge и игнорируются.
+Новые challenge ограничены интервалом 300 ms; первичный HELLO повторяется без отдельного timeout.
 
-```
-               etcp_router_recv_cb(conn, entry)
-                         │
-                         ▼
-              ┌──────────────────────┐
-              │ dst == node_id?      │
-              └──┬───────────────┬───┘
-                 │ YES           │ NO (транзит)
-                 ▼               ▼
-    ┌────────────────────┐   ┌──────────────────────────┐
-    │ Мы — целевая нода   │   │ Транзит: найти next hop   │
-    └────────┬───────────┘   │ route_bgp_find_conn_for_  │
-             │               │ node(bgp, hdr.dst)        │
-             ▼               │ etcp_send(next, entry)    │
-    ┌────────────────────┐   └──────────────────────────┘
-    │ pl_len == 0?       │
-    └──┬───────────┬─────┘
-       │ YES       │ NO (данные)
-       ▼           ▼
-  ┌─────────┐  ┌─────────────────────────┐
-  │ CLOSE/  │  │ rconn = find/get        │
-  │ RST?    │  │ (авто-создание если нет) │
-  └──┬──┬───┘  └───────────┬─────────────┘
-     │  │                  │
-     │  │ NO (ACK)         ▼
-     │  ▼          ┌───────────────────────────────────────┐
-     │ ┌──────────┐│ Проверка границ seq:                   │
-     │ │ tx_acked ││ d = seq - rx_seq                       │
-     │ │ = hdr.seq││ |d| < ROUTER_MAX_INFLIGHT?             │
-     │ │ (только  ││                                        │
-     │ │ вперёд)  ││ Дубликат?                              │
-     │ │ drain_q  ││ rx_seq - seq > 0  ИЛИ                  │
-     │ └──────────┘│ seq уже в recv_q?                      │
-     │             └──────┬─────────────┬──────────────────┘
-     │                    │ OK          │ out-of-bounds / dup
-     │                    ▼             ▼
-     │             ┌──────────────┐  ┌─────────┐
-     │             │ recv_q.put() │  │ DROP    │
-     │             │ хеш по seq   │  └─────────┘
-     │             └──────┬───────┘
-     │                    │
-     │                    ▼
-     │             ┌──────────────────────┐
-     │             │ seq == rx_seq?       │
-     │             └──┬───────────────┬───┘
-     │                │ YES           │ NO
-     │                ▼               │
-     │         ┌──────────────┐       │
-     │         │ try_assembly │       │
-     │         │ while next в │       │
-     │         │ recv_q:      │       │
-     │         │   deliver()  │       │
-     │         │   rx_seq++   │       │
-     │         └──────┬───────┘       │
-     │                │               │
-     │                ▼               │
-     │         ┌──────────────────────┴──┐
-     │         │ router_deliver()        │
-     │         │ вызывает callback       │
-     │         │ сервиса (svc_id)        │
-     │         │ entry: [svc_id|payload] │
-     │         └──────────────┬──────────┘
-     │                        │
-     ▼                        ▼
-  ┌────────────────────────────────────┐
-  │ router_schedule_ack(rconn)         │
-  │ запускает ack_timer (100ms) если   │
-  │ ещё не запущен                     │
-  └────────────────────────────────────┘
-```
+| Событие | Что сохраняется | Что меняется |
+| --- | --- | --- |
+| Смена ETCP/next hop | Логические эпохи, seq, очереди | Физический waiter/маршрут |
+| Первое подтверждение peer | Накопленная send_q | Заполняется peer_reset_id, начинается отправка |
+| Подтверждённый рестарт peer | Собственный reset_id | Очереди, seq, RTT/метрики; уведомление сервиса |
+| Явный conn_restart | Ключ group/peer/service и адрес rconn | Новый reset_id, пустое состояние; затем callback и HELLO |
+| conn_close | Только данные, переданные во владение callback | Запись снимается с реестра, ресурсы освобождаются |
 
-```
-     CLOSE / RST ветка:
-     ┌────────────────────────────────────────┐
-     │ pl_len == 0 && seq & CLOSE/RST         │
-     │   → router_close_and_notify(rconn)     │
-     │     ├─ router_send_close_to_service()  │
-     │     │   (callback с NULL conn)         │
-     │     ├─ отправить CLOSE удалённой стороне│
-     │     ├─ отмена всех таймеров            │
-     │     ├─ очистка recv_q + send_q         │
-     │     └─ удаление из inst->router_conns  │
-     └────────────────────────────────────────┘
-```
+Сервис возобновляет прикладную синхронизацию после сброса; старые гарантии доставки через reset не продолжаются.
+Готовность router означает наличие подтверждённого peer ID. Это отдельное состояние
+от физического UP и READY BGP-группы.
 
-## ACK Mechanism
+## Подтверждение и пауза потребителя
 
-```
-         ┌─────────────────────────────────────────┐
-         │       router_schedule_ack(rconn)        │
-         │  (вызывается при получении данных)       │
-         └────────────────┬────────────────────────┘
-                          │
-         ┌────────────────▼────────────────────────┐
-         │  если idle_ack_timer активен — отменить  │
-         │  если ack_timer не активен — запустить   │
-         │  ROUTER_ACK_INTERVAL_TB = 1000 (100ms)  │
-         └────────────────┬────────────────────────┘
-                          │
-                          ▼  (через 100ms)
-         ┌─────────────────────────────────────────┐
-         │          router_ack_timer_cb()           │
-         │                                          │
-         │  if rx_seq != last_sent_ack_seq:         │
-         │    router_send_ack(rconn)                │
-         │    last_sent_ack_seq = rx_seq            │
-         │    перезапустить ack_timer               │
-         │  else:                                   │
-         │    запустить idle_ack_timer (500ms)      │
-         └────────────────┬────────────────────────┘
-                          │
-                          ▼  (через 500ms)
-         ┌─────────────────────────────────────────┐
-         │        router_idle_ack_timer_cb()        │
-         │                                          │
-         │  if rx_seq != last_sent_ack_seq:         │
-         │    router_send_ack(rconn)   (досылка)    │
-         │    last_sent_ack_seq = rx_seq            │
-         └─────────────────────────────────────────┘
+DATA проходят crypto policy и verify/decrypt до изменения reorder/rx_seq.
+Сервис получает `[svc:1][src:8][dst:8][rx_flags:1][group:8][payload]`, всего 26 байт заголовка.
+Его callback владеет entry, ACK продвигается после успешной передачи callback.
 
-         router_send_ack(rconn):
-           hdr.seq = rx_seq
-           hdr.svc_id = svc_id
-           pl_len = 0  →  это ACK-пакет
-           etcp_send(conn, entry)
-```
+ACK подтверждает только диапазон до tx_sent, в модульном порядке uint32.
+При продвижении снимаются существующие inflight-записи и один раз учитываются исходные payload bytes.
 
-```
-         Обработка входящего ACK:
-         ┌────────────────────────────────────────┐
-         │ pl_len == 0 && нет CLOSE/RST флагов     │
-         │                                         │
-         │ if seq >= tx_acked:    // только вперёд │
-         │   tx_acked = seq       // обновить      │
-         │ else:                                   │
-         │   DEBUG_WARN "stale ACK"                │
-         │                                         │
-         │ if send_blocked:                        │
-         │   router_drain_send_q(rconn)            │
-         └────────────────────────────────────────┘
-```
+RECEIVE_BUSY не подтверждает отложенные DATA, но поддерживает живость ожидающего диска/буфера сервиса.
+Даже при прежнем seq допустимый BUSY обновляет отсчёт RTO и останавливает новую отправку/проход ретрансмитов.
+Обычный повторный ACK без продвижения этого не делает. Снятие BUSY возобновляет send_q.
 
-## Inflight Control
+receive_ready — предикат без I/O и изменения/закрытия роутера. При 0 пакет сохраняется в recv_q;
+resume_receive планирует продолжение. Управляющий CLOSE не проходит через этот предикат.
 
-```
-   ROUTER_MAX_INFLIGHT = 256
+| Механизм | Интервал/условие |
+| --- | --- |
+| ACK | Не чаще 10 ms; текущая граница повторяется при дубликате DATA после потери ACK |
+| RECEIVE_BUSY | Около 100 ms, пока сервис остановлен |
+| Idle ACK | 500 ms, только если rx_seq ещё не был отправлен в ACK |
+| Handshake/RTO | 300 ms |
+| Нет маршрута после handshake | Повторный поиск через 20 ms |
+| Транзит при backpressure | Waiter + повтор выбора маршрута через 20 ms |
+| Watchdog send_q | 500 ms, пока очередь непуста |
+| Нет прогресса/BUSY | Закрытие после 17 циклов, для сервиса CALL — после 67 |
 
-   Отправка возможна когда:   tx_seq - tx_acked < 256
-   Отправка заблокирована:    tx_seq - tx_acked >= 256
+Транзитные очереди принадлежат физическому ETCP, сгруппированы по group/src/dst и не имеют своих seq.
+При смене маршрута пакет переносится на актуальный next hop без ожидания освобождения старой очереди.
+Отсутствие пути приводит к потере транзитной копии; её восстанавливает end-to-end inflight источника.
 
-   При блокировке:
-     данные → send_q (FIFO, без дропов)
-     send_blocked = 1
-     send_resume_timer = 50ms retry
+## Владение и локальная доставка
 
-   Разблокировка:
-     приход ACK от remote → tx_acked обновляется
-       → router_drain_send_q() разгребает send_q
-     или send_resume_timer (50ms) → router_drain_send_q()
+| Объект | Владение |
+| --- | --- |
+| Входной entry etcp_route_send | Всегда поглощается, включая ошибку |
+| Буфер etcp_router_conn_send | Заимствован на время копирования |
+| ETCP_ROUTER_CONN из conn_get | Заимствован до close/destroy |
+| Сервисный entry | Передаётся callback; освободить dgram и entry |
+| Физический conn в callback | Заимствован, может обозначать транзитного пира |
+| Синтетический conn | Только на время callback, instance/peer=self; без сетевого send/ref_take |
+| Send-ready handle/arg | У производителя до callback/отмены; перед освобождением отменить |
 
-   send_q полностью разобран → send_blocked = 0
-```
+Self-доставка через etcp_route_send синхронна и не создаёт канал. Она обходит сетевые crypto policy
+и receive_ready, выдаёт rx_flags=0; режим проверяется на допустимые биты.
+Payload должен быть непустым и помещаться вместе с 26-байтным заголовком в uint16 длину.
+Нет обработчика, переполнение размера или отказ памяти возвращают -1.
+Отдельный синтетический conn каждого вызова сохраняет контекст при вложенных доставках разных ядер.
 
-## Полная схема потоков
+Закрываемый канал удаляется из реестра до callback. Callback может закрывать группу/другие каналы
+или открыть замену с тем же ключом; старая запись не возвращается повторным поиском.
+Память канала и send_q освобождается отложенно за пределами текущего callback.
+До массовой остановки сервисы отменяют producers/waiters; уничтожение ядра из callback останавливаемого сервиса запрещено.
 
-```
-                           ┌──────────┐
-                           │  Сервис  │ (routing, proxy, NAT, ...)
-                           │  (svc_id)│
-                           └────┬─────┘
-                                │
-              etcp_route_send() │              callback(svc_id, entry)
-                                ▼              ▲
- ┌─────────┐   send   ┌─────────────────────────────────┐   recv   ┌─────────┐
- │  TUN    │─────────▶│         ETCP ROUTER              │─────────▶│  TUN    │
- │ (выход) │          │                                  │          │ (вход)  │
- └─────────┘          │  ┌──────────┐  ┌──────────┐    │          └─────────┘
-                      │  │ send_q   │  │ recv_q   │    │
-                      │  │ (FIFO)   │  │ (хеш seq)│    │
-                      │  └────┬─────┘  └────┬─────┘    │
-                      │       │             │          │
-                      │       ▼             ▼          │
-                      │  ┌─────────────────────────┐   │
-                      │  │   Inflight / Assembly   │   │
-                      │  │   tx_seq - tx_acked     │   │
-                      │  │   rx_seq → deliver      │   │
-                      │  └───────────┬─────────────┘   │
-                      │              │                  │
-                      └──────────────┼──────────────────┘
-                                     │
-                              ┌──────▼──────┐
-                              │   BGP       │
-                              │  (нахождение│
-                              │   next hop) │
-                              └──────┬──────┘
-                                     │
-                              ┌──────▼──────┐
-                              │ ETCP conn   │──▶ сеть
-                              └─────────────┘
+close_group удаляет логические каналы и pending transit указанной группы.
+destroy снимает wire callback, закрывает все логические каналы и очищает транзитные очереди,
+таймеры и waiters на всех живых ETCP. Уничтожать сам ETCP для очистки роутера не требуется.
 
-   ──▶ send (исходящие данные)
-   ──▶ recv (входящие данные, callback сервису)
-   ──▶ транзит (через BGP к следующему hop)
-```
-
-## Таймеры (один rconn)
-
-```
-   ┌─────────────────────────────────────────────────────┐
-   │                                                     │
-   │  ack_timer ──────── 100ms ─────▶ router_ack_timer_cb│
-   │    (периодический)                                    │
-   │                                                     │
-   │  idle_ack_timer ─── 500ms ─────▶ router_idle_ack_cb │
-   │    (досылка последнего ACK)                           │
-   │                                                     │
-   │  send_resume_timer ─ 50ms ─────▶ router_send_resume │
-   │    (retry когда send_q не пуст)                      │
-   │                                                     │
-   └─────────────────────────────────────────────────────┘
-```
-
-## Флаги seq
-
-```
-   ┌──────────────────────────────────────────────────┐
-   │  CLOSE:  0x80000000  нормальное закрытие conn     │
-   │  RST:    0x40000000  conn не найден (reset)       │
-   │                                                   │
-   │  CLOSE/RST-пакеты: seq=0 | флаг, pl_len=0         │
-   │  Data-пакеты:      seq=tx_seq,     pl_len>0       │
-   │  ACK-пакеты:       seq=rx_seq,     pl_len=0       │
-   └──────────────────────────────────────────────────┘
-```
+Метрики delivery считают первые подтверждения исходного payload, без заголовков/crypto/ретрансмитов.
+RTT — 0.1 ms, snapshot API выдаёт микросекунды; jitter — unsigned 16.16 EWMA,
+монитор публикует удвоенный EWMA. Очереди, метрики и параметры minRTT сбрасываются вместе с логической сессией.

doc/group_avatar.txt

@@ -0,0 +1,81 @@
+Аватарка CHAT-группы
+===================
+
+Модуль src/chat/group_avatar.c. Картинка — бинарный BLOB до 16384 байт в общей
+SQLite каждого участника: channels.avatar_data/version/hash/signature.
+Storage-сервер, каталоги файлов и пользовательские квоты не используются.
+При старте добавляются отсутствующие колонки одной транзакцией, записи/ключи
+каналов сохраняются. channel_put использует UPSERT и сохраняет аватарку,
+UI-состояние и локальные приватные ключи; смена публичных ключей существующего
+channel_id запрещена. Удаление группы удаляет и её аватарку.
+
+Право публикации — приватный Ed25519 ключ группы плюс собственное действующее
+членство. creator UID/admin-флаг не заменяют ключ. group_avatar_set подписывает:
+ASCII "group-avatar-v1" без NUL, group:u64 LE, version:u64 LE, size:u16 LE, bytes.
+Версия — max(NTP microseconds/1000, previous+1), ограничена INT64_MAX.
+SHA256 считается по картинке; при одинаковой версии побеждает больший SHA256.
+Обе конкурирующие записи должны иметь правильную подпись группы; конфликт — WARN.
+Публикация одинаковой картинки не создаёт новую версию. Удаление — подписанная
+запись с size=0 и новой версией; подпись/версия сохраняются, старый пир не может
+восстановить удалённую картинку. Чтение проверяет сохранённый хеш и подпись.
+
+Транспорт
+---------
+
+ETCP_RT_ID_GROUP_AVATAR=0x3A, router wire version=1. Отправитель/группа берутся
+из проверенного router-заголовка. Все пакеты подписаны ключом узла и зашифрованы
+end-to-end; в DATA дополнительно передаётся подпись группы над всей картинкой.
+Обмен только между READY-соседями CHAT-группы с действующим подписанным членством.
+Любой участник пересылает сохранённую запись, владелец ключа может быть offline.
+
+Все числа протокола LE. Общая часть, 44 байта:
+  version:u8=1, command:u8, avatar_version:u64, total_size:u16, SHA256:32.
+STATE=1 объявляет локальную версию/хеш; начальное отсутствие — version=0, hash=0.
+GET=2 запрашивает актуальную запись. Объявление не меняет БД без полной DATA.
+DATA=3 добавляет group_signature:64, offset:u16, block_size:u16, bytes.
+DATA header=112 байт. Картинка разбивается на блоки по 4096 байт; последний
+короче. Полная картинка 16 КиБ — ровно четыре DATA. Удаление — один DATA без bytes.
+
+Порядок блоков гарантирует router. Сборка проверяет offset, постоянные version,
+total_size/hash/signature и допустимые размеры. До полной сборки прежняя картинка
+остаётся в БД. После SHA256/Ed25519 вся запись заменяется одним UPDATE, затем
+CHANNEL_UPDATED доставляет изменение GUI и STATE распространяется соседям.
+Промежуточные блоки не публикуются, ACK/retransmit каждого блока — только router.
+
+Отправка заполняет router до нижнего порога send_q count<=0 и ждёт send_ready;
+планировщик отправляет максимум четыре пакета за callback. Snapshot отправителя
+не меняется при новом локальном обновлении. Максимум 16 tx и отдельно 16 rx
+сборок на экземпляр, каждая до 16 КиБ. receive_ready при заполнении rx сохраняет
+пакет в router recv_q без продвижения ACK; освобождение слота возобновляет приём.
+Несовпадение эпох/закрытие router отменяет незавершённую сборку и начинает сверку.
+Эпоха нового контекста берётся из текущей READY-сессии, не сбрасывает первый приём.
+Обнаружение соседей/таймауты — таймер 1 с; STATE также раз в 30 с. Нет прогресса
+15 с — отмена незавершённого snapshot, повтор запроса/сверки. Остановка сервиса
+отменяет таймеры/waiters/call_soon до удаления группы/ядра.
+
+ChatGUI
+-------
+
+Настройки группы: Upload group avatar/Remove group avatar, предпросмотр и статус.
+Кнопки доступны только при локальном приватном ключе. Применение сразу, отдельно
+от Save локальных настроек. Worker обрезает центральный квадрат, создаёт JPEG
+128×128, снижает качество/размер до лимита 16 КиБ. Вход ограничен 16 мегапикселями.
+GUI отправляет байты в uasync; ядро повторно проверяет размер/членство/ключ.
+
+SQLite — постоянный кеш. GroupAvatarManager хранит QImage до 32 МиБ, ключ кеша:
+group/version/hash. Декодирование в отдельном worker, проверка SHA256, JPEG и
+квадратных размеров до 128×128. Поздний результат старой версии не заменяет
+новую. Готовая картинка обновляет только строку группы; без аватарки — инициалы.
+Приватные ключи/байты картинки не выводятся в диагностику.
+
+Проверки
+--------
+
+test_group_avatar: настоящие два ядра/UDP/router, 16 КиБ четырьмя блоками,
+атомарность сборки, hash/signature/cross-group отказ, приостановка receive,
+перезапуск канала, stale/conflict, редактор с ключом вне creator UID, подписанное
+удаление, повторное описание группы и restart БД. Schema failure откатывает
+частичные ALTER, сохраняет прежние данные/ключи, повторное добавление идемпотентно.
+test_group_avatars (Qt): нормализация, лимит/отображение, кеш, права кнопок и отказ
+ядра без ключа, удаление. chat=debug показывает состояния и каждый 4КиБ блок;
+chat=info — публикации и жизненный цикл. Ошибки содержат group/peer/version/offset.

doc/linux_audio_recovery.md

@@ -0,0 +1,528 @@
+# Linux: диагностика и восстановление аудио
+
+Проверка 2026-10-02: desktop chatgui, miniaudio/PulseAudio, общий голосовой стек,
+звонки, рация и запись сообщений. Исправления обработки PCM, владения устройствами
+и автоматическое восстановление реализованы. Ниже сохранены исходные результаты
+аудита; раздел «Реализация» описывает действующие контракты и проверки.
+
+## Вывод
+
+До исправлений тракт был некорректен при сбоях. Самое существенное: воспроизведение
+звонка зависит от наличия микрофонных кадров в duplex-ring. Его опустошение
+останавливает вызов пользовательского callback, оставляя хвост выходного буфера
+незаполненным. Восстановление jitter-буфера не исправляет остановившееся устройство.
+Отдельного управляющего механизма восстановления устройств не было.
+
+В реализации восстановлены три гарантии: каждый запрос output полностью заполнен; обработка
+одного callback всегда ограничена; остановка/пересоздание устройства выполняются
+вне аудиопотока и не уничтожают сетевую сессию звонка.
+
+## Что установлено по работающим клиентам
+
+В локальном старом логе звонка `132e4a9698f47bdf` с Samsung SM_A525F наблюдались
+паузы callback примерно 0,5–2,6 секунды при зарегистрированной обработке 0–2 мс.
+Входящий буфер desktop достигал 15 секунд, росли потери, включалось ускорение 160%.
+На Samsung захват продолжал давать около 50 кадров/с, playback регистрировал
+underrun и тоны разрыва. RTT порядка 1–4 мс не объясняет эти паузы сам по себе.
+
+Это признаки проблемы обслуживания локального аудио, но ещё не доказательство
+конкретной причины зависания PulseAudio. Старое измерение исключало время
+синхронных DEBUG-вызовов между концом обработки и обновлением timestamp.
+Новая диагностика охватывает весь callback, включая эти логи.
+Работающий GUI не перезапускался, поэтому новый инструмент ещё не записал этот
+сбой на реальном звонке. Лог Samsung сохранён в `/tmp/sm-audio-current.log`.
+
+## Найденные дефекты и ограничения до исправлений
+
+| Место | Поведение и последствия | Необходимая доработка |
+| --- | --- | --- |
+| `lib/miniaudio.h`, `ma_device__handle_duplex_callback_playback()` | При пустом capture-ring `acquire_read` возвращает success с нулём кадров. Выполняется `break`, output остаётся частично незаполненным, call callback не вызывается. PulseAudio затем отправляет весь mapped buffer. | Обеспечить полный output и продолжение playback при отсутствии capture. Нельзя делать commit_read для синтетических кадров. |
+| `ma_device_on_write__pulse()` | Успешная запись с нулём обработанных кадров не уменьшает остаток цикла. Возможно бесконечное вращение с блокированием того же PA mainloop, включая capture. | Немедленно выходить при отсутствии продвижения, возвращать управление mainloop. Логировать состояние и запрос, не пытаться записывать до успеха в этом callback. |
+| `ma_device_on_read__pulse()` | PA hole отбрасывается без подачи соответствующего количества нулевых кадров. Из capture timeline исчезает интервал, duplex-ring может опустеть. | Сохранять длительность hole тишиной либо явно обозначать discontinuity независимому capture-тракту. |
+| `lib/speex_aec.c`, `speex_aec_feed_playback()` | Обрабатывает только остаток одного 960-sample кадра, отбрасывая хвост входного блока. Контракт разрешает произвольный count. | Циклом потреблять весь count, складывать все полные кадры, сохранять остаток. |
+| `CallAudioEngine::setPlaybackDeviceIndex()` | После неудачного пересоздания `m_active` остаётся true при отсутствии устройства; `start` того же звонка возвращает успех. | Разделить желание продолжать звонок и работоспособность устройства. Ошибка запуска переводит устройство в recovering. |
+| `RadioAudioEngine::teardownDevice()` | Если playback init успешен, а start нет, uninit пропускается: он зависит от флага started. Объект удаляется вместе с незавершёнными ресурсами. | Разделить initialized и started; каждый успешный init обязательно завершать uninit. |
+| `MainWindow::~MainWindow()` / `SoundManager::shutdown()` | Общий context освобождается вместе с engine, но звонок и рация здесь явно не останавливаются. Их singleton-объекты могут оставлять живые устройства. `m_context` также не обнуляется. | Сначала остановить все зависимые устройства и дождаться callbacks, затем освобождать общий context. |
+| `AudioRecorder` | Callback выбирает глобальный `g_recorder`, игнорируя `pUserData`. Второй recorder, в том числе тест микрофона, заменяет получателя. Флаги/уровень/вектор waveform используются из GUI и аудиопотока без согласованной синхронизации. | Использовать `pUserData`; передавать уровни атомарно, waveform — безопасным snapshot; буфер записи должен иметь однозначного владельца. |
+
+До исправлений первые два дефекта воспроизводились стендом без аппаратуры:
+duplex оставлял sentinel в output при starvation, а PA-write без продвижения
+требовал внешней остановки. AEC из 1200 + 720 samples сохранял один кадр вместо
+двух. Теперь эти проверки требуют полного output, самостоятельного возврата
+из callback и двух сохранённых AEC-кадров; результаты приведены ниже.
+
+Capture-AEC также обрабатывает не более одного кадра за вызов. В звонке его
+вызывают ровно с 960 samples, поэтому текущий call feed этот случай не нарушает.
+При расширении API нельзя объявлять произвольный count без согласованного размера
+выходного буфера. `speex_aec_reset()` уже существует: новый API для сброса самого
+AEC не нужен, но нужен согласованный сброс всего локального voice-тракта.
+
+## Чистота реализации
+
+Этот раздел фиксирует исходный аудит; изменения владения и ограничение работы
+callback описаны в разделе «Реализация».
+
+Нормальная структура уже есть: GUI владеет устройствами, сервисный слой кодирует
+Opus и обрабатывает jitter, сетевой поток доставляет пакеты. Нет необходимости
+переписывать весь стек или заводить новый backend.
+
+Однако границы владения не завершены: context фактически принадлежит engine
+звуковых уведомлений, а используется независимыми устройствами звонка/рации.
+Флаги active/started/initialized местами смешивают три разных состояния.
+Выбор input применяется к recorder, звонок использует default input, рация —
+default устройства. Output звонка и SoundManager тоже выбираются отдельно.
+Индекс перечисления не является устойчивой идентичностью устройства после hotplug.
+В radio capture fallback `useDefault` фактически повторяет ту же попытку:
+`pDeviceID` и так NULL в обеих ветках. Callbacks рации запускаются раньше
+подготовки capture-буфера и установки VAD; порядок запуска нужно привести к
+«сначала состояние и буферы, затем устройства», чтобы исключить гонки при старте.
+
+Callback не является строго realtime-safe. Capture удерживает `g_mtx` во время
+AEC/AGC/Opus; отправка выделяет память и вызывает `uasync_post`. Playback вызывает
+SoundTouch и код с возможным расширением контейнеров, mutex и синхронными логами.
+Приём пакетов тоже может держать mutex при работе с jitter и логировании.
+Плохие Opus-кадры могут последовательно выбираться из большой очереди в одном
+pull: нужен предел работы на callback. Новая диагностика покажет, где это
+действительно нарушает deadline. Перенос всего DSP в ещё один worker заранее
+увеличит число очередей и точек синхронизации без установленной необходимости.
+
+AEC получает reference только звонка. Звуки отдельного SoundManager в него не
+попадают; delay по умолчанию фиксирован, не вычисляется по фактической задержке
+устройств. Это ограничение качества эхоподавления, а не установленная причина
+текущего зависания.
+
+Jitter умеет повторно накопить резерв после сетевого underrun, но диапазон tempo
+ограничен 1,0–1,6. Ускорение убирает избыток, а замедления для компенсации более
+медленных часов отправителя нет. При устойчивом отрицательном дрейфе резерв будет
+снова опустошаться. Это отдельная задача длительных звонков: после восстановления
+устройств проверить наклон глубины буфера и при необходимости добавить небольшую
+компенсацию дрейфа в обе стороны, не смешивая её с быстрым catch-up после паузы.
+
+Принудительные 480 frames задают период 10 мс при 48 кГц. Собственный PA default
+miniaudio — 25 мс с комментарием о проблемах PipeWire при периодах меньше ~20 мс.
+Период backend и Opus-кадр 20 мс должны оставаться независимыми. Увеличивать
+период до исправления AEC нельзя: 1200-sample блоки уже воспроизводят потерю хвоста.
+После исправления разумно сначала проверить default backend и измерить задержку.
+
+## Предлагаемое восстановление без большого усложнения
+
+### 1. Сначала восстановить инварианты обработки и владения
+
+Исправить полный output, zero-progress, AEC accumulation и uninit при неудачном
+start. Перед освобождением context явно остановить recorder, звонок, рацию и
+прочие его устройства. До остановки отменять recovery timer; после join можно
+сбрасывать voice-ресурсы. Проверять возвраты feed/start/init и логировать причину.
+
+Самый небольшой вариант — оставить один duplex-device: при нехватке capture
+подать в call callback нулевой input, полностью сформировать playback и не
+продвигать реальный capture-ring за синтетические samples. Это чинит непосредственный
+дефект, но сохраняет общий жизненный цикл input/output и синтетический TX по
+playback-clock.
+
+Для устойчивости к исчезновению микрофона предпочтительнее два устройства
+capture/playback внутри существующего `CallAudioEngine`, как уже сделано в рации.
+Capture только накапливает 960 samples и вызывает feed; playback независимо
+вызывает pull и всегда заполняет output. Это два handle с одним владельцем,
+без нового DSP-worker или дополнительной PCM-очереди. Потребуется уточнить
+потоковый контракт voice-слоя: один capture-writer и один playback-writer,
+согласованный доступ к AEC, остановка обоих до release. Текущий `g_mtx` уже
+защищает AEC, но остальные общие поля нужно проверить перед разделением.
+
+### 2. Разделить краткий underrun и неисправность устройства
+
+| Событие | Действие |
+| --- | --- |
+| Нет сетевого PCM, callback продолжает приходить | Тишина/существующий gap tone; jitter автоматически накапливает данные. Устройство не пересоздавать. |
+| Один backend underrun, новые кадры принимаются | Подать следующий полностью заполненный буфер; собрать счётчик. Не сбрасывать AEC и не запускать restart на каждый xrun. |
+| Hole/переполнение capture | Учесть потерянную длительность; краткую потерю пережить, длительную отметить discontinuity для AEC. |
+| Поток failed/stopped или нет продвижения кадров длительное время | Перейти в recovering и пересоздать затронутое устройство вне callback. |
+| Suspend/resume ОС | Учитывать suspend как отдельную причину, восстановление проверять после resume; не запускать частый restart-loop во время сна. |
+| Потерян общий backend/context | Однократно остановить всех его пользователей, восстановить владельца, затем требуемые устройства. |
+
+Один owner timer и состояния `Stopped / Running / Recovering` достаточны.
+`wanted` хранит желание пользователя продолжать; generation меняется при stop,
+новом звонке и смене устройства. Каждая отложенная попытка проверяет generation
+и wanted — законченный звонок никогда не возрождается.
+
+Callbacks только обновляют атомарные счётчики успешно обработанных кадров и
+признак backend failure. Watchdog проверяет фактический прогресс отдельно по
+направлениям. Тишина в PCM не означает остановку устройства. Reporter диагностической
+очереди не должен становиться watchdog: его события могут теряться.
+
+Начальные значения для проверки: timer 200 мс, подозрение при отсутствии прогресса
+500 мс после startup grace; повторные попытки через 250/500/1000 мс с потолком
+2 секунды. Это предлагаемые настройки, не доказанные универсальные пределы.
+Suspend и фактический согласованный backend period должны учитываться отдельно.
+Нельзя обещать bounded recovery, пока init/stop/uninit сами могут зависнуть:
+сначала устранить spin-loop и проверить время backend-операций. Если они реально
+блокируют GUI, вынести только управление устройствами в один owner-thread,
+сохранив тот же автомат состояний.
+
+На пересоздании сбросить capture-accumulator, AEC delay/filter и локальный PCM/
+stretch, сохранив call ID и сетевую сессию. После длительной аппаратной паузы
+устаревшую речь нужно явно отбросить до актуального резерва jitter, иначе
+15 секунд накопленного звука при скорости 160% разгружаются примерно 25 секунд.
+Этот сброс применять только при аппаратной discontinuity; обычный сетевой jitter
+не должен автоматически приводить к отбрасыванию очереди.
+
+Устройство хранить по backend ID либо как default, не по индексу. При его
+исчезновении попробовать default и явно сообщить о смене; выбранное устройство
+можно вернуть при появлении. Нужны ошибки с ID/именем/направлением и результатом
+попытки. Для PA-ошибок следующий уровень диагностики — stream/context state и
+`pa_context_errno`, потому что один `-1` от API не объясняет причину.
+
+### 3. Проверить сценарии, а не только успешный старт
+
+После реализации добавить проверки: capture starvation 20/500 мс и возврат;
+hole; AEC блоки, пересекающие границу кадра; zero writable; ошибка записи;
+исчезновение выбранного устройства и появление default; suspend/resume;
+перезапуск звукового сервера; stop во время backoff; закрытие GUI при активном
+звонке/рации. Проверять полный output, bounded очереди и работу callback,
+возобновление прогресса, отсутствие callbacks после release и отсутствие
+повторного старта после пользовательского stop.
+
+## Как читать добавленную диагностику
+
+В GUI-категориях включить `call=debug` либо задать отдельную строку в INI:
+
+```ini
+[debug]
+call=debug
+```
+
+Обычные сводки идут на DEBUG, аномалии — WARN/ERROR; miniaudio info перенесён
+на DEBUG, подробный backend log — TRACE. Все устройства используют категорию
+call, включая recorder, radio и sound-engine; role и ID различают их в строках.
+Не включать глобальный trace для всего проекта при измерении аудио.
+
+Reporter раз в секунду печатает stage, tid, callbacks/s, requested frames/s,
+максимальный интервал между входами, полное wall-time обработки и thread CPU-time,
+незавершённый вход и время с последнего входа. `work_max` и `cpu_max` — отдельные
+максимумы за окно, они не обязательно относятся к одному вызову.
+
+| Stage | Что измеряется |
+| --- | --- |
+| loop | Один `pa_mainloop_iterate`, включая ожидание и вложенные callbacks. Долгое время само по себе не доказывает тяжёлый DSP. |
+| read / write | Полный backend read/write callback. Frames/s здесь — запрошенные, не гарантированно обработанные кадры. |
+| map | `writable_size` и `begin_write`; пустой/ошибочный выход тоже закрывает измерение. |
+| submit | Вызов `pa_stream_write`. |
+| duplex | Перенос capture-ring в duplex-output; detail содержит глубину capture-ring. |
+| callback | Полный miniaudio data callback, включая код приложения и его синхронные логи. |
+| feed / pull | Capture DSP/encode/send и playback jitter/stretch/tone в звонке. |
+
+`unfilled_frames` — незаполненный output, `hole_frames` — потеря capture timeline,
+`capture_drop_frames` — переполнение capture-ring, `no_progress` — PA-write без
+продвижения. `backend_underruns` — отдельный callback самого PA-stream; это не
+то же самое, что пустой сетевой jitter. `backend playback started/resumed`
+показывает фактическое начало/возобновление playback. Notification содержит
+числовые miniaudio type/state.
+
+Первое событие каждого типа за окно имеет tid и CLOCK_MONOTONIC timestamp;
+повторения суммируются. Для задержавшихся потоков reporter читает `/proc` wchan
+и накопленные schedstat CPU/ready-wait/slices. Сравнивать соседние snapshots:
+сами totals не являются длительностью текущей паузы. CPU-time намного меньше
+wall-time означает ожидание/вытеснение; wchan помогает отличить poll от mutex/
+I/O wait. Это снимок в момент отчёта, не исторический стек зависшего вызова.
+
+Producer не выделяет память, не ждёт mutex reporter и не пишет диагностические
+логи: ограниченная MPSC-очередь 8192 события, не более четырёх CAS-попыток.
+Reporter не разыменовывает ma_device/pa_stream. Переполнение логируется как
+`diagnostic events lost`; такое окно нельзя считать полным. Инструментация
+добавляет получение часов/TID и атомарные операции, поэтому overhead ненулевой.
+Частые события call jitter/AEC/TX теперь публикуются счётчиками и выводятся из
+uasync вне аудиомьютекса. Часть существующих логов рации остаётся синхронной;
+тракт не объявляется строго realtime-safe.
+После close устройство удаляется из reporter: для устройств короче секунды
+доступны lifecycle и первые аномалии, но не полная секундная сводка.
+
+Новый binary собран в `tools/chatgui/build/vibechat`; для нового измерения нужен
+его обычный перезапуск. Изменение файла binary не обновляет уже запущенный процесс.
+
+## Реализация (2026-10-02)
+
+`SoundManager` владеет общим контекстом и конечными выходами. На каждый фактический
+выход приходится один микшер: PCM сообщений/видео, заранее декодированные сигналы,
+готовый голос звонка и рации. После суммирования float PCM ограничивается, и один
+и тот же stereo буфер отправляется устройству и AEC соответствующего микрофона.
+Звук другого выхода в референс не входит. Default/явный backend ID объединяются;
+PulseAudio также публикует идентификатор фактического маршрута. После server move
+совпавшие выходы объединяются в GUI только после подтверждения фактического
+маршрута; предположение о default не используется вместо PA snapshot. При временной коллизии дополнительный выход
+отдаёт тишину до объединения. Изменение списка источников выполняется после stop
+callback, с сохранением backend stream и выбранного сервером маршрута.
+
+Устройства сохраняются как backend ID вместо индекса. При init/start failure
+явного выбора пробуется default, причина логируется. Выбранный ID сохраняется;
+вернуться к нему можно повторным выбором или при следующем recovery. Автоматический
+опрос hotplug для возврата на первоначальный выбор не добавлен.
+
+`AudioDevice` — владелец одного miniaudio device в GUI. Успешный init всегда имеет
+парный uninit, включая ошибку start. Callback и его состояние готовятся до start.
+Close останавливает/join-ит device worker перед освобождением callback. Отдельный
+атомарный счётчик кадров контролирует прогресс. Таймер 200 мс проверяет stopped
+и отсутствие продвижения 1 с; suspend продлевает grace, отдельный xrun не вызывает
+restart. Backoff: 250/500/1000/2000 мс, сброс после продвижения.
+
+Miniaudio не добавляет накопитель фиксированного периода: `noFixedSizedCallback`
+включён, hardware chunks могут иметь любую длину. В PulseAudio физическое начало
+блока определяется по timing snapshot с AUTO_TIMING_UPDATE/INTERPOLATE_TIMING.
+Capture: monotonic now минус latency read index, без повторного вычитания длины
+блока. Playback: now плюс latency write index. Учитываются задержка converter и
+остающийся input cache. Один backend dispatch имеет один snapshot, позиции
+последующих client callbacks продвигаются по числу кадров. В отсутствие snapshot
+используется оценка по callback; источник времени и physical route логируются.
+PA hole отдельно помечен как отсутствующий capture, а не как реальная тишина.
+
+`VoiceAudioIo` создаётся только для звонка и рации. Capture и RX обрабатывают
+независимые потоки. Hardware capture только копирует PCM в фиксированную MPSC-очередь;
+RX worker выполняет decode/SoundTouch/тоны и поддерживает до 40 мс готового голоса.
+В сервисном слое рации вычисление Silero держит только TX mutex: общий mutex
+отпущен, поэтому VAD не блокирует RX; lifetime и порядок PCM/PTT сохранены.
+Hardware output смешивает готовый PCM. Opus, AEC, VAD, AGC и растущие буферы записи
+не исполняются в аппаратных callbacks. Обработка самого backend, PCM/resampler
+узлов miniaudio и атомарные уведомления остаются в callback; строгая hard realtime
+гарантия не заявляется.
+
+Capture worker — единственный владелец AEC и порядка PCM/PTT/mute. Кадр AEC —
+960 отсчётов на канал; 1/2 канала микрофона и 2 независимых канала референса.
+Противофазное стерео не усредняется. История рендера содержит до 1,92 с PCM и
+физические timestamps. Reference выбирается по времени микрофона; небольшое
+различие часов компенсируется интерполяцией только референса. Реальная тишина
+сохраняется как валидный PCM; при отсутствующем reference AEC пропускает микрофон
+и не адаптируется. Потеря reference, смена маршрута/поколения и скачок часов
+сбрасывают фильтр. Возраст capture-очереди ограничен 100 мс от enqueue, отдельно
+от собственной задержки backend. Потери и очередь видны в сводках категории `aec`.
+
+Mute применяется после AEC/AGC: фильтр продолжает получать настоящий микрофон,
+а Opus получает нули только в отмеченной части кадра. Desktop запускает core
+через `call_audio_start_prepared`: повторного core AEC нет. Raw API с core AEC
+сохранён для Android/headless; смешивать политики в активном звонке нельзя.
+
+У рации один автомат передачи: manual PTT или VAD. VAD читает непрерывный очищенный
+сигнал до AGC, включая время ручного PTT. Передача использует отдельный накопитель
+Opus-кадра; границы PTT внутри AEC-кадра сохраняются. При закрытии серии хвост
+дополняется нулями только перед Opus и помещается в очередь перед FIN. Короткий
+capture tail при stop проходит без AEC, а не дополняет непрерывный фильтр. Разрыв
+захвата завершает старый сетевой хвост и сбрасывает VAD, исключая склейку через
+потерянные отсчёты. Capture restart завершает принятую серию; новое прослушивание
+того же канала отменяет старые BEGIN/media. FIN проверяет токен своего capture/burst
+и поколение экземпляра ядра, поэтому не закрывает более новую серию и не обращается
+к освобождённому ядру даже при повторном использовании его адреса.
+
+TX ограничен 8 media-задачами, возраст — 200 мс. У рации дополнительно ограничено
+16 control-задач; FIN выделяется заранее вместе с BEGIN. Если control-очередь
+занята, новый BEGIN откладывается до освобождения; это логируется. Очередь PCM
+резервирует 8 слотов для управляющих сообщений; producer не меняет consumer и
+публикует слот только после копирования. Capture callback никогда не ждёт слот.
+Отказ постановки GUI-команды завершает capture; таймер запускает recovery.
+
+`AudioRecorder` получает raw microphone без AEC. Его worker обрабатывает AGC,
+накапливает запись и публикует атомарный уровень/длительность. Переполнение или
+ошибка обработки отклоняют запись с логом. Meter-only использует тот же capture,
+но не сохраняет PCM и не создаёт голосовое сообщение. Stop: close device, drain
+и join worker, затем передача владельца записи задаче attachment. Настройки
+компрессора в ходе записи применяются к следующей.
+
+PCM воспроизводится через независимые handles. Сообщение, видео и тест динамика
+не останавливают чужой PCM; sample rate принадлежит источнику. Seek пересоздаёт
+узел и очищает его read/resampler cache, сохраняя handle и владельца PCM. Cursor
+вычисляется по реально обработанным графом кадрам, а не по prefetched datasource.
+Pause отсоединяет узел и ждёт начатое чтение графа; resume подключает тот же узел,
+сохраняя его PCM и cache. Соседние проигрыватели продолжают работать.
+У асинхронного открытия видео/голоса проверяется generation.
+
+Потоковый AGC использует фиксированные кольца истории и PCM, нулевой lookahead
+и непосредственный process_frame без растущего output. У записи lookahead явно
+100 мс; растёт только сохраняемый результат. Push/flush/configure возвращают
+ошибки; flush проверяется перед кодированием вложения.
+
+Порядок остановки голосового направления: close capture → join capture worker →
+detach output → join RX worker → release core. При failed context синхронный сигнал
+сначала закрывает всех клиентов, затем освобождает context. Mixer, PCM handles,
+call ID и группа переживают recovery. Stop выключает recovery; таймер завершения
+звонка проверяет generation. MainWindow останавливает клиентов до SoundManager
+и сетевого ядра. Сетевые операции и регистрация audio ops выполняются в uasync.
+
+PulseAudio control-waits ограничены 1 с на операцию; при timeout operation
+отменяется до возврата, исключая callback с просроченным stack pointer. Partial
+init освобождает контекст/mainloop/события. Failed stream/context содержит PA
+errno в логе. Zero writable/zero converter progress возвращают управление.
+Последовательность нескольких операций init/uninit всё ещё может задержать GUI
+дольше секунды; отдельный device owner-thread не добавлен.
+
+## Проверки реализации
+
+`vibechat` и аудиотесты собираются через CMake. Набор проверки:
+
+```sh
+ctest --test-dir tools/chatgui/build --output-on-failure \
+  -R 'test_(linux_audio|audio_timing|audio_diagnostics|audio_recovery|audio_event_queue|voice_audio_io|voice_tx|call_jitter|radio_audio|radio_jitter|voice_file)$'
+make -C tests test_audio_compressor test_speex_aec
+./tests/test_audio_compressor
+./tests/test_speex_aec
+```
+
+Добавлены отдельные проверки MPSC (80000 сообщений, reserve/control, слот ещё не
+опубликован), точных PCM/PTT/mute границ, короткого хвоста, независимого RX при
+задержке capture worker, противофазного stereo AEC, старого физического timestamp
+при свежем enqueue, совпадения реальных Opus-пакетов с правильно дополненным
+хвостом, rapid PTT, capture restart, отмены старого прослушивания и bounded control.
+Проверяются manual/VAD handover
+без второй серии и продвижение настоящего сервисного RX при заблокированном VAD.
+Timing test проверяет read-index timestamp, несколько converter callbacks одного
+блока и метку hole. Recorder тестирует raw PCM и отсутствие вложения в meter-only.
+
+Speex проверяет подавление эха и сохранение double-talk также для двух микрофонов
+с двумя независимыми каналами reference. В детерминированном синтетическом тесте
+остаточная энергия эха — около 0,009 исходной; корреляция near-end — около 0,95.
+Эти величины относятся только к тесту, а не к реальным акустическим условиям.
+
+В `/tmp/utun-audio-asan` проверяются пять тестов нового тракта с ASAN/UBSAN и
+LeakSanitizer; LeakSanitizer запускается вне песочницы. MPSC отдельно проверяется
+ThreadSanitizer. Изолированный интеграционный запуск:
+
+```sh
+dbus-run-session -- python3 tools/chatgui/tests/run_pulse_recovery.py
+```
+
+Итоговый прогон 2026-10-02: сборка `vibechat` успешна, CTest — 11/11,
+ASAN/UBSAN/LeakSanitizer — 5/5, компрессор — 479/479, Speex — PASS,
+MPSC под ThreadSanitizer — PASS. Timing-стенд прошёл ещё 100 последовательных
+повторов. Пауза PCM проверяется также серией pause/resume при работающем соседнем
+проигрывателе; она ждёт чтение узла, а не только меняет его флаг.
+
+Тест создаёт собственные PipeWire/PulseAudio/WirePlumber в `/tmp`, отключает
+аппаратные monitors и использует два виртуальных sink. Проверяет объединение
+voice с общим выходом после `move-sink-input`, сохранение desired выхода звонка
+при recovery общего выхода (включая server stream-restore), затем восстановление capture/PCM
+после остановки и запуска своего PulseAudio. Звонок и рация сохраняют идентичность;
+recorder и медиа продолжают работу. Системный аудиосервер не затрагивается.
+
+Исторические проверки исходного recovery: полный `check.sh` — 119 passed,
+0 failed, 1 skipped; proxy/burst/load интеграции прошли. По указанию пользователя
+async-тесты исключены из дальнейших запусков. APK ранее собран offline; установка
+на телефон не выполнялась.
+
+Физический USB/Bluetooth hotplug, сон ОС, внешние звуки других приложений и качество
+AEC в длительном реальном звонке этими проверками не подтверждены. Reference
+охватывает звук этого приложения на том же выходе, согласно выбранному контракту.
+
+## Период Linux/PulseAudio и сравнительный замер
+
+`AudioDevice::requestLowLatency()` задаёт запрос 10 мс для capture звонка/рации.
+Он применяется при каждом открытии, включая recovery и fallback.
+Остальные backends сохраняют прежние параметры.
+Общий и отдельный voice output сохраняют прежний период: запрос 10 мс
+на проверенной системе не снизил измеренную задержку воспроизведения.
+Кадры AEC/кодека остаются 20 мс; `noFixedSizedCallback` позволяет обслуживать
+фактические порции backend без дополнительного накопления в miniaudio.
+
+Это запрос задержки, а не гарантия размера callback. PulseAudio согласует
+`tlength`, `fragsize`, `minreq`, `maxlength`, `prebuf`; PipeWire также ограничивает
+quantum и минимальные порции. `AudioDiag` при init выводит внутренний PCM-формат
+и согласованные параметры в миллисекундах (`-1` — значение по умолчанию).
+Пересчёт использует внутренние rate/channels/format, а не формат приложения.
+
+Секундные clock-отчёты содержат `latency_us`/`backend_us` и `block_us` в виде
+`min/avg/max`. В задержку включены только измеренные timing snapshots;
+`estimated_blocks`/`measured` позволяют отличить их отсутствие от нулевой задержки.
+Для времени исполнения callback включать `call=trace`, для состояния AEC —
+`aec=debug`. Логи агрегируются вне аппаратного callback.
+
+Ручной режим существующего стенда использует настоящие устройства и голосовые
+workers, не сохраняет микрофонный PCM и не отправляет его по сети. Выход звонка
+без удалённого собеседника обслуживается тишиной; акустическое подавление эха
+этот режим не измеряет. Аргументы: capture frames, playback frames, секунды,
+необязательный режим `call` (по умолчанию), `radio` или `output`, затем путь лога.
+Ноль frames оставляет стандартный период backend; override применяется только
+в тестовом executable, до настоящего `ma_device_init`.
+
+```sh
+cmake --build tools/chatgui/build --target test_audio_recovery -j4
+tools/chatgui/build/test_audio_recovery --latency 960 0 60 > /tmp/audio-baseline.log 2>&1
+tools/chatgui/build/test_audio_recovery --latency 480 0 60 > /tmp/audio-capture10.log 2>&1
+tools/chatgui/build/test_audio_recovery --latency 960 480 60 > /tmp/audio-playback10.log 2>&1
+tools/chatgui/build/test_audio_recovery --latency 480 480 60 > /tmp/audio-both10.log 2>&1
+```
+
+Запуски последовательные: несколько потоков могут менять общий quantum сервера.
+Сравнивать одинаковые маршруты и нагрузку, отдельно от старта/остановки и после
+стабилизации адаптивного PCM-резерва. Проверять backend latency, возраст первого
+сэмпла перед готовым TX-кадром, очередь после mix, starvation, holes, потери PCM,
+AEC reference и событий диагностики. Затем повторить baseline и проверить
+выбранный вариант под нагрузкой. Меньший возраст PCM в capture callback сам по
+себе не доказывает такой же выигрыш до кодирования: worker собирает кадры 20 мс.
+
+`test_voice_audio_io` дополнительно проверяет порции по 256 samples: порядок PCM,
+временные метки, границы mute/PTT и позицию частичного playback. AEC проверяется
+при разных порциях capture/reference (256/480 и 480/256) с противофазным stereo
+reference. Очереди по-прежнему ограничены числом событий; уменьшение периода
+не увеличивает их ёмкость в миллисекундах.
+
+Сравнение 2026-10-15 на встроенном HDA, PipeWire 1.6.2, 48 кГц. Каждый вариант
+работал 60 секунд; таблица содержит средние по callback/кадрам после 45 секунд
+прогрева (PCM-резерв к этому моменту уменьшился до одного блока).
+
+| Запрос capture / playback | Capture backend, мс | Первый сэмпл готового TX-кадра, мс | Playback backend, мс | PCM после mix, мс |
+| --- | ---: | ---: | ---: | ---: |
+| 20 мс / default 25 мс | 30,69 | 34,53 | 16,32 | 18,67 |
+| 10 мс / default 25 мс | 16,02 | 29,79 | 16,15 | 18,67 |
+| 20 мс / 10 мс | 31,51 | 34,97 | 18,09 | 24,00 |
+| 10 мс / 10 мс | 16,13 | 29,66 | 18,46 | 24,00 |
+
+Изменение capture даёт около 14,7 мс на границе backend и около 4,7 мс перед
+передачей полного кадра в голосовой стек. Для playback сервер согласовал
+`tlength=16ms`, `minreq=5.333ms` при запросе 10 мс; callback уменьшился с 512
+до 256 samples, но выигрыша по задержке не получилось. Поэтому в рабочем коде
+изменён только capture. Значения в столбцах не следует складывать как независимые
+участки общей задержки: capture backend входит в возраст TX-кадра, а очередь после
+mix снята уже после извлечения текущего выходного блока из очереди.
+
+В этих четырёх прогретых окнах не было потерь capture/reference PCM, выходного
+starvation, backend underrun/overflow или потери событий диагностики.
+Отдельные отсутствующие AEC references были и в baseline (4 кадра за окно),
+и в остальных вариантах (4–5). Это существующее ограничение привязки reference,
+а не проверка акустического качества. Первоначальный output starvation и
+временное увеличение PCM-резерва учитываются отдельно от стабильного окна.
+
+Повтор baseline дал 30,76 мс capture backend и 34,99 мс возраста TX-кадра.
+Двухминутный прогон выбранного capture 10 мс под нагрузкой четырёх CPU-процессов
+дал после прогрева 15,81 и 28,55 мс соответственно; PCM после mix — 18,67 мс.
+Потерь PCM, backend underrun/overflow и потери событий диагностики в этом окне
+не было. За 75 секунд окна зарегистрировано 25 отсутствующих AEC references.
+Отдельный минутный прогон рации: capture backend в среднем 15,48 мс, без потерь PCM.
+
+Сборка `vibechat` и 6 аудиотестов прошли. Изолированный интеграционный тест
+подтвердил объединение выходных маршрутов и восстановление capture/playback после
+перезапуска тестового PulseAudio. Запускать весь стенд через `dbus-run-session`,
+чтобы имя его PulseAudio не конфликтовало с сервером пользовательской сессии.
+В fixture перед `radio_audio_init` создаётся `radio_instance`, освобождаемый после
+`radio_audio_destroy`; это исключает ложную ошибку регистрации mute callback.
+Полный `check.sh` вне sandbox: 156/156, 9/9 proxy-интеграций, burst и load — PASS.
+В sandbox сетевые тесты не проходят из-за запрета сокетов; этот запуск не является
+проверкой сетевых регрессий.
+
+## Референсы
+
+Первичные исходники и документация просмотрены 2026-10-01; ссылки на master могут
+изменяться. Используем принципы, а не копируем целиком архитектуру библиотеки.
+
+- [PipeWire audio-src-ring.c](https://docs.pipewire.org/audio-src-ring_8c-example.html):
+  callback читает доступные кадры, заполняет остаток тишиной и возвращает полный
+  буфер; пополнение инициирует через событие управляющего потока. Хороший минимальный
+  пример поведения при пустой PCM-очереди.
+- [PulseAudio stream API](https://github.com/pulseaudio/pulseaudio/blob/master/src/pulse/stream.h):
+  отдельные underflow/overflow/started/suspended/moved callbacks; peek различает
+  пустую очередь и hole с ненулевой длиной. Нужно разделять эти состояния в логах.
+- [PulseAudio pacat.c](https://github.com/pulseaudio/pulseaudio/blob/master/src/utils/pacat.c):
+  underflow callback сообщает событие без пересоздания stream. При failed context
+  утилита завершает работу — это пример диагностики, не готовая self-healing система.
+- [Mozilla cubeb PulseAudio backend](https://github.com/mozilla/cubeb/blob/master/src/cubeb_pulse.c):
+  явные context/stream states, пересоздание ошибочного context при инициализации,
+  согласованное отключение callbacks и доступ под mainloop lock; minimum latency
+  25 мс. Это полезный референс владения и границ управления, а не основание
+  автоматически заимствовать всю библиотеку.
+- [miniaudio](https://github.com/mackron/miniaudio/blob/master/miniaudio.h):
+  init/start/stop/uninit запрещены внутри data callback из-за deadlock. Просмотренный
+  upstream тоже содержит break при пустом duplex-ring: обновление библиотеки само
+  по себе не решает этот найденный дефект.

doc/lwip_nuances.md

@@ -0,0 +1,66 @@
+# Важные нюансы работы встроенного lwIP TCP-стека
+
+Краткая памятка по тонким местам `src/lwip_tcp/`, критичным для прокси.
+Полное описание модуля — в `src/lwip_tcp/lwip_tcp_doc.md`.
+
+## Ключевые константы (`lwip_tcp_opts.h`)
+
+| Константа | Значение | Смысл |
+|-----------|----------|-------|
+| `TCP_MSS` | 1460 | максимальный размер сегмента |
+| `TCP_WND` | 8×MSS = 11680 | окно приёма lwIP (объявляется пиру) |
+| `TCP_SND_BUF` | 16×MSS = 23360 | буфер отправки |
+| `TCP_TMR_INTERVAL` | 250 мс | базовый интервал таймера |
+| `tmr_interval_ms` | `TCP_TMR_INTERVAL/4` = 62.5 мс | фактический шаг `tcp_fasttmr` |
+| `TCP_WND_UPDATE_THRESHOLD` | `TCP_WND/4` = 2920 | порог немедленного ACK окна |
+
+**Важно:** таймер uasync использует timebase 0.1 мс — `uasync_set_timeout(ua, N, …)`
+задаёт N×0.1 мс. Например, 5000 = 500 мс.
+
+## Контракт recv_cb — главный источник багов
+
+lwIP вызывает `recv_cb(arg, pcb, pbuf, err)` для данных, **уже извлечённых из pcb**.
+Дальше приложение само решает судьбу данных и окна:
+
+| Действие | Результат |
+|----------|-----------|
+| скопировать + `tcp_recved(pcb, len)` | данные приняты, окно восстановлено (норма) |
+| `return != LERR_OK` | lwIP кладёт pbuf в `refused_data` и отдаст позже — **без потери**, окно закрывается |
+| `pbuf_free(p)` без `tcp_recved` | данные потеряны, окно не восстановлено → схлопывание окна |
+
+`refused_data` — штатный backpressure lwIP: одноканальный (один pbuf), ре-доставка
+через `tcp_fasttmr` (62.5 мс) или при следующем входящем сегменте.
+
+**Ошибка, из-за которой падал `tcp_proxy_full`:** при backpressure прокси делал
+`pbuf_free(p)` без `tcp_recved`. Каждый такой сброс уменьшал `rcv_wnd` на MSS; после
+~8 пакетов окно падало в 0, OS-TCP переставал слать, и передача умирала.
+
+## Управление окном и «деградация 62.5 мс»
+
+`tcp_recved(pcb, len)` увеличивает `rcv_wnd` и через `tcp_update_rcv_ann_wnd` решает,
+слать ли ACK окна немедленно. Немедленный ACK идёт только если прирост окна
+`wnd_inflation ≥ TCP_WND_UPDATE_THRESHOLD` (=2920 = 2×MSS); иначе ACK откладывается
+до `tcp_fasttmr` (62.5 мс).
+
+Отсюда классическая ловушка: если после backpressure окно восстанавливать **по одному
+пакету** (`tcp_recved(1460)` за раз), прирост 1460 < 2920 → ACK уходит раз в 62.5 мс →
+пир шлёт 1 пакет за 62.5 мс ≈ 23 КБ/с. Это выглядит как «пропускная способность
+застряла», хотя сеть свободна.
+
+**Правильно:** восстанавливать окно **пачкой** (несколько `tcp_recved` подряд либо один
+`tcp_recved(TCP_WND_MAX - rcv_wnd)`), тогда прирост ≥ 2920 → ACK немедленный → пир
+сразу возобновляет бурст.
+
+## Рекомендуемый паттерн для relay-потребителя (как в `tcp_proxy_client.c`)
+
+1. При получении данных — копировать в ограниченную очередь, **не вызывать**
+   `tcp_recved` (окно само плавно закрывается; очередь ограничена `TCP_WND`).
+2. Дрейн очереди по сигналу освобождения нижележащего канала
+   (`etcp_router_on_send_ready`) + retry-таймер (force=1) как safety-net.
+3. `tcp_recved(len)` вызывать **только после успешной отправки** — окно
+   восстанавливается пачкой по мере дрена, ACK уходит немедленно.
+4. Никогда не сбрасывать pbuf без `tcp_recved`; не держать данные в `refused_data`
+   дольше одного пакета (single-slot).
+
+См. реализацию: `tcp_proxy_client_tx_queue_drain_cb` / `tcp_proxy_client_fin_flush`
+в `src/proxy/tcp_proxy_client.c`.

doc/media_async_audit_findings.txt

@@ -0,0 +1,530 @@
+Аудит media_async / media_delivery — 2026-10-24
+Статус: alias encrypted_file, граница voice_file, переанонс SQLite и расхождение MIME write/read исправлены.
+Сверка двух каталогов завершена: все11 заголовков, sync.md, _desc.txt и encrypted_attachments.md.
+Общий service_lifecycle.md проверен в media-части; разделы других сервисов не считаются закрытыми.
+Ниже сохранена хронология воспроизведений и исправлений; прежние отметки незавершённости относятся к этапам.
+Последние проверки MIME и итоговая архитектурная сверка — в конце.
+
+Подтверждённый дефект: исходник уничтожается через другое имя того же файла
+
+encrypted_file_write, src/media_async/encrypted_file.c:79-87, сравнивает только строки
+source/destination. Разные строки могут обозначать один inode. fopen(destination,"wb")
+усекает уже открытый source. Криптография затем успешно обрабатывает пустой файл.
+Контейнер корректен для нулевого содержимого, но исходные данные потеряны; возврат равен 0.
+
+Воспроизведено на настоящих функциях из src/libutun.a:
+- source и source с компонентом /./: исходные30 байт заменены контейнером152 байта,
+  plaintext_size=0, rc=0, SHA256 исходника изменился;
+- source и hardlink: тот же результат;
+- encrypted_file_read тоже пропускает оба вида alias: контейнер182 байта заменяется
+  plaintext30 байт, rc=0, исходный ciphertext больше не существует в прежнем виде.
+
+У read такая же проверка strcmp в строке118 и разрушающий fopen в строке142.
+В текущем групповом pipeline вызывающий выбирает отдельный .part; воспроизведение
+доказывает дефект файлового API, а не наблюдавшуюся потерю реального пользовательского вложения.
+Ошибку нельзя замаскировать описанием одинаковых файлов как успешного no-op:
+шифрование и расшифровка должны создавать другое содержимое.
+
+Диагностика:
+- /tmp/media-encrypted-alias-repro.c — четыре проверки, сверяются inode, размеры и SHA256;
+- /tmp/media-encrypted-alias-repro.mk — использует цели/библиотеки/флаги tests/Makefile;
+- /tmp/media-encrypted-alias-repro.log — полный журнал с media=debug;
+- /tmp/media-encrypted-alias-lvVS77/ — сохранённые входы и результаты опыта.
+Проектные .c/.h для воспроизведения не менялись.
+
+Согласованная архитектура исправления
+
+Одной проверки file_io_paths перед fopen(wb) недостаточно для полного исправления
+контракта владения. Сейчас encrypted_file удаляет destination при ошибке, а
+ak_file_done повторно удаляет заранее вычисленный .part даже при раннем отказе.
+Нужно убрать открытие произвольного назначения с усечением и очистку по одному имени.
+
+Граница модулей
+
+- lib/file_io: UTF-8/regular-file проверки, идентичность, эксклюзивный temp,
+  flush/sync/close, atomic rename, владение temp и защита от orphan cleanup.
+- encrypted_file: создание/проверка контейнера в собственном temp; без публикации
+  конечного имени, SQLite и состояния async-задачи.
+- chat_attachment: задача владеет temp, выбирает конечное имя и выполняет одну
+  публикацию; completion меняет состояние БД/UI и освобождает только свои ресурсы.
+  Подготовка, sync и rename остаются в worker, как сейчас; новые файловые I/O в uasync не добавляются.
+
+Предлагаемый контракт write/read
+
+1. Функция получает source, конечный target_path и указатель на обнулённый file_io_temp.
+   target_path задаёт место будущего результата; он не открывается с усечением.
+   До начала работы file_io_paths(source,target_path) обязан вернуть 0.
+   Совпадение строки, /./, hardlink и конечная ссылка назначения отклоняются без изменений.
+2. Источник открывается общим file_io_open_read. Только после успешного открытия
+   создаётся уникальный temp рядом с target_path через file_io_temp_open.
+   На POSIX он имеет права 0600; создание эксклюзивное, владелец сразу учтён в общем реестре.
+3. Контейнер пишется/проверяется через уже открытый FILE этого temp. Нет второго .part,
+   второго открытия выхода по пути или дополнительного слоя публикации внутри codec.
+4. Полностью проверяются данные, закрытие входа и durable завершение выхода.
+   При ошибке удаляется только созданный этой операцией temp; существующие source/target сохраняются.
+   При успехе возвращается закрытый, синхронизированный temp, который ещё не опубликован.
+   Результат info/type у read присваивается только после полного успешного завершения подготовки.
+5. Владелец file_io_temp размещается прямо в ak_file и имеет стабильный адрес до done;
+   копировать его структуру нельзя: реестр хранит адрес владельца.
+   Функции не принимают уже активный output и не уничтожают его при отказе аргументов.
+
+Единая политика durability
+
+В file_io_temp_open добавить flags, в file_io_temp хранить выбранный режим на весь
+срок операции. FILE_IO_DURABLE включает обе части: finish и publish.
+Обычные пользователи передают 0 и сохраняют свою семантику; отдельные флаги в каждом
+finish/publish не нужны. Это предотвращает случайное сохранение файла без сохранения имени.
+
+Durable finish: fflush -> fsync/_commit того же открытого fd -> fclose. Ошибка любой
+фазы сохраняет первый код ошибки; close выполняется и при отказе sync. Открывать путь
+заново ради fsync не нужно. После отказа temp остаётся у владельца до discard.
+
+Publish повторно проверяет идентичность source/target и принимает только закрытый temp.
+На POSIX: rename и fsync каталога назначения; соседний temp находится в том же каталоге.
+На Windows: общий wide API и MOVEFILE_WRITE_THROUGH. Родительский каталог вычисляется
+без обрезания: имя без '/' означает '.', '/file' означает '/'.
+Политика sync принадлежит file_io, а не формату зашифрованного контейнера.
+
+Точка фиксации — успешный rename. До неё ошибка сохраняет старый target.
+После rename ошибка fsync каталога означает: результат уже установлен, долговечность
+имени не подтверждена. Нельзя обещать откат, удалять новый файл вслепую или восстанавливать
+старое содержимое. В этот момент temp уже отсоединён от реестра и его имя в owner пусто.
+Этот переход должен быть явно описан в file_io.h и проверен тестом.
+Длительный fsync выполняется после снятия блокировки реестра временных файлов.
+
+Владение задачи и отмена
+
+ak_file хранит file_io_temp вместо temporary[...]. Worker после успешной подготовки
+один раз вызывает file_io_temp_publish с тем же target и источником.
+До publish поле temporary непустое; после успешного rename оно пустое даже при
+ошибке directory sync. По этому переходу задача фиксирует факт своей публикации.
+Completion всегда может вызвать discard: после rename он ничего не удаляет.
+Cleanup при отмене/удалении канала учитывает отдельно действительно созданные/
+заменённые артефакты. Вычисленный путь не является доказательством владения файлом.
+При отказе до создания выхода нельзя удалять существующий target или его alias.
+
+Отдельных async owners, refcount и фоновых потоков не требуется. Ключ по-прежнему сохраняется
+до шифрования; ready получателя/публикация сообщения подтверждаются только после
+успешного worker и проверки актуальности канала в completion. Авторская строка ключа
+сохраняется до worker по прежним правилам. Общей транзакции ФС/SQLite нет: после rename
+путь остаётся известен attachment_keys для последующей очистки/повторной операции.
+
+Кеш и восстановление после crash
+
+Активный temp защищён существующим file_io-реестром, в том числе после finish.
+В chat_msg убрать специальное сохранение вычисленного cipher_path.part; конечный
+cipher_path по-прежнему защищается attachment_keys, временный файл — своим owner.
+После crash реестра нет: такие temp допустимо удалить.
+
+Нельзя ограничиться нынешним orphan walk дерева media: plaintext-temp находится
+в decrypted, а ak_recover_preparations знает только фиксированный .part.
+В init/очистке после завершения workers нужно удалять оставшиеся временные файлы
+строгого собственного формата <UUID>.uenc.tmp.<32hex> / <UUID>.file.tmp.<32hex>
+в управляемых каталогах media/decrypted. Использовать file_io_remove_orphan,
+чтобы сохранить активные temp другого instance того же процесса. Конечные файлы,
+ключи и данные иных форматов такой проход не удаляет; ошибка обхода логируется.
+
+Область изменений
+
+Основные файлы: lib/file_io.c/h, media_async/encrypted_file.c/h,
+chat/chat_attachment.c, chat/chat_msg.c, test_encrypted_file/test_media_primitives
+и сетевые проверки зашифрованных вложений. Остальные вызовы file_io_temp_open
+в media_async/media_delivery/video переводятся на явные flags=0.
+DM не вызывает encrypted_file_write/read: он использует media_crypto streams
+и общие sync/publish helper-функции из encrypted_file.h. При правке общего слоя
+необходимо сохранить их durable контракт; перенос общих операций в file_io должен
+быть прямым, без совместимых обёрток и без изменения DM state machine.
+Формат контейнера, nonce, протокол ключей и схема БД для этого фикса не меняются.
+
+Регрессии и критерии готовности
+
+- Обе операции: одинаковая строка, /./, hardlink, symlink, отсутствующий/необычный source;
+  source и прежний target не меняются, alias не удаляется, чужой temp не освобождается.
+- Обычные файлы размером 0/1/32767/32768/32769 байт, большой файл, UTF-8 пути;
+  успешная подготовка не меняет target до publish. Read не публикует info/type при ошибке.
+- Внедрение ошибок open/fdopen/read/write/seek/flush/fsync/input-close/output-close/
+  rename/directory-sync/RNG; отсутствие утечек fd/памяти/регистраций temp.
+- Подмена target на hardlink между подготовкой и publish: повторная проверка
+  отклоняет публикацию, исходник сохраняется, удаляется только собственный temp.
+- Отказ directory sync после rename: новый файл цел, temp-owner отсоединён,
+  ошибка не представляется как откат; повторная операция корректна.
+- Orphan cleanup во время work, после finish, после publish; crash/restart
+  в обоих деревьях, чужие имена сохраняются. Отмена, stop и удаление канала
+  до work, после подготовки и после rename: один done, нет публикации сообщения/ready.
+- Профильные 20 тестов, ASAN/UBSan/LSan и полный набор. Изменение file_io требует
+  также проверки его прежних пользователей: copy, video и media blocks/download.
+
+Этот проект реализован. Успешные 20 тестов ниже относятся к исходной реализации;
+проверки исправленного кода приведены в конце.
+
+Что проверено и что осталось
+
+Прочитаны все шесть пар .c/.h media_async, целиком file_transfer.c/h, заголовки
+media_delivery/download/index/proto, sync.md и doc/encrypted_attachments.md.
+Полная повторная сверка остальных реализаций media_delivery и исправление контрактов
+ещё не выполнены. Прежние [V] в общем checklist относятся к предыдущим аудитам;
+новые незавершённые пункты отмечены [~].
+
+Linux: ./build.sh --no-gui -j4 — PASS;20/20 профильных тестов — PASS:
+media_primitives, attachment, attachment_send, encrypted_file, encrypted_attachment,
+media_async, media_index, media_index_regressions, media_delivery_sql,
+media_delivery_download, media_download_timeout, media_query, media_blocks,
+media_replication, media_delivery_integration, media_delivery_full,
+media_delivery_chat, dm_media, dm_worker, services.
+Логи: /tmp/media-audit-build.log, /tmp/media-doc-audit-results.log,
+/tmp/media-doc-audit-logs/. Штатный test_encrypted_file не покрывает alias.
+Старые сбои encrypted_attachment/media_delivery_chat в этом прогоне не воспроизвелись;
+один PASS не закрывает задачи о нестабильности.
+На исходном этапе полный check.sh и новые sanitizer-прогоны не запускались.
+
+Результаты исправления — 2026-10-24
+
+- file_io_temp получил единый FILE_IO_DURABLE: sync открытого fd при finish,
+  write-through rename на Windows и directory sync после rename на POSIX.
+  После rename temporary пуст, включая отказ directory sync; discard не удаляет результат.
+  Общие sync/publish функции перенесены в file_io; DM вызывает их напрямую.
+- Write/read готовят отдельный закрытый temp. Source/target не открываются с усечением;
+  совпадающая строка, /./, hardlink и конечная ссылка отклоняются до создания выхода.
+  Read выдаёт info/type только после успешного закрытия/сохранения проверенного результата.
+- ak_file хранит один output, учитывает подготовленный plaintext snapshot и выполненный rename.
+  Worker публикует один раз; completion очищает только собственные артефакты.
+  Кеш использует реестр владельцев; recovery очищает строгие temp в media и decrypted.
+  Построение путей и SQL recovery используют одну каноническую media_base.
+- test_encrypted_file: прежние шесть размеров, восемь alias-сценариев обоих API,
+  активный output, alias перед publish и 23 отказа I/O с контролем fd/temp/метаданных.
+  До rename прежний target сохраняется; после отказа directory sync новый файл установлен.
+- test_media_primitives: durable и обычный режим, sync failure до rename, failure после
+  rename, относительный/корневой каталог, защита активного temp в worker и после close.
+- test_attachment_send детерминированно ждёт настоящего crypto rename без обработки
+  completion, затем останавливает сервис: нет сообщения/ключа/оставшихся файлов/temp.
+- test_encrypted_attachment при каждом startup/restart проверяет оба дерева:
+  stale temp удалены; открытый/закрытый активные owners, конечные файлы и чужие имена сохранены.
+- Профильный Linux-набор: 21/21 PASS, включая video/no_ffmpeg, DM, services и media delivery.
+  Основной make check: 185/185 PASS. TUN в отдельном network namespace с тем же бинарником:
+  proxy9/9, burst1/1, load8/8 PASS; 134217728 проверенных байт.
+- ASAN/UBSan/LSan: 21/21 PASS с detect_leaks=1. Все встроенные зависимости собраны
+  с sanitizer-флагами в /tmp/utun-media-fix-sanitizers; обычные объекты проекта не смешивались.
+  Windows/FreeBSD build/runtime не проверялись.
+
+Логи: /tmp/media-fix-profile-results.log, /tmp/media-fix-full-check.log,
+/tmp/media-fix-network-check.log, /tmp/media-fix-sanitizer-results.log,
+/tmp/media-fix-cancel-after-rename.log, /tmp/media-fix-encrypted-file.log.
+Проверка реализации не выявила противоречий владения в перечисленных сценариях.
+Частичные отметки остальных файлов аудита сохраняются; этот фикс не означает полного
+завершения проверки media_async/media_delivery или закрытия старых нестабильных тестов.
+
+Продолжение аудита — 2026-10-24: граница длительности voice_file
+
+voice_file.h обещает максимум24ч; attachment_validate (attachment.c:35) отвергает
+duration_ms >86400000. Однако voice_file.c:16 проверяет samples/channels/rate >86400:
+целочисленное деление отбрасывает долю секунды. Записи с полными кадрами на24ч+20..980мс
+проходят проверку аргументов. Затем voice_file.c:37 вычисляет точную длительность
+в миллисекундах по числу20мс кадров, уже выходящую за предел метаданных.
+attachment_send.c вызывает voice_file_encode в worker, а attachment_validate —
+при публикации результата. При успешном полном кодировании такой результат будет
+отклонён после подготовки файла. Это дефект границы записей длиннее суток;
+сбой обычных коротких записей или потеря данных этим опытом не установлены.
+
+Диагностическое воспроизведение на настоящем voice_file_encode из src/libutun.a:
+- /tmp/media-voice-duration-repro.c и .mk; сборка через tests/Makefile и его библиотеки/флаги.
+- Linux64: виртуальный read-only PCM достаточного размера, без чтения или заполнения.
+  Linker wrapper opus_codec_encoder_create фиксирует достижение кодировщика
+  и возвращает NULL до чтения PCM/открытия output. Реальная проверка аргументов не подменена.
+- Частоты8000/12000/16000/24000/48000, mono/stereo; для каждой пары проверены
+ 24ч-20мс, ровно24ч, +19мс хвоста, +20мс, +980мс и +1000мс: всего60 случаев.
+- Ровно24ч и +19мс хвоста проходят, так как хвост короче полного кадра отбрасывается;
+  +1000мс отвергается до encoder. На +20/+980мс во всех10 сочетаниях codec достигнут,
+  тогда как attachment_validate соответствующей длительности возвращает-1:
+  duration_guard_mismatches=20, confirmed=1.
+- Все60 вызовов возвращают-1: для допустивших encoder это намеренная инъекция отказа,
+  для +1000мс — штатная валидация. Опыт доказывает ошибку допуска к encoder,
+  но не является24-часовым кодированием или сквозной проверкой отправки такого файла.
+- Полный журнал с media=info/debug=info: /tmp/media-voice-duration-repro.log;
+  сборка: /tmp/media-voice-duration-build.log. Проектные .c/.h не менялись.
+
+Проект простого исправления:
+1. Задать один ATTACHMENT_DURATION_MAX_MS=86400000 в attachment.h; использовать
+   в валидаторе voice/video и проверке video completion вместо отдельных литералов.
+2. После проверки rate/channels считать frame_samples=(rate/50)*channels,
+   frames=count/frame_samples. До создания encoder/открытия файла отклонять
+   frames<25 либо frames>ATTACHMENT_DURATION_MAX_MS/20 (4320000).
+   Проверяется длительность записываемых полных кадров, хвост <20мс по-прежнему отбрасывается.
+3. Только после ограничения frames считать samples=frames*frame_samples
+   и duration_ms=frames*20. Размер samples не превосходит count, длительность
+   помещается в uint32_t; большие count не требуют потенциально переполняющего умножения на20.
+4. Сообщение раннего отказа различает неверные параметры и недопустимую длительность;
+   для длительности выводит count/rate/channels/frames и разрешённые границы.
+   Дополнительный helper/API или изменение pipeline/формата не нужны.
+5. В test_attachment добавить проверку границ500мс/24ч, хвоста <20мс,
+   превышения на полный кадр, разных rate/channels и раннего отказа без изменения файла/метаданных.
+   Верхние границы проверять диагностической точкой до encoder без реального кодирования суток;
+   сохранить существующий настоящий Opus roundtrip короткой записи.
+
+На этапе подтверждения аудит был остановлен по AGENTS.md:10, без изменения рабочего кода.
+Пользователь согласовал исправление; результаты приведены ниже.
+
+Результаты исправления voice_file — 2026-10-24
+
+- ATTACHMENT_DURATION_MAX_MS в attachment.h задаёт один предел86400000мс:
+  его используют валидатор voice/video, video completion и кодировщик голоса.
+- voice_file считает frames=count/frame и проверяет25..4320000 до создания Opus
+  и открытия выходного файла. Метаданные при раннем отказе не изменяются.
+  Хвост <20мс сохраняет прежнее поведение: отбрасывается, включая хвост после ровно24ч.
+- Проверка архитектуры: frame всегда положителен и не больше1920 для разрешённых rate/channels;
+  деление count/frame не переполняется. После ограничения frames произведение frames*frame
+  не превосходит исходного count; frames*20 не превосходит86400000 и помещается в uint32_t.
+  Подготовка, публикация, владение PCM/файлом и формат контейнера не меняются.
+- Лог раннего отказа содержит count/rate/channels/frames и разрешённые границы;
+  debug принятой записи показывает число кадров, длительность и отброшенный хвост.
+- test_attachment: 120 граничных вызовов для пяти частот и mono/stereo.
+  Все70 недопустимых длительностей отвергнуты до encoder; все50 допустимых
+  дошли до диагностического encoder с инъекцией отказа. Во всех120 случаях
+  побайтно сохранены исходные metadata и содержимое существующего output.
+  Linux64 использует виртуальный read-only PCM; суточное кодирование не выполняется.
+- Настоящий Opus encode/decode: прежняя1с запись и десять записей на500мс с хвостом
+  почти20мс, все rate/channels, все три preset. Проверены header, декодирование,
+  число20мс кадров, EOF и валидность метаданных результата.
+- validate/encode/decode voice/video принимают86400000мс и отвергают86400001мс.
+- ./build.sh --no-gui -j4 — PASS. В изменённых C-файлах/тесте предупреждений сборки нет;
+  общие прежние предупреждения остальных модулей остаются в полном логе.
+- Профильные тесты10/10 PASS: attachment, attachment_send, encrypted_file,
+  encrypted_attachment, media_async, dm_media, dm_worker, services, video, video_no_ffmpeg.
+  Первый запуск attachment внутри sandbox выдал запреты создания stream fd;
+  весь профильный набор, включая attachment, успешно повторён вне sandbox.
+
+Логи: /tmp/media-voice-fix-build.log, /tmp/media-voice-fix-profile-results.log,
+/tmp/media-voice-fix-profile-logs/test_attachment.log и остальные логи этого каталога.
+Новый полный make check и ASAN/UBSan/LSan не запускались; прежние результаты encrypted_file
+выше не относятся к этому изменению. Windows/FreeBSD не проверялись.
+voice_file.h и attachment.h сохраняют [~]: завершение этого фикса не закрывает
+оставшуюся сверку контрактов всего аудита. Повторная проверка media_delivery ещё не завершена.
+
+Продолжение аудита — 2026-10-24: переанонс записей SQLite
+
+Полностью прочитаны media_index.c/h, media_download.c/h, media_delivery.c/h,
+file_transfer.c/h, media_delivery_proto.h и sync.md. Повторно сверены media_crypto.c/h.
+В media_crypto.h уточнены native байты nonce, границы CCM/буферов, пустой поток,
+момент выдачи размеров/хеша и отсутствие close/fsync/rename; неверный аргумент не обнуляет выходы.
+В file_transfer.h уточнены lookup/авторизация, 16 операций, размер1..INT64_MAX,
+усечение своего временного назначения даже при отказе запуска, таймаут и отмена/владение callback.
+Изменения только описаний сохранены коммитом5dbca4a2.
+
+Подтверждённый дефект
+
+media_delivery_announce_local_blocks (media_delivery.c:1610) читает media_id/block_id
+через sqlite3_column_blob, но проверяет только ненулевой указатель. Затем
+media_delivery_send_have_block копирует по16 байт в пакет и подписывает объявление.
+media_files имеет BLOB NOT NULL без CHECK длины: такие строки допустимы текущей схемой.
+Обычные media_index writers пишут правильные длины; опыт моделирует повреждённые
+локальные данные, а не доказанный путь внесения повреждения удалённым участником.
+
+Настоящие SQLite, схема, обработчик, выбор группы/суперузла и Ed25519; перехвачена
+только транспортная отправка в существующем tests/media_delivery_fixture.h:
+- Контрольные UUID16/16, chunk0, chat_id111: один корректный HAVE_BLOCK.
+- media_id длиной1 байт: один HAVE_BLOCK с16-байтным media_id, из них15 байт вне BLOB.
+  В журнале вместо ожидаемого единственного7a видны посторонние ненулевые байты памяти.
+- block_id длиной1 байт: аналогичное чтение15 лишних байт в сетевой block_id.
+- media_id или block_id длиной17 байт: отправка с молчаливым усечением до16.
+- chunk=-1: wire_chunk=4294967295; chunk=4294967296: wire_chunk=0.
+  Причина — sqlite3_column_int с последующим приведением к uint32_t без диапазона.
+- chat_id111junk: strtoull без endptr принимает префикс111 и направляет объявление в группу111.
+- Итого8 случаев,7 повреждённых строк из7 отправлены; invalid_records_sent=7, confirmed=1.
+  Ошибки соответствующих полей в модуле не логируются. Пакеты сохранены только стендом,
+  реальные удалённые узлы в опыте не участвовали. Ошибка ASAN или падение не воспроизводились.
+
+Артефакты: /tmp/media-announcement-audit.c, /tmp/media-announcement-audit.mk,
+/tmp/media-announcement-audit-build.log, /tmp/media-announcement-audit.log.
+Сборка через tests/Makefile с настоящими src/libutun.a/libuasync.a и штатными флагами;
+проектные .c для диагностики не менялись. Очистка собственного стенда исправлена и повторно проверена.
+Отдельно по коду видно: результаты bind/завершающего step/finalize игнорируются;
+SQL-ошибку окончания обхода нельзя выдавать как обычное «done». Инъекция SQL-ошибок здесь не выполнялась.
+
+Проект простого исправления
+
+1. Проверять строку на границе чтения SQLite до доступа как к фиксированным структурам:
+   media_id/block_id имеют тип BLOB и ровно16 байт; проверить полученные указатели.
+   Скопировать прошедшие проверку UUID в локальные массивы до вложенных SQL/отправок.
+2. chunk читать как int64: тип INTEGER, 0..UINT32_MAX, только затем cast.
+   chat_id — TEXT, длина1..20 без embedded NUL, каноническое ненулевое uint64 decimal.
+   Полный разбор должен отвергать суффиксы, знаки, пробелы, leading zero и переполнение;
+   строка канала должна сохранять свой смысл при переводе в router group_id.
+3. Плохую строку пропускать с WARN, указав rowid/типы/длины/некорректное поле,
+   без чтения за BLOB и без анонса. Корректные соседние строки продолжать обрабатывать.
+   Никакого общего выделяемого снимка или отката уже отправленных корректных анонсов не требуется.
+4. Проверять bind, terminal step и finalize; SQL-ошибки логировать с фазой/кодами
+   и количеством обработанных строк. Не превращать их в обычный успешный финальный лог.
+   Сохранить существующий void API, поштучные анонсы и wire-формат.
+5. Регрессии в штатной media-цели: valid row, длины UUID0/1/15/16/17 и неверные SQL-типы,
+   chunk=-1/0/UINT32_MAX/UINT32_MAX+1, неверные/граничные chat_id, embedded NUL;
+   смесь корректных/плохих записей и ошибки SQL. Перехват HAVE_BLOCK обязан доказать,
+   что наружу ушли только исходные16 байт проверенных UUID и правильный номер группы/блока.
+
+Аудит остановлен по AGENTS.md:10 после подтверждения дефекта и подготовки проекта исправления.
+Новые полные build/check/sanitizer-прогоны не запускались: изменения в репозитории только документальные.
+media_crypto.h и file_transfer.h можно отметить [V]; media_delivery.h/proto.h остаются [~]:
+нужно исправление этого пути и завершение сверки описаний. Остальные прежние отметки не закрывают
+весь аудит. Остались контракты attachment/attachment_send/voice, связанные encrypted/lifecycle документы
+и устаревший _desc.txt (RTT-подбор, direct-only репликация и её интервалы расходятся с текущим кодом).
+
+Результаты исправления SQLite-переанонса — 2026-10-24
+
+- Проверка остаётся внутри существующего обхода media_files. UUID допускаются только
+  как BLOB ровно16 байт; chunk — INTEGER в0..UINT32_MAX, читается через int64.
+  Исходные SQL-типы получены до преобразований. Проверенные UUID копируются
+  в локальные16-байтные массивы до вложенных запросов/отправок.
+- chat_id имеет тип TEXT, длину1..20; разбор по объявленной длине отвергает embedded NUL,
+  знаки/пробелы/суффиксы, ноль/leading zero и переполнение. Допускается весь ненулевой uint64,
+  включая UINT64_MAX. Условие gid<=(UINT64_MAX-digit)/10 до операции исключает переполнение.
+- Непроверенные фиксированные memcpy и сужающие cast устранены. Некорректная строка
+  пропускается с WARN: id/поле, типы/длины, исходный chunk. Хорошие соседние строки продолжают обрабатываться.
+- prepare/bind/завершающий step/finalize проверяются. Отказ SQL логирует фазу/коды
+  и неполный обход; обычный complete-лог не выдаётся. Счётчики rows/eligible/skipped
+  описывают обработку, а не гарантированную доставку. Уже корректно отправленные пакеты не откатываются.
+- Архитектура сохраняет существующие void API, wire-формат, источник ролей и единичные анонсы;
+  нет общего снимка/новых ресурсов, транзакций или состояния. Statement закрывается и при ошибке bind/step.
+- test_media_delivery_sql: 36 случаев полей,32 недопустимых строки не отправляются,
+  четыре допустимые сохраняют точные UUID/group/chunk/timestamp. Проверены границы
+  UINT32_MAX/UINT64_MAX, все заявленные длины UUID и неверные SQL-типы, embedded NUL.
+  В смеси valid/invalid/valid отправлены только два корректных анонса.
+- Linux: пять внедрений prepare/bind/first-step/step после первой строки/finalize.
+  До отказа сохранены0/0/0/1/2 корректных отправки, statement не остаётся активным;
+  проверяется ERROR с фазой и отсутствие ложного complete. После каждого отказа
+  обычный повтор успешно отправляет обе строки с исходными UUID и номерами блоков.
+  После захвата файлового лога тест явно восстанавливает console_enabled.
+- ./build.sh --no-gui -j4 PASS; в изменённых C-файлах предупреждений нет.
+  Профиль12/12 PASS: delivery_sql, query, blocks, replication, index/index_regressions,
+  delivery_download, download_timeout, delivery_integration/full/chat, services.
+  После изменения только вывода диагностики SQL-тест повторно прошёл отдельно.
+- ASAN/UBSan/LSan4/4 PASS: delivery_sql/query/blocks/replication, detect_leaks=1.
+  Свежая копия /tmp/utun-media-announcement-sanitizers содержит текущий код;
+  CPPFLAGS=-fsanitize=address,undefined применён и к встроенным зависимостям.
+  Обычные объекты проекта не смешивались с sanitizer-объектами.
+  Первый configure внутри sandbox отклонён LeakSanitizer из-за ptrace;
+  сборка и тесты успешно выполнены вне sandbox.
+
+Логи: /tmp/media-announcement-fix-build.log, /tmp/media-announcement-fix-profile-results.log,
+/tmp/media-announcement-fix-sql-final.log, /tmp/media-announcement-sanitizer-build.log,
+/tmp/media-announcement-sanitizer-tests-build.log, /tmp/media-announcement-sanitizer-results.log.
+Полный make check и Windows/FreeBSD не запускались. Завершение фикса не означает завершения
+сверки оставшихся заголовков и документов двух каталогов.
+
+Продолжение сверки описаний — 2026-10-24: MIME контейнера
+
+Сверены и уточнены attachment.h, attachment_send.h, voice_file.h, media_delivery_proto.h
+и комментарий неиспользуемого HAVE_BLOCK timeout в media_delivery.h:
+- attachment: UTF-8 и только ASCII C0/DEL, границы полей по kind, состояние выходов
+  при ошибке encode/decode, content_type не является валидатором kind.
+- voice_file: собственное перезаписываемое назначение, поздняя ошибка close может
+  изменить info; native контейнер и отсутствие fsync/атомарной публикации.
+- attachment_send: владение начинается при вызове trampoline, при отказе самого post
+  остаётся у caller; PCM/compressor, контекст освобождения, DM generation, канальные
+  request_id/reply, внутренний UUID подготовки и события подготовки вместо обещания доставки.
+- proto: вне SYNC числа native-endian; SERVE_REG/LEAVE только вспомогательный учёт,
+  загрузчик их не посылает. SERVE_ACK не отправляется; приём SERVE_ACK/HAVE_BLOCK_ACK игнорируется,
+  ожидания ACK/его таймера нет. Не менялись команды, wire или runtime-поведение.
+Коммиты описаний:08692fa4 и4e4c60ee. Из общего service_lifecycle повторно сверена
+только media-секция111..196 по текущему порядку start/quiesce/destroy и прочитанным модулям;
+за пределами media документ не считается полностью проверенным.
+
+Подтверждённый дефект MIME
+
+encrypted_file_write проверяет только ненулевой type и strlen(type)<32, затем шифрует строку.
+encrypted_file_read требует непустую NUL-терминированную строку в32-байтном поле,
+ASCII33..126 без '"' и '\\'. Поэтому write может успешно подготовить непригодный для read контейнер.
+chat_attachment_send (chat_attachment.c:198..225) имеет такую же слабую входную проверку:
+до сохранения ключа/старта worker проверяется лишь наличие указателя и длина.
+
+Реальный roundtrip, без подмены криптографии или файловых функций:
+- Контроль application/octet-stream: write=0/read=0, hash расшифрованного temp равен исходному.
+- Пустой MIME, перевод строки, двойная кавычка, обратная косая черта и не-ASCII UTF-8:
+  все пять write=0, после publish и вычисления точного внешнего hash соответствующий read=-1.
+  Ключ, author, UUID и контейнер при чтении те же. Ошибка — invalid metadata/type,
+  а не аутентификация или порча контейнера в опыте.
+- При ошибке read прежние info/type сохранены, temp очищен; SHA256 исходника неизменен во всех6 случаях.
+  Это подтверждённый дефект принятия аргумента в API. Сквозная отправка/открытие карточки GUI не моделировалась.
+- /tmp/media-content-type-audit.c и .mk, сборка через tests/Makefile и настоящие библиотеки;
+  /tmp/media-content-type-audit-build.log, /tmp/media-content-type-audit.log.
+  Артефакты: /tmp/media-content-type-audit-FdtMC3/. Лог содержит MIME как hex, без управляющих символов в тексте.
+
+Проект простого исправления
+
+1. Экспортировать encrypted_file_validate_type в encrypted_file.h: 0/-1, bounded strnlen(type,32),
+   непустая строка длиной1..31, ASCII33..126 кроме двойной кавычки и обратной косой черты.
+   Это ограничение существующего контейнера, не новый полноценный MIME parser и не правило для всех сообщений чата.
+   Диагностика показывает длину/позицию/hex ошибочного байта, не выводит сырую непроверенную строку.
+2. Вызывать один валидатор в chat_attachment_send до выделения задачи/генерации ключа/записи в БД,
+   в encrypted_file_write до открытия source/temp и в read для расшифрованного32-байтного поля.
+   Существующие проверки длины расшифрованного блока сохраняются; правило MIME не дублируется в трёх местах.
+3. Не менять формат, nonce, crypto, DB state machine или файловое владение. Reader остаётся строгим;
+   writer не должен выдавать успех для метаданных, которые этот же reader не принимает.
+4. Регрессии: NULL/пустая строка/31/32 байта, каждый запрещённый символ, ASCII-границы
+   и валидные значения; writer на раннем отказе сохраняет source/target/output.
+   Для reader плохие metadata шифруются тестом с известным ключом и пересчитанным внешним hash:
+   отказ не теряет прежние info/type и не оставляет temp. Проверить send-отказ без строки ключа/worker/файлов.
+
+На этапе воспроизведения аудит был остановлен по AGENTS.md:10. Затем пользователь разрешил продолжать исправления.
+
+Реализация и проверка MIME-фикса — 2026-10-24
+
+- encrypted_file_validate_type использует bounded strnlen(type,32) и одно правило для send/write/read.
+  NULL, пустая/нетерминированная строка и недопустимый байт отклоняются с WARN: длина/позиция/hex.
+  Успешная проверка имеет DEBUG-лог; сырые непроверенные строки в лог не попадают.
+- send проверяет type до выделения задачи, генерации/сохранения ключа и старта worker.
+  write отказывает до файловых операций и изменения output. read проверяет уже аутентифицированное
+  поле после проверки длины metadata и сохраняет атомарное присваивание info/type только при успехе.
+  Валидатор не выполняет I/O и разрешён в uasync; файловые write/read остаются worker-only.
+- Правило сохраняет действующий набор reader, включая короткое значение "a"; это не полный MIME parser.
+  Не добавлены новый wire, изменение nonce/crypto, состояние БД или второй владелец файлов.
+  Код:90964e7a/f4cc6920, регрессии:aace975a.
+- test_encrypted_file: все256 значений первого байта,92 допустимых; NULL отдельно.
+  Восемь ранних отказов сохраняют output побайтно, source/cipher/target по SHA256.
+  Три настоящих roundtrip проверяют длины1/24/31, metadata, SHA256 plaintext и сохранность target до publish.
+  Семь плохих wire-полей зашифрованы настоящим CCM с пересчитанным внешним SHA256:
+  read отказывает, сохраняя info/type/старый target/source; temp и fd не остаются.
+- test_attachment_send: восемь отказов до ключей/worker, число файлов и исходный байт сохранены.
+  Сохранён прежний сценарий реального encrypted worker, отмены после публикации и recovery.
+- ./build.sh --no-gui -j4 PASS; в изменённых C-файлах предупреждений нет.
+  Профиль10/10 PASS: encrypted_file, attachment_send, encrypted_attachment, attachment, media_async,
+  services, media_delivery_chat/full, dm_media, dm_worker.
+- ASAN/UBSan/LSan4/4 PASS: encrypted_file, attachment_send, encrypted_attachment, services.
+  detect_leaks=1, halt_on_error=1; встроенные зависимости также инструментированы через CPPFLAGS.
+  Отдельная копия /tmp/utun-media-mime-sanitizers исключает смешение обычных/sanitizer-объектов.
+  Первый build остановился из-за нехватки /tmp; очищены воспроизводимые объекты прежних копий,
+  затем повторная сборка и весь прогон завершились успешно. Исходники и журналы сохранены.
+
+Логи: /tmp/media-mime-fix-build.log, /tmp/media-mime-fix-profile-results.log,
+/tmp/media-mime-fix-profile-logs/, /tmp/media-mime-sanitizer-build-retry.log,
+/tmp/media-mime-sanitizer-tests-build.log, /tmp/media-mime-sanitizer-results.log,
+/tmp/media-mime-sanitizer-test_*.log. Полный check и Windows/FreeBSD для MIME-фикса не запускались.
+encrypted_file.h теперь согласован с реализацией. Последующая сверка общих описаний завершена ниже.
+
+Завершение аудита media_async/media_delivery — 2026-10-24
+
+- Все11 публичных заголовков двух каталогов сверены по полным функциям и структурам реализаций:
+  media_async/crypto, attachment/send, encrypted_file, voice_file, media_index/download/delivery/proto,
+  file_transfer. Уточнены назначения, входы/выходы, владение и потоки, ошибки и wire-ограничения.
+- _desc.txt заменён актуальным описанием подготовки, поиска/загрузки, relay, каталога и репликации.
+  Убраны прежние предположения о RTT-выборе, только прямых соединениях, часовых повторах и ACK-окне.
+  Отражены фактические QUERY/CM/transfer UUID, пределы выдач, per-group RX-курсор и атомарный приём страницы.
+  sync.md уточняет отсутствие ожидания HAVE ACK и проверки SQLite при локальном переанонсе.
+- encrypted_attachments.md целиком сопоставлен с chat_attachment.c и источниками desktop/Android UI:
+  inputbar, MessageList/attachment_key_ui, JNI snapshot, ChatRepository, MessageBubble/Reply/ChannelList.
+  Уточнены MIME, видимость desktop-кнопки при наличии pending requests и preview цитаты после расшифровки.
+  Контейнер не выдаётся UI как готовый файл; путь/метаданные заменяются после готовности plaintext.
+  Это сверка исходников, без нового интерактивного GUI/Android runtime-прогона.
+- media-раздел service_lifecycle.md сверён по текущему start/quiesce/join/done/destroy и владельцам
+  worker/temp/CM/relay. Дописано, что ранний MIME-валидатор допустим в uasync и не выполняет I/O.
+  Общий документ сохраняет частичную отметку: голос, звонки и другие немедийные владельцы вне этой проверки.
+- Архитектура исправлений остаётся простой: формат/валидация контейнера принадлежат encrypted_file,
+  temp/durability — file_io, публикация и БД/UI — задаче chat_attachment; один владелец на ресурс.
+  Media_index регистрирует подготовленное, delivery проверяет передачу и ведёт каталог своей группы.
+  Синхронные приём/проверка/сборка delivery в uasync и отсутствие общей транзакции ФС/SQLite
+  явно описаны как действующие границы. File_transfer оставляет ключи/авторизацию/проверку caller.
+- Все четыре воспроизведённых дефекта исправлены и имеют регрессии. Неразобранных подтверждённых
+  дефектов в рамках этого аудита не осталось. Последние изменения после MIME-прогона — только описания;
+  git diff --check проходит. Для MIME действуют профиль10/10 и ASAN/UBSan/LSan4/4 выше;
+  прежние полные185/186 и sanitizer21/21 не приписываются последующим исправлениям.
+
+Коммиты общей сверки:91fed902 (delivery),8d175049 (encrypted/UI/lifecycle).
+Чек-лист: все media-заголовки и encrypted_attachments.md — [V], общий service_lifecycle.md — [~].
+Windows/FreeBSD, новый полный check и интерактивные GUI/Android проверки не выполнялись.

doc/member_files.txt

@@ -0,0 +1,380 @@
+Файлы участников CHAT-группы
+===========================
+
+Модуль: src/member_files/. Desktop-браузер: tools/chatgui/src/member_files/.
+Отдельный сервис router ETCP_RT_ID_MEMBER_FILES (0x39), отдельно от вложений
+сообщений media_delivery и E2E-файлов DM. Серверы выбираются явно; между
+серверными деревьями автоматической репликации нет.
+
+Хранение и конфигурация
+----------------------
+
+Корень по умолчанию: <db_path>/member_files/ (без db_path — ./member_files/).
+Публичное дерево: <корень>/<group_id>/<node_id>/<относительный путь>.
+Временные файлы: <корень>/.uploads/<upload UUID в hex>.
+При старте сервис создаёт/открывает корень в дисковом worker, удаляет старые
+незавершённые temp и сканирует опубликованные файлы. До готовности отвечает BUSY.
+Ошибка сканирования оставляет локальное хранилище недоступным до restart;
+частичные счётчики клиенту не выдаются. Клиентские передачи к другим серверам продолжают работать.
+Очистка кэша вложений media/ это дерево не обходит.
+
+Настройки [chatserver] / [chat]:
+  member_files_enabled=1
+  member_files_user_quota_mb=1024
+  member_files_upload_ttl_sec=3600
+  member_files_path=/путь/к/хранилищу  (опционально, до 255 байт UTF-8)
+
+Путь, квота и TTL читаются при старте чат-сервиса; изменение требует его restart.
+enabled проверяется на каждом запросе. Лимит одинаков для каждого UID отдельно,
+размер UID суммируется по всем группам на этом сервере. Значение в МиБ (1024*1024 байт).
+Счётчики used/reserved/files/directories хранятся в памяти дискового worker и восстанавливаются с диска только при старте.
+Каталоги не занимают байтовую квоту. files/directories считают опубликованные файлы и каталоги внутри деревьев UID
+по всем группам; корни групп, корни UID и .uploads исключены. Пустой опубликованный файл считается файлом.
+Сохранённые файлы удалённых участников также занимают квоту.
+При начале загрузки резервируется размер нового файла или положительный прирост при замене.
+WRITE не изменяет used; COMMIT обновляет used на разницу размеров и освобождает резерв.
+ABORT/Cancel/TTL освобождают резерв после удаления temp; REMOVE вычитает размер файла.
+Переименование внутри UID не меняет размер и числа объектов. Новый COMMIT увеличивает files на 1;
+замена существующего файла, включая нулевой размер, сохраняет files. MKDIR увеличивает directories на 1,
+REMOVE уменьшает соответствующий счётчик. Для mkdir учитывается факт создания даже при последующей ошибке sync.
+BEGIN/WRITE/ABORT/Cancel/TTL не увеличивают files: temp не опубликован.
+Все изменения корректируют счётчики инкрементально, без обхода каталога пользователя;
+QUOTA только читает их из памяти. LIST выполняет свой обычный обход для отображения записей, не пересчитывая статистику.
+Повторы BEGIN/COMMIT/MKDIR/REMOVE не меняют учёт повторно.
+Уже превышенная квота не удаляет данные: чтение, удаление и уменьшение файла доступны,
+новый положительный прирост запрещён. Физический temp может занимать больше места,
+чем резерв прироста; нехватка места файловой системы остаётся отдельной I/O-ошибкой.
+Нехватка квоты/места возвращает NO_SPACE; опубликованные файлы не вытесняются.
+Общая member_files_quota_mb удалена. Корень обслуживается только файловым сервисом;
+ручные изменения требуют повторного сканирования через restart.
+
+Сервер — действующий полный мембер группы с подписанным adm_tags.storage="yes".
+Колонка peers.storage — производный сетевой приоритет, для полномочий не используется.
+Каждый запрос и ответ подписаны Ed25519 и зашифрованы end-to-end средствами
+route_crypto. group/src берутся только из проверенного заголовка router;
+ETCP peer промежуточного хопа не считается автором запроса.
+Читать могут действующие участники той же группы. Изменять дерево может только
+src == owner. Удалённые записи и source=1 (плейсхолдеры) доступа не дают.
+Открытый fd/UUID загрузки не отменяют повторную проверку членства.
+Файлы удалённого участника сохраняются на диске, но через сервис не доступны.
+
+Wire, версия 4
+--------------
+
+Все числа LE, без сырых структур и padding. Фиксированный заголовок 125 байт:
+  0      protocol_version:u8 = 4
+  1      kind:u8 (1=request, 2=response)
+  2      command:u8
+  3      status:u16 (request=0)
+  5      request_id:u64, ненулевой случайный ID
+  13     owner:u64 (UID каталога; 0 только для LIST виртуального корня группы)
+  21     offset:u64
+  29     size:u64
+  37     cursor:u64
+  45     version:16
+  61     upload:16
+  77     hash:32
+  109    mtime:u64, Unix seconds
+  117    type:u8 (1=file, 2=directory)
+  118    more:u8 (0/1)
+  119    path_len:u16
+  121    target_len:u16
+  123    data_len:u16
+После заголовка: path[path_len], target[target_len], data[data_len], без NUL.
+Длина пакета обязана точно совпадать с указанными размерами.
+Путь максимум 1024 байта, компонент максимум 255 байт, максимум 60 компонентов.
+Данные максимум 8192 байт; вместе с полным router-путём и crypto укладываются
+в лимит normalizer 16384 байта. Размер файла/смещение ограничены INT64_MAX.
+Пути — строгий UTF-8, относительные, разделитель '/'. Запрещены пустые компоненты,
+компоненты с ведущей '.', завершающей точкой/пробелом, управляющие символы,
+Windows device names и символы \ : * ? " < > |. Корень внутри UID — пустой путь.
+POSIX разрешает путь через *at/O_NOFOLLOW; regular-файлы с hardlink отвергаются.
+Windows удерживает родительские каталоги без SHARE_DELETE и не принимает reparse points.
+
+Команды
+---------------
+
+1 LIST: owner/path/cursor/version. Первая страница cursor=0, version=0.
+  Ответ data — записи: name_len:u16,type:u8,size:u64,mtime:u64,version:16,name.
+  cursor — сколько записей уже выдано. more=1 требует следующую страницу с
+  возвращёнными cursor/version. При изменении снимка — STALE, начать сначала.
+  Размер каталога не ограничивает память страницы. Виртуальный корень группы
+  выдаёт UID действующих полных участников, даже если каталог ещё не создан.
+  Изменение namespace сервера консервативно инвалидирует дисковые LIST-курсоры.
+
+2 STAT: owner/path. Ответ type/size/mtime/version. Не хеширует весь файл.
+  version — непрозрачный снимок identity/size/mtime/ctime и эпохи сервера.
+  Закрытие fd по таймауту токен не меняет; restart меняет дисковые токены.
+
+3 READ: owner/path/version/offset/size (1..8192).
+  Ответ size — полный размер файла, data_len — фактически прочитано,
+  more — есть ли байты после ответа. offset==EOF возвращает 0 байт/more=0;
+  offset>EOF — INVALID_RANGE. Изменение файла между блоками — STALE.
+  Клиент не смешивает версии и публикует локальный файл только по завершении.
+
+4 BEGIN_WRITE: owner/path/upload/size/hash/version.
+  upload — 16 случайных байт, size — конечный размер, hash — SHA256 содержимого.
+  version=0 означает создать новый файл, существующий возвращает EXISTS.
+  Для замены требуется версия из STAT/LIST. В один путь одна активная загрузка.
+  UUID привязан к group/src/owner/path; повтор BEGIN с теми же параметрами безопасен.
+
+5 WRITE: owner/path/upload/offset/size/data. size==data_len, диапазон внутри
+  конечного размера. Можно писать в произвольном порядке и повторять блок.
+  ACK подтверждает запись в temp, а не durable публикацию всего файла.
+
+6 COMMIT: owner/path/upload. Проверяет SHA256, fsync/_commit и ожидаемую
+  версию назначения, затем атомарно заменяет файл и синхронизирует namespace.
+  Прежний файл виден до публикации. Ответ содержит размер/версию/SHA256.
+  Незаписанные sparse-области читаются как нули; неправильное содержимое не
+  проходит SHA256. Пустые файлы поддерживаются. При I/O-ошибке во время
+  публикации результат может быть неопределённым; нужно повторно проверить STAT.
+
+7 ABORT: owner/path/upload. Удаляет temp, освобождает резервацию.
+  Неизвестный UUID — OK; опубликованные файлы никогда не удаляет.
+
+8 MKDIR: owner/path. Создаёт один каталог; родители должны существовать.
+9 RENAME: owner/path/target/version. Только внутри UID/группы, без замены
+  существующего назначения. Активная загрузка в затрагиваемом пути — BUSY.
+10 REMOVE: owner/path/version. Файл или пустой каталог, без рекурсивного удаления.
+  Непустой каталог возвращает DIRECTORY_NOT_EMPTY.
+
+11 STREAM_WRITE: открытие потоковой загрузки; поля как BEGIN_WRITE,
+  cursor — ненулевой ID потока. Ответ подтверждает готовность temp и конечный размер.
+12 STREAM_READ: открытие потокового скачивания; owner/path/version/size/cursor,
+  upload — случайный токен клиента. Сервер сверяет снимок и размер перед началом.
+13 STREAM_DATA: request_id — ID потока, owner/path/upload, offset/size/data.
+  kind=request для upload, response для download. Ответа на блок нет.
+  offset обязан равняться следующему принятому смещению; size==data_len, не более 8192.
+14 STREAM_END: ID потока, owner/path/upload, offset==size==размер файла, SHA256.
+  Upload: клиент отправляет END после всех DATA, сервер отвечает END после COMMIT.
+  Download: сервер отправляет END после DATA и повторной проверки версии; клиент
+  проверяет SHA256 записанных данных, синхронизирует и публикует локальный файл.
+  Ошибка сервера приходит END.status!=OK; ошибка открытия — ответом на STREAM_READ/WRITE.
+15 STREAM_CANCEL: клиент отменяет конкретный поток. Поздние DATA не публикуются.
+
+16 QUOTA: owner=UID, path/target пустые, cursor=0, data_len=0.
+  Права чтения те же, что у STAT/LIST выбранного участника. Ответ data_len=40:
+  used:u64, limit:u64, reserved:u64, files:u64, directories:u64, LE.
+  Первые три значения в байтах, последние два — числа объектов. Снимок общий для UID во всех группах.
+  Не резервирует место и не занимает квитанцию мутации. used может превышать limit
+  после уменьшения лимита; сервер не выдаёт фиктивный нулевой размер при ошибке учёта.
+
+Открытие потока — обычный повторяемый запрос с отдельным request_id. cursor связывает
+его с DATA/END/CANCEL. Поток определяется group/peer/kind/ID; один ID не может
+одновременно обозначать разные открытия. Каждый пакет по-прежнему подписан и зашифрован.
+При закрытии/перезапуске router-канала его handles завершаются с IO_ERROR;
+байты разных эпох не смешиваются. Возобновление через новую эпоху пока не реализовано.
+
+Статусы (0..14): OK, ACCESS_DENIED, NOT_FOUND, INVALID_PATH, INVALID_RANGE,
+EXISTS, BUSY, STALE, NO_SPACE, IO_ERROR, BAD_PACKET, HASH_MISMATCH, CANCELLED, TIMEOUT,
+DIRECTORY_NOT_EMPTY.
+Мутации COMMIT/MKDIR/RENAME/REMOVE сохраняют успешный ответ на 120 секунд
+(64 квитанции); тот же request_id с другим содержимым — BAD_PACKET.
+COMMIT дополнительно узнаётся по upload UUID. При заполнении квитанций новая
+мутация возвращает BUSY до истечения старых. Клиент повторяет запрос с прежним
+request_id раз в 5 секунд, общий срок 120 секунд. Повторы после этого срока
+не дают гарантии того же результата; перед новой мутацией требуется STAT.
+
+Потоки, таймауты и остановка
+---------------------------
+
+На экземпляр один дисковый pthread с очередью до 64 обычных задач. Сеть,
+ACL, таймеры и state machines выполняются в uasync; open/stat/readdir/read/write,
+resize/hash/sync/rename/remove/close — в дисковом потоке. GUI только передаёт
+команды через bridge и получает события. Нет вызова дискового I/O из callback
+таймера. Completion резервируется до постановки задачи; без polling workers.
+Локальные файлы transfer и серверное дерево используют тот же дисковый поток.
+Для обязательной очистки резервируется отдельная задача до открытия файла.
+Обращение к своему серверу доставляется через отдельную ограниченную очередь
+call_soon в тот же обработчик, без сетевого канала. ACL и дисковый поток общие;
+сетевой recv не принимает unsigned даже при src == self.
+
+Сервер держит до 64 открытых файлов. Каждый READ/WRITE/BEGIN продлевает idle.
+После 10 секунд простоя fd закрывается на очередном дисковом sweep (таймер 1 с);
+занятый дисковый поток откладывает sweep до освобождения. Закрытие не публикует
+и не удаляет файл. Temp можно открыть заново до истечения upload TTL.
+После restart незавершённые temp удаляются; опубликованные файлы остаются.
+
+Лимиты: 16 клиентских запросов, 32 серверных задания/ответа, 16 временных
+загрузок, 16 клиентских и 16 серверных потоков на экземпляр. Каждый поток имеет
+кольцо 32 x 8192 байт (256 КиБ); worker обрабатывает до 16 блоков за задачу.
+Чтение следующей порции перекрывается с отправкой уже подготовленной.
+Все серверные и локальные I/O используют один FIFO worker, без блокировки uasync.
+
+Отправитель добавляет пакеты, пока send_q router находится под нижним порогом
+(сейчас count<=0), затем ждёт etcp_router_on_send_ready. Файловый слой не устанавливает
+своё окно inflight и не повторяет DATA; транспортные ACK, retransmit и порядок — router.
+Callback отправляет не более 8 блоков за запуск, уступая очередь другим потокам.
+Параллельные файлы одного пира разделяют канал и FIFO/round-robin waiters.
+
+Готовность приёмника проверяется router до доставки следующего seq. Заполненное
+кольцо или очередь заданий оставляют пакет в recv_q: rx_seq/ACK не продвигаются.
+Освобождение места вызывает отложенный resume; pump отменяется при reset/close.
+ACK RECEIVE_BUSY (flags bit0) раз в 100 мс отличает ожидание диска от потери транспорта.
+Отправитель приостанавливает новые DATA, а живые busy ACK продлевают таймаут router.
+Буфер router ограничен его receive window. Локальная доставка использует такую же
+проверку готовности и ограниченный FIFO, а не сеть или отдельные подтверждения.
+
+При остановке сначала отменяются producers/requests и дожидаются все stream cleanup
+continuations; только затем worker освобождает storage. Отмена после уже выполненной
+публикации не удаляет опубликованный файл.
+
+Transfer владеет CM handle до окончания/отмены; DOWN/TIMEOUT handle не освобождает.
+quiesce запрещает новые команды, отменяет таймеры, waiter и запросы; destroy
+вне callbacks дожидается только своих работ/completions и закрывает дисковый
+поток до уничтожения CHAT-групп. Контексты не освобождаются под работающим I/O.
+Отмена не прерывает текущий системный I/O или хеширование, а ждёт его completion.
+
+Desktop
+-------
+
+Контекстное меню канала: Group files. Меню участника: Member files.
+Окно: выбор сервера/UID, путь, Up/Refresh, таблица каталогов/файлов,
+Upload/Download/New folder/Rename/Delete, прогресс и Cancel transfer.
+Чужой UID доступен только для чтения. Автор может быть offline.
+Open скачивает в выбранный пользователем локальный файл и открывает его
+приложением ОС после завершения. Смена контекста отбрасывает поздние ответы.
+Для выбранного UID строка хранилища показывает занято/всего, число файлов/каталогов и резерв текущих загрузок.
+Точные байты доступны в tooltip. QUOTA запрашивается отдельно от LIST при выборе
+сервера/UID, обновлении каталога, завершении передачи и каждые две секунды видимого окна.
+Поздние ответы старого UID/сервера игнорируются. BUSY при стартовом сканировании
+сохраняет Loading directory и повторяет LIST через секунду; новый переход отменяет повтор.
+
+API параллельных передач
+-----------------------
+
+member_files_transfer_start(request, callback, arg) копирует request и возвращает
+отдельный mf_transfer* на каждый файл. upload задаёт направление, group/server/owner
+выбираются для каждой операции. id=0 выбирает случайный ID; id в callback — фактический.
+NULL означает отказ запуска без callback; причина пишется в лог.
+max_bytes=0 оставляет прежний лимит; ненулевое значение ограничивает размер файла.
+Upload проверяет размер источника до хеширования, download — ответ STAT до открытия
+локального temp. STREAM привязан к проверенным размеру/version; превышение — INVALID_RANGE.
+
+callback(arg, mf_transfer_progress*) получает id/done/total/status/finished.
+Прогресс заимствован до возврата callback. done для отправителя означает байты,
+принятые router в очередь; успешный finished подтверждает завершение операции,
+для upload — публикацию на сервере, для download — публикацию локального файла.
+finished приходит ровно один раз, handle к этому моменту уже освобождён;
+вызывающий обнуляет свой указатель в callback. member_files_transfer_cancel(handle)
+отменяет только этот файл, ждёт его I/O и ставит CANCEL в очередь с backpressure.
+Stop сервиса/группы завершает все принадлежащие ему handles.
+
+Все API/callbacks выполняются в uasync-потоке экземпляра. GUI trampolines используют
+тот же API и превращают callback в существующие события прогресса; Qt не делает I/O.
+Один локальный файл назначения не может одновременно принадлежать двум download.
+
+Аватарки пользователей
+---------------------
+
+Относительный путь avatars/<sha256>.<расширение> находится внутри обычного дерева UID:
+<корень>/<group>/<UID>/avatars/<sha256>.<расширение>. Дополнительного UID в API/пути нет.
+Аватарка по умолчанию копируется в каждую группу, где выбранный сервер имеет
+подписанную storage-роль. Ссылка каждого канала публикуется только после COMMIT
+соответствующей копии; отсутствующий сервер в другом канале не создаёт битую ссылку.
+Новое членство обнаруживается через снимки участников и повторяет публикацию.
+Между серверами автоматического копирования нет.
+
+userinfo содержит строковые avatar_server (16 hex цифр) и avatar_file (64 hex SHA256 + .json).
+Оба поля отсутствуют при удалённой аватарке. Профиль подписан ключом участника;
+смена имени/адресов сохраняет остальные плоские JSON-атрибуты. userinfo ограничен
+1024 байтами UTF-8. Merkle, JOIN_INFO_RESP, CHANNEL_INVITE и JOIN_REQUEST используют
+длину userinfo:u16 BE вместо прежнего u8. Bootstrap передаёт существующий подписанный
+профиль инвайтера, не создавая более свежую запись только с именем. Обе стороны
+нужно обновить: обратной совместимости нет.
+
+Снимок участника CHAT_MEMBER_DISPLAY_SIZE теперь 158 байт: прежние 79 байт,
+avatar_server:8LE, avatar_file:70 (с NUL), storage_role:1. storage_role обозначает
+подписанную роль сервера, независимо от существующей колонки storage — сетевого
+приоритета, который может быть 0 у сервера за NAT. Потребители используют общий
+chat_member.h; локальное изменение профиля также вызывает MEMBER_UPDATED.
+
+В Settings → Profile доступны Upload avatar, выбор storage-сервера, предпросмотр
+и Remove avatar. Изменения применяются сразу, независимо от Save других настроек.
+Перед загрузкой desktop/Android показывают редактор: неподвижная квадратная рамка,
+перемещение фото и масштабирование (мышь/колесо или жесты). Отмена не публикует новую ссылку.
+Worker принимает JPEG/PNG/WebP до 32 МиБ и 16 мегапикселей. Исходные байты, включая EXIF,
+сохраняются без изменений. Выбранная область после EXIF-ориентации становится WebP lossy
+256×256, quality=85, максимум 1 МиБ. Описание JSON (максимум 4096 байт): version=1,
+original/preview — имена объектов; original_bytes/preview_bytes, width/height — размеры
+ориентированного оригинала; x/y/w/h — нормализованный квадрат в его координатах.
+Все объекты лежат в avatars/<SHA256 собственных байтов>.<jpg|png|webp|json>.
+Порядок COMMIT: оригинал, превью, описание; затем подписанная ссылка на описание.
+Повтор использует уже сохранённые неизменяемые объекты. Сервер проверяет имя/SHA256,
+лимит объекта и запрещает замену под прежним именем и rename в/из avatars.
+Файлы и каталог входят в обычные квоты. Прежние версии сохраняются на сервере;
+владелец может удалить их через файловый браузер. Старые PNG-ссылки не поддерживаются.
+
+Клик по аватарке сообщения/участника открывает галерею пользователя: LIST каталога
+выбирает только описания, проходит все страницы cursor/version, сортирует mtime DESC,
+при равенстве — по имени. Изначально выбрана текущая подписанная ссылка. Большое фото —
+полный оригинал, до его загрузки показывается превью. Внизу пять квадратных позиций:
+две предыдущие, выбранная по центру, две следующие; за границами списка позиции пустые.
+Desktop: кнопки/клавиши ←/→; Android: кнопки/свайпы при исходном масштабе. Превью кликабельны.
+Загружаются выбранный оригинал и видимые превью; закрытие отменяет запросы без других владельцев.
+Для DM источник — общий канал, из которого берётся отображаемая аватарка.
+
+AvatarManager общий для списка участников и сообщений, максимум две операции
+одновременно, одинаковые хеши не скачиваются параллельно. Изменение своего профиля
+имеет приоритет перед фоновыми загрузками. Для DM используются ссылки из общих
+каналов; при отсутствии доступной ссылки остаются инициалы. Онлайн-статус списка
+отображается отдельной точкой поверх фотографии. Поздний результат старой ссылки
+пополняет кеш, но не заменяет картинку новой ссылки.
+
+Кеш аккаунта: <db_path>/avatar_cache/<local_UID_hex>/<sha256>.<расширение>; без db_path
+используется Qt AppLocalDataLocation. Проверяются SHA256 объектов, описание и WebP 256×256;
+превышение/битая картинка не публикуются. Публикация кеша атомарна через QSaveFile,
+незавершённые download/part очищаются при старте. Готовые файлы не требуют TTL/STAT:
+смена содержимого меняет имя. Дисковый LRU — 100 МиБ, кеш QImage — 32 МиБ;
+собственная аватарка и источники незавершённых upload сохраняются при вытеснении.
+Дисковое I/O и декодирование выполняются вне GUI/uasync. Повторы неудачных загрузок:
+5/10/20/40/80/160 секунд; новая ссылка сбрасывает задержку. RTT/online не меняют ссылку
+и не вызывают повторной загрузки. Желаемая собственная ссылка/удаление сохраняются
+атомарно одной строкой ui_state.avatar_default, незавершённая публикация повторяется
+после запуска при наличии локального источника.
+
+test_avatars проверяет нормализацию, хеш/размеры, очистку temp, настоящее storage
+в двух каналах, публикацию, сохранение при смене имени, DM-кеш, restart без сети,
+автоматический download после потери кеша и удаление ссылок. Также проверяются
+max_bytes до открытия local temp и смена аватарки при задержанном download старой
+версии: поздний результат не заменяет новый рисунок. test_member_adapter проверяет
+подписанные профили 191/255/256/512/1023/1024 байт вместе с adm_tags до 8192.
+Категория media=debug показывает discovery, cache hit/eviction, направление,
+group/owner/server/hash, ошибки проверки и retry; media=info — передачи/публикации.
+
+Проверки и диагностика
+---------------------
+
+tests/test_member_files: wire/UTF-8, произвольные блоки, повторы, EOF, версии,
+короткая замена, SHA256, пустой файл, независимые квоты UID, общий учёт по группам,
+резервирование/повторы/TTL, инкрементальные files/directories, замены пустых файлов,
+создание/удаление/rename каталогов, отсутствие runtime-rescan, стартовый scan и его ошибки, ссылки, expiry/restart, 10-секундный
+fd idle и принадлежность work/done потокам.
+tests/test_member_files_network: настоящие A/B/M, подписанная storage-роль,
+параллельные upload/download одного пира, local loopback, пустые файлы, побайтная
+проверка, отмена одного handle, restart router и destroy с активным server I/O.
+Шестисекундная задержка worker проверяет receive backpressure и busy ACK.
+Также проверяются чужая запись, виртуальный корень и подписанное удаление читателя.
+QUOTA проверяется на настоящем подписанном/зашифрованном канале; удалённый читатель не получает счётчики.
+test_services — stop/start общего чат-сервиса.
+Диагностика файлового сервиса — категория media, маршрутизатора — etcp_route.
+Настройка для полного трасса этих модулей:
+  [debug]
+  media=trace
+  etcp_route=trace
+media=debug показывает запрос/ответ, ACL, очереди файлового сервиса, I/O и fd idle.
+etcp_route=debug добавляет выбор маршрута, состояния канала и ретрансмиты.
+Уровень trace дополнительно показывает каждый
+read/write и передачу задач/завершений между дисковым потоком и uasync.
+stream progress раз в секунду показывает ID/направление, done/total, число блоков
+в кольце, активность I/O, причину ожидания и скорость B/s. Router логирует переходы
+receive paused/resumed и peer receive busy без повторного сообщения на каждый блок.
+quota scan started/ready показывают путь, число пользователей и время обхода;
+quota updated показывает UID/операцию/used/reserved/files/directories; quota exceeded — used/reserved/growth/limit.
+По request_id видны GUI post → core request → router seq → server rx → ACL →
+disk queued/start/done → response tx → GUI result/bridge → directory ready.
+PID создания worker, PID отправки задачи и startup PID позволяют однозначно
+обнаружить fork после создания потока; несовпадение PID логируется как ошибка.
+Ключи шифрования, plaintext файлов и сырые медиа в debug не выводятся.
+Старые VAD/рация/GUI/вложения сообщения перенесены в vad/radio/chat/media/config;
+ошибки и пользовательские info остаются в тематических категориях.

doc/message_links.md

@@ -0,0 +1,36 @@
+# Ссылки в сообщениях
+
+Android и Qt распознают `http://`, `https://` и `utun://` в обычном тексте
+личных и групповых сообщений. HTTP/HTTPS нечувствительны к регистру схемы.
+Ссылки выделяются цветом и подчёркиванием; длинные веб-адреса переносятся по ширине.
+Сокращённая строка структурированного PM-приглашения сохраняет полный `utun://` адрес.
+
+Пробелы, управляющие символы, кавычки и угловые скобки отделяют ссылку от текста.
+Конечные `. , ; : ! ?` и лишние закрывающие скобки удаляются из распознанного адреса.
+Сбалансированные скобки в адресе, параметры, fragment и Unicode сохраняются.
+Адреса без схемы не распознаются. Некорректные веб-адреса остаются обычным текстом.
+Исходное сообщение в БД и протоколе не меняется.
+
+Разборщики возвращают диапазоны UTF-16 и полные адреса:
+`tools/chatgui/src/message_links.cpp`, Android `data/MessageLinks.kt`.
+Подсветка и нажатие используют эти диапазоны. Android подставляет emoji placeholders
+только в обычный текст между ссылками: emoji внутри адреса остаётся частью полного URL.
+Qt использует один QTextLayout для размеров, отрисовки, выделения и координат нажатия.
+Перетаскивание выделяет текст без открытия ссылки.
+
+HTTP/HTTPS открываются из GUI системным обработчиком: Android `ACTION_VIEW`,
+Qt `QDesktopServices::openUrl`. `utun://` запускает существующий JOIN.
+Ошибки открытия показываются через перевод интерфейса и логируются.
+Диагностика открытия содержит схему и host, без полного пути/query.
+
+Общие случаи: `tools/chatgui/tests/message_links_cases.tsv`.
+Qt `test_invite_links` проверяет разбор, перенесённые веб-ссылки, смесь схем,
+нажатие, drag/copy и сокращённые приглашения; `test_emoji_playback` — жесты приглашений.
+Android `tests/test_message_links.kt` проверяет тот же TSV на классах из APK-сборки:
+
+```bash
+cd tools/chatgui-android
+./build.sh noinstall
+kotlinc tests/test_message_links.kt -classpath app/build/tmp/kotlin-classes/debug -d /tmp/message-links-tests.jar
+kotlin -classpath /tmp/message-links-tests.jar:app/build/tmp/kotlin-classes/debug Test_message_linksKt ../chatgui/tests/message_links_cases.tsv
+```

doc/nat_detection.txt

@@ -0,0 +1,146 @@
+Как работает детектор NAT
+========================
+
+Детектор выясняет две вещи: какой внешний IP:порт получает рабочий UDP-сокет
+при обращении к разным IP и проходят ли к нему пакеты от незнакомого IP.
+Проверяется именно сокет, через который работает приложение.
+
+Есть быстрый путь без помощников: если рабочий сокет принял подключение
+и локальный IP и фактический IP подключившегося узла публичные,
+ему сразу ставится direct/open (UNCHANGED + OPEN). Это правило действует
+для UDP и TCP, даже если с IP пира раньше уже был исходящий обмен.
+Локальные подключения и SOCKS интернет-вход не подтверждают. Для TCP
+фактический локальный IP должен совпадать с IP интерфейса сокета.
+
+Нужны три узла: A проверяет себя, B наблюдает его внешний адрес,
+C помогает проверить входящие пакеты. Команды и результаты передаются
+по уже работающей сети uTun, в том числе через TCP или промежуточные узлы.
+Сами тестовые пакеты идут напрямую по UDP.
+
+Порядок проверки
+---------------
+
+1. A отправляет пакет узлу B. Тот сообщает, с какого IP:порта его получил.
+   Ответ идёт по управляющему соединению, поэтому блокировка прямого
+   UDP-ответа не мешает узнать внешний адрес A.
+
+2. Через B узел A просит C отправить несколько пакетов на этот внешний адрес.
+   До этого A не должен отправлять ничего на IP узла C с проверяемого сокета.
+   Приложение хранит историю таких отправок и учитывает новые во время проверки.
+   На входящие тестовые пакеты A автоматически не отвечает.
+
+3. Получатель проверяет настоящий адрес отправителя каждого тестового пакета.
+   Локальный или другой непубличный IP не подходит для интернет-проверки.
+   Для проверки незнакомого входа также не подходят IP узла B, собственный
+   внешний IP узла A и IP, на который A уже отправлял пакеты.
+   Если помощник не подходит, A выбирает другого. Разные узлы с одним IP
+   не считаются разными источниками. Проверяются также подлинность пакета
+   и принадлежность текущей попытке, чтобы чужой или старый пакет не влиял на результат.
+
+4. Затем A сам отправляет пакет C и узнаёт, какой внешний IP:порт видит C.
+   Если входящие до этого не проходили и внешний адрес совпал с увиденным B,
+   C повторяет отправку с того же IP:порта на исходный внешний адрес A.
+   Так проверяется, открыл ли исходящий контакт путь для входящих.
+   Параллельный обмен с B подтверждает, что UDP-связь в целом работает.
+
+5. A повторяет измерение внешнего адреса через B и C. Результат принимается,
+   только если адрес для каждого направления остаётся стабильным.
+   Сравниваются разные IP назначения; другие порты того же IP не проверяются.
+
+Что означает результат
+----------------------
+
+strict — B и C стабильно видят разные внешние IP:порты узла A.
+Единого внешнего адреса для подключения с любого IP нет.
+
+eim open — B и C видят одинаковый внешний IP:порт, и пакет от C пришёл
+ещё до исходящего контакта A с его IP.
+
+eim filtered — внешний IP:порт одинаковый, серия пакетов до контакта не прошла,
+а после исходящего контакта пакеты с того же адреса C начали приходить.
+Это оценка: потерю UDP-пакетов нельзя абсолютно отличить от блокировки.
+
+EIM? — два направления видят одинаковый внешний IP:порт, но незнакомый вход
+проверить не удалось, например все доступные помощники уже были знакомы.
+Это EIM с неизвестной доступностью входящих, без обещания открытого входа.
+Такой же предварительный EIM? дают два STUN-сервера, видящие одинаковый внешний
+IP:порт тестового сокета на том же локальном IP и интерфейсе. Поддержка запроса
+с незнакомого IP для этого не нужна. Источник оценки — STUN, вход остаётся UNKNOWN.
+Измерение рабочего сокета имеет приоритет; STUN-оценка действует до пяти минут
+и обновляется автоматически. Публичный порт для подключения берётся только
+из наблюдения рабочего сокета: внешний порт STUN в него не подставляется.
+
+Если внешний IP:порт совпадает с локальным, отдельно отмечается отсутствие
+трансляции адреса. Доступность входящих всё равно проверяется.
+
+Если данных недостаточно, соответствующая часть результата остаётся UNKNOWN.
+Известный тип NAT можно сохранить, даже если входящие проверить не удалось.
+Таймаут и отсутствие подходящих узлов сами по себе не означают strict.
+
+Если один пир уже увидел публичный IP:порт, отличный от локального, этот адрес
+сразу сохраняется как NAT с type=UNKNOWN. Он публикуется отдельно от адреса
+интерфейса и остаётся кандидатом для пробного подключения: одного наблюдения
+недостаточно, чтобы обещать тот же адрес для других IP или открытый вход.
+Уже знакомый помощник пригоден для измерения типа NAT, хотя проверить незнакомый
+вход через него нельзя. Потеря результата входящих не останавливает сравнение
+адресов через доступные публичные узлы; ожидание одного этапа ограничено по времени.
+Измеренный mapping сохраняется сразу, а проверка незнакомого входа продолжается
+через остальных помощников. Порядок обхода фиксирован на его начало; фактический
+source всегда проверяется по актуальной истории. При паузе по общему бюджету
+незавершённая попытка повторяется с новыми идентификаторами, без сброса обхода.
+Если попытка уже получила полный бюджет, его исчерпание считается таймаутом:
+обход переходит дальше, а не повторяет одного помощника бесконечно.
+Старый сохранённый результат входящих не считается успехом новой проверки.
+
+Соединения по LAN работают независимо и не сбрасывают интернет-профиль.
+Если доступны только локальные узлы, измерить тип интернет-NAT для UDP нельзя.
+STUN на другом порту даёт предварительную оценку типа NAT для того же IP/интерфейса.
+Работа TCP не заменяет проверку UDP.
+
+Для TCP определяется только наличие NAT. Непубличный локальный IP сразу означает
+NAT с неизвестным типом. Если локальный IP публичный, достаточно одного публичного
+TCP-пира: по готовому защищённому соединению он сообщает увиденный IP.
+IP совпали — трансляция IP не обнаружена; отличаются — NAT есть, тип UNKNOWN.
+Порты при сравнении не учитываются. Публичный внешний IP сохраняется с портом 0:
+входящий порт неизвестен, поэтому NCD не использует эту запись для подключения.
+Активных проб типа NAT и TCP-входа нет; OPEN устанавливается по принятому
+публичному подключению и сохраняется при последующих совпавших наблюдениях IP.
+Через SOCKS внешний IP прокси
+не записывается как собственный адрес.
+
+Управляющий обмен и ресурсы
+--------------------------
+
+Команды идут через сервис NAT_DETECTION ETCP-router с подписью и шифрованием.
+Используются узлы группы с рабочим маршрутом через READY-соседа; это не требует
+прямого UDP-соединения A с C. CHAT-допуск требует полной неудалённой записи участника.
+Источник и группа берутся из проверенного заголовка router, а не из next hop.
+
+Версия управляющего формата — 4. Основное сообщение занимает 117 байт:
+10 однобайтовых полей команды/сокетов/этапа/результата, шесть uint64
+(owner, generation, round, token, observer, helper), uint16 timeout_ms
+и три адреса по 19 байт (target, primary, observer_address).
+RECHECK занимает 23 байта: cmd, command, version, socket_id и адрес 19 байт.
+Многобайтовые числа кодируются вручную в big-endian; адреса — route_ping_addr_encode.
+Это размеры сообщения после служебного заголовка router. Приём требует точного
+размера; старые generation/round/token и чужие делегирования результата отклоняются.
+
+Детектор работает с шагом 100 мс. Помощник отправляет до трёх проб на этап;
+таймаут одной пробы — не меньше секунды и не меньше четырёх RTT наблюдателя.
+Общий бюджет обхода — 30 секунд; незавершённый обход может продолжиться после паузы.
+Полный результат перепроверяется через 30 минут, неполный — через 30 секунд.
+Повтор по неудаче подключения ограничен одним запросом за пять минут на endpoint.
+Сохранённый успешный ETCP-профиль не истекает по таймеру; изменение endpoint его сбрасывает.
+
+История исходящих хранит до 256 IP для каждого локального endpoint (IP:порт).
+Она сохраняется в SQLite. Переполнение или ошибка загрузки/записи помечают историю
+неполной: UNKNOWN сохраняется до достоверного измерения, OPEN по незнакомому входу
+с неполной историей не подтверждается. Кеш наблюдений ограничен 128 записями,
+одновременно выполняется не более 64 задач помощи.
+
+Детектор владеет таймерами, подписками и изолированными probe_only UDP-сокетами.
+Эти сокеты не публикуются как рабочие адреса. Их отдельное удаление снимает ссылку
+в состоянии родителя, отменяет зависимые пробы и допускает обычный последующий teardown.
+Ошибка регистрации любой подписки или начального таймера отменяет весь запуск.
+Ядро сохраняет контекст в instance->nat_det; останавливает его до ETCP/router
+и обнуляет поле после destroy. Уничтожать ядро из callback детектора нельзя.

doc/node_snapshot.md

@@ -0,0 +1,118 @@
+# Подписанная запись узла
+
+`TOPO_NODE.timestamp` — версия всей подписанной записи, а не отдельного адреса.
+Узел-владелец назначает Unix microseconds, строго больше предыдущей сохранённой
+версии. Имя, тип, активность, адреса, метаданные сокетов, REALITY и подпись
+заменяются вместе. Timestamp входит в подпись. Групповые пути и подсети
+остаются в `TOPO_GROUP_NODE` и не являются частью общей записи узла.
+
+В NODEINFO секции подсетей присутствуют только при `TOPO_FLAG_SEND_SUBNETS`.
+Без флага оба счётчика подсетей равны нулю; противоречащий этому заголовок отклоняется.
+Parser проверяет точную длину пакета и проходит все присутствующие секции независимо
+от запрошенных `out_*`: например, `out_subnets=NULL` отключает создание объектов подсетей,
+но сохраняет проверку префиксов и правильное положение следующего hop-list.
+Выходы выдаются только после полного успеха; при ошибке они обнулены, частичные объекты
+освобождены. Подпись и допустимость пути проверяются после структурного разбора.
+
+Получатель проверяет подпись до изменения реестра или маршрутов. Более свежая
+запись заменяет старую целиком, включая пустые списки адресов. Старые записи
+игнорируются; разные подписанные записи с одинаковым timestamp — конфликт.
+Повторное BGP-объявление может обновить путь, но не содержимое общей записи.
+8-битный `ver` сохраняется как диагностический счётчик; свежесть определяется
+только timestamp.
+
+Локальный узел группы готовится до удаления прежнего `local_node`: сравниваются сами адреса
+и префиксы подсетей, включая замену при прежнем количестве. При отказе памяти, подписи или
+конфликте IPv4-маршрутов прежние узел и маршруты сохраняются. Подсети CHAT не публикуются.
+`topo_group_update_my_nodeinfo` возвращает число IPv4-подсетей, для CHAT — 0, при ошибке — -1;
+рассылку подготовленного NODEINFO выполняет вызывающий.
+
+Живая телефонная занятость передаётся без изменения структуры NODEINFO: в существующем
+`flags` бит `0x04` означает известное состояние, `0x08` — занятость звонком.
+Это групповые флаги `TOPO_GROUP_NODE.phone_status`, как флаг рации `0x02`;
+они не входят в подпись общей записи и используются только для цвета трубки в GUI.
+Без разрешения Android, при выключенной публикации и после ухода узла статус неизвестен.
+Решение о начале вызова принимает адресат по локальному состоянию ОС, а не по BGP-подсказке.
+Изменения публикуются обычной новой версией NODEINFO во всех CHAT-группах; отдельного опроса и таймера нет.
+
+Профиль endpoint в SOCKMETA содержит независимые `mapping` и `inbound`, источник `source`.
+ID и время измерения не передаются: последний успешный профиль действует до
+явного изменения endpoint или подтверждённого нового результата. Повторная
+проверка с тем же результатом не меняет NODEINFO. Все поля SOCKMETA — отдельные байты;
+границы списков metadata/адресов/REALITY также входят в каноническую подпись.
+Алгоритм и условия неопределённости описаны в `doc/nat_detection.txt`.
+`source=ETCP` обозначает результат детектора рабочего endpoint. Одно UDP-наблюдение может дать
+адрес `TOPO_ADDR_NAT` при `mapping=UNKNOWN`, `inbound=UNKNOWN`: это NAT-кандидат
+для пробного подключения, а не адрес интерфейса или подтверждённый открытый вход.
+Общий внешний адрес подтверждает EIM; strict не публикует универсальный NAT-адрес.
+Source входит в подпись; SOCKMETA занимает 5 байт. `source=STUN` означает предварительный
+EIM? для того же локального IP/netif с неизвестным входом; измерение ETCP приоритетно.
+Владелец снимает STUN-оценку после TTL. Внешний адрес тестового порта не публикуется:
+NAT-кандидат по-прежнему требует наблюдения рабочего сокета.
+Для TCP достаточно одного публичного пира: внешний IP с неизвестным входящим
+портом публикуется как `TOPO_ADDR_NAT` с `port=0`, `mapping=UNKNOWN`, `inbound=UNKNOWN`.
+NCD пропускает нулевые порты. Непубличный локальный TCP IP сразу означает NAT;
+совпавший с наблюдением публичный IP даёт UNCHANGED без подтверждения открытого входа.
+
+Таблица `node_snapshots` хранит полную сериализованную запись без группового
+окружения. `node_addresses` остаётся проекцией для поиска и отображения, а не
+источником для восстановления подписанной записи. При наличии сохранённого
+snapshot загрузка использует его. Локальная публикация сохраняется до рассылки;
+ошибка сохранения не разрешает публикацию новой версии.
+
+В проекции адресов сохраняются `nat_mapping`, `nat_inbound`, `nat_source`, `address_kind`.
+Уникальность определяется endpoint и видом адреса,
+а не отображаемым классом NAT. Старый производный формат пересоздаётся;
+bootstrap-загрузка без подписанного snapshot не подтверждает NAT-профиль.
+Такая загрузка требует хотя бы одного адреса; отказ SQL/памяти освобождает все частичные списки
+и возвращает NULL. Наличие валидного snapshot с пустым списком адресов, напротив, допустимо.
+При удалении старых `nat_evidence`/`nat_checked` адреса и REALITY сохраняются для bootstrap,
+старые профили сбрасываются, сериализованные snapshots инвалидируются.
+Максимальные timestamp snapshots сохраняются, чтобы новая локальная публикация
+не откатывала версию даже при коррекции часов. Чат и ключи миграция не изменяет.
+
+Timestamp 0 обозначает bootstrap-сведения без подписи (конфиг, приглашение,
+начальные адреса). Они могут помочь установить первое соединение, но не
+заменяют принятую подписанную запись. По BGP принимаются подписанные записи
+с ненулевым timestamp. Формат NODEINFO изменён без обратной совместимости.
+
+После принятия BGP-записи `node_conn_direct_update_node` применяет адреса к
+существующему NCD-соединению. Отсутствующее соединение этот вызов не создаёт.
+Путь подготавливается до изменения общего реестра и групповых подсетей: отказ
+памяти сохраняет прежнюю запись, ссылки и пути. После commit IPv4-таблица
+перестраивается для этого узла, включая удаление старых подсетей при пустом
+новом наборе. Конфликт подсетей или OOM установки маршрутов логируется,
+новый набор не устанавливается, прежние маршруты удаляются; ошибка запрещает
+READY сессии. Принятая подписанная запись и пути при этом могут сохраниться.
+Линки дополняются как при UP, так и до установления соединения; повторная
+доставка не создаёт дубликаты UDP/TCP. Работающие линки не закрываются только
+из-за смены списка адресов. NCD удерживает ссылку на общую запись, пока
+обслуживает соединение, и использует её при восстановлении.
+
+`node_conn_direct_open_node` сверяет переданную запись с реестром/БД. Более
+свежая подписанная запись принимается целиком, старая уступает уже известной.
+Bootstrap-адреса не перекрывают подписанную запись даже при DOWN.
+
+Конфигурационные подключения UTUN используют один адаптер
+`init_client_connections` для старта и reload. Все адреса, TCP и REALITY
+передаются NCD; адаптер не создаёт ETCP-линки. Новый набор handles открывается
+до освобождения старого; при ошибке старые handles сохраняются. Конфигурация
+удерживает один handle на клиента, независимо от количества его адресов.
+
+Включение конфигурационного пира в UTUN-группу выполняет callback NCD UP.
+Само событие транспортного UP не включает соединение в UTUN-группу автоматически.
+Входящий JOIN остаётся явным запросом
+участия. При пересоздании UTUN-группы учитываются её конфигурационные handles.
+Удаление клиента отправляет `LEAVE_GROUP` и освобождает удержание UTUN-группы
+с обеих сторон. Другие владельцы NCD сохраняют транспорт. Поздние NODEINFO и
+WITHDRAW от отсоединённого UTUN-пира игнорируются, чтобы не вернуть его маршруты.
+LEAVE ждёт backpressure через queue waiter и временно удерживает собственный
+NCD handle. Закрытие транспорта отменяет ожидание; новое участие в группе
+делает ожидающий LEAVE устаревшим, и он не отправляется.
+Причина удаления пира передаётся явно: только потеря транспорта запускает
+recovery каскадных маршрутов. Локальный/удалённый LEAVE и удаление битой
+member-записи не должны восстанавливать намеренно закрытое участие.
+
+REALITY использует полное SNI до 255 символов; размер поля в записи узла
+согласован с транспортом. Если локального TCP listen-сокета нет, NCD может
+создать исходящий TCP-линк с выбором локального адреса операционной системой.

doc/pm.txt

@@ -0,0 +1,12 @@
+Работа лички
+
+1. отдели логику лички от логики групповых чатов. не смешивай.
+
+Работа лички. сообщения и медиа доставляется напрямую если узел доступен через bgp.
+если недоступен - то pending сообщения сохраняются на суперузле и pending media сохраняется на каком-либо медиаузле, а суперузлу сообщается где хранится медиа.
+при появлении пира суперузел организует доставку медиа до получателя. после успешной доставки медиа/сообщений они удаляются с промежуточных узлов.
+
+время хранения медиафайлов на промежуточных узлах ограничено - 1 неделя по умолчанию (задачется в конфиге этих узлов).
+для доставки медиа поднимаем линк (conn_mgr).
+
+и посмотри реализацию медиа для групповых чатов.

doc/pm_invites.md

@@ -0,0 +1,69 @@
+# Приглашение в группу через PM
+
+В desktop chatgui и Android кнопка «+» доступна в строке другого участника
+и в шапке личной беседы. Она открывает один диалог с фиксированным получателем
+и выбором группы, в которой отправитель состоит. Группа не выбирается автоматически.
+
+После нажатия «Пригласить» клиент создаёт свежую ссылку через `invite_build`,
+ожидает подтверждения регистрации ключа и отправляет PM с `ct="invite"`.
+Зашифрованное тело: `[group_name:UTF8][NUL][полная ссылка:UTF8]`, без конечного NUL.
+Снимок для GUI содержит полную ссылку в `data` и название в `tags.group_name`.
+GUI добавляет заголовок «Приглашение в группу «название»» из перевода интерфейса;
+язык отправителя не фиксирует язык сообщения у получателя.
+Успех означает сохранение сообщения и исходящей задачи в одной транзакции.
+Доставку, повтор и шифрование обеспечивает существующий механизм DM.
+После успешной отправки открывается личная беседа с получателем.
+
+Срок действия ключа — **10 минут с момента последней успешной регистрации на каждом узле**.
+Повторная регистрация того же ключа для того же канала тем же инвайтером продлевает срок.
+Connection-узел сохраняет ключ при обработке регистрации, инвайтер — после её подтверждения;
+при совпадении этих ролей запись одна. Для JOIN ключ должен действовать у обоих.
+Получение PM срок не продлевает. Длительность указана в диалогах отправки и подключения. Поздняя offline-доставка
+может принести уже просроченную ссылку; в этом случае нужно новое приглашение.
+Ссылка не содержит время истечения, поэтому клиент показывает длительность,
+без обратного отсчёта и вычисления оставшегося времени.
+
+Нажатие на `utun://` в сообщении запускает существующий JOIN и показывает его результат.
+Если клиент уже состоит в группе, открывается эта группа. Ссылка приглашения отображается
+одной строкой с многоточием; нажатие и копирование используют полный адрес.
+В Android долгое нажатие копирует ссылку, в desktop выделение сокращённой строки
+копирует ссылку целиком без запуска JOIN. Обычные текстовые PM с вручную
+вставленными ссылками сохраняют текстовое отображение.
+
+## Контракт операции
+
+`dm_invite_trampoline` выполняется в uasync-потоке. Запрос содержит `request_id`,
+ID получателя, выбранную группу и исходную общую группу для создания PM.
+Из шапки существующей PM исходная группа может быть пустой.
+
+На instance допускается одно ожидание регистрации приглашения в PM.
+Повтор во время ожидания возвращает BUSY. Закрытие диалога отменяет только
+соответствующий `request_id`; уже отправленное сообщение не отзывается.
+Отмена и остановка DM завершают принятый запрос ровно один раз.
+
+`CHAT_EVT_DM_INVITE_RESULT` содержит 28 байт:
+`[request_id:u64][result:i32][peer:u64][conv_id:u64]` в порядке байтов ядра.
+Desktop и Android сопоставляют результат с запросом и получателем.
+Ошибки регистрации или сохранения сообщения оставляют диалог открытым для повторной попытки.
+
+JOIN во вторую группу может использовать уже открытый транспорт общей группы.
+Поэтому обработчики JOIN_REQUEST и JOIN_READY явно планируют member_sync,
+а JOIN_READY обновляет кеш каналов до запуска синхронизации.
+
+## Проверка и диагностика
+
+- `tests/test_dm_invite`: настоящая UDP-доставка ссылки в другую группу, JOIN,
+  репликация участника и отправка группового сообщения после вступления;
+  отмена, BUSY, неверная группа, rollback при ошибке commit и остановка DM;
+  передача названия с Unicode, кавычками и переводом строки.
+- `tests/test_chat_join`, `tests/test_chat_join_e2e`, `tests/test_dm_e2e`:
+  существующие сценарии регистрации ключей, JOIN и PM-доставки.
+- Qt `test_invite_links`: одна строка приглашения на разных ширинах, полный адрес
+  при нажатии и копировании, переносы двух обычных ссылок, их полное содержимое при нажатии,
+  выделение текста и выбор получателя кнопкой в строке участника.
+- Qt `test_emoji_playback`: перетаскивание ссылки не активирует подключение.
+
+Для сетевого теста подробности включаются через `UTUN_TEST_DEBUG=1`.
+В приложении полезны категории `dm=debug`, `chat_sync=debug`, `member_sync=debug`.
+Операция пишет request, peer, group, результат и TTL; сообщения диагностики
+новой операции не выводят саму invite-ссылку.

doc/proxy_fix_plan.txt

@@ -0,0 +1,198 @@
+Proxy: исправления и проверка архитектуры
+Дата: 2026-10-24. Статус: реализовано и проверено на Linux.
+Ниже сохранён согласованный проект; фактические изменения и результаты — в конце.
+
+Подтверждённые факты до исправлений
+
+1. udp_proxy.c не проверяет bind/sendto, результат socket_set_nonblocking,
+   часть выделений/регистраций/таймеров и отправку ответа через router.
+   Неудачный запуск flow может оставлять ресурс без рабочего таймера очистки.
+2. server_init и client_create оба запускают общие UDP/ICMP-контексты.
+   client_destroy сохраняет их по server.enabled, server_destroy уничтожает всегда.
+   Простой rollback через destroy одного модуля не выражает владение общими ресурсами.
+3. ICMP init публикует контекст и сообщает успех без raw socket. При этом тот же
+   контекст нужен для клиентских REPLY: отсутствие возможности exit не означает,
+   что клиентская сторона ICMP не может работать через другой exit.
+4. В диагностическом прогоне tcp_io error_cb при HUP отменяет read_waiter,
+   включает чтение и напрямую вызывает read_cb вопреки read_paused.
+   Для fd=15 порог чтения 4; журнал фиксирует read_paused=1 и рост rq до 53.
+   Это нарушение ограничения очереди, а не только избыточная диагностика.
+5. EPIPE/ENOTCONN в HTTPS CONNECT воспроизведены. Системная трасса четырёх TLS-потоков:
+   recv(destination)=0 -> поздняя TLS-запись 24 байта от клиента -> send(destination)=24
+   -> SO_ERROR=EPIPE либо shutdown(SHUT_WR)=ENOTCONN. Повторный shutdown не обнаружен.
+   Определение содержимого зашифрованной TLS-записи по трассе невозможно.
+   Сам по себе этот сценарий не доказывает дефект half-close в proxy.
+6. После удаления exit-потока приходят поздние WINDOW: диспетчер пишет unhandled,
+   хотя это известная команда уже завершённого потока. Создавать поток по WINDOW нельзя.
+7. enabled=yes в серверных тестовых конфигах не поддержан парсером. Сейчас сервер
+   включается при обработке любого параметра секции, включая неизвестный.
+
+Предлагаемая архитектура
+
+Владелец общих UDP/ICMP-контекстов — UTUN_INSTANCE. Их жизненный цикл координируется
+в utun_instance.c после router_init и до router_destroy. TCP client/server управляют
+только своими listeners, TCP-потоками и bindings. Общих счётчиков ссылок не требуется:
+при существующем lifecycle они живут до остановки instance.
+
+Контексты нужны при включённом exit или клиентском TUN; SOCKS/HTTP без TUN их не требуют.
+server.enabled обозначает действующий TCP exit. Роль при запуске ICMP exit должна
+передаваться явно, а не определяться случайным порядком вызовов init.
+При отказе создания клиента rollback освобождает только его ресурсы и собственный binding.
+Повторное создание клиента/сервера поверх активного состояния отклоняется.
+Результат client_create публикуется в inst->tcp_proxy_client только после успеха.
+
+Порядок остановки: клиент и exit-потоки -> общие UDP/ICMP -> router -> drain deferred free.
+При destroy всего instance остановку proxy перенести перед остановкой UTUN-группы,
+разборкой topo_groups и ETCP-сокетов/соединений. Сейчас proxy уничтожается в phase M,
+после topo_groups и транспорта: для нового rollback нельзя сохранять этот поздний порядок.
+Общий instance_init_common уже вызывает instance_destroy при отказе создания;
+нужно использовать этот путь, не добавляя параллельную систему частичной очистки.
+При create_from_config сохранить существующее правило: отказ возвращает config вызывающему коду.
+Ресурсы закрываются в одном uasync-потоке; stop/destroy не вызывается из активного
+callback уничтожаемого владельца. Таймеры/waiters отменяются до освобождения памяти.
+
+Инициализация и ICMP
+
+Разделить создание общего ICMP-контекста/регистрацию REPLY и запуск raw exit socket.
+Это две разные операции: при отказе raw нельзя уничтожать работающую клиентскую сторону.
+Например, icmp_proxy_init создаёт общий контекст, отдельный enable_exit открывает
+raw socket и регистрирует чтение. Новый raw socket публикуется только после полного успеха.
+Обе операции возвращают ошибки непосредственно своему вызывающему коду.
+
+Рекомендуемая политика: EPERM/EACCES/отсутствие поддержки raw явно отключают только ICMP exit,
+с WARN о причине и итогом запуска tcp=on/udp=on/icmp_exit=off. TCP/UDP продолжают работать.
+Ошибки выделения/регистрации обязательных ресурсов прерывают запуск proxy с полной очисткой.
+Если продукт требует обязательного ICMP, отсутствие raw должно быть фатальным на уровне
+конфигурации; это отдельная политика, а не скрытый fallback внутри init.
+В production виртуальные echo-ответы недопустимы. Тестовый loopback выбирается явно
+и должен работать одинаково с правами raw и без них.
+
+Заданные SOCKS/HTTP listeners обязательны: enabled с пустым/неверным адресом либо
+неудачный bind/listen проваливают create. Нельзя вернуть готовый клиент без выбранного входа.
+Проверки router bind оставляем, но при живом inst нынешний bind не выделяет память
+и возвращает 0; не нужно изображать реальные OOM-пути там, где их нет.
+
+UDP и ограниченные ресурсы
+
+Новый flow сначала полностью создаётся локально: socket -> nonblocking -> bind ->
+read registration -> обеспечение expire timer. Только затем добавляется в список.
+Любой отказ снимает уже созданные регистрации/таймеры и закрывает именно новый сокет.
+Если общий таймер не удаётся продлить, оставшиеся flows закрываются с диагностикой:
+состояние без гарантированной очистки не сохраняется.
+
+sendto проверяется по точному размеру. Для нулевой датаграммы n=0 означает успех.
+EINTR допускает повтор операции; EAGAIN/ENOBUFS означает явное отбрасывание датаграммы
+с диагностикой. Не добавляем неограниченную очередь и TCP-подобные повторы UDP.
+Остальные ошибки также логируются с peer, tuple, длиной и errno; packet-specific ошибка
+не должна автоматически уничтожать рабочий flow. Невалидный/сломанный сокет удаляется.
+Проверяются ошибки router send, выделения ответов и доставки в TUN.
+ICMP request тоже не публикуется без рабочего механизма истечения срока ожидания.
+
+TCP HUP, FIN и границы ответственности
+
+FIN относится только к одному направлению и следует после его DATA. Ошибка реальной
+записи остаётся ошибкой даже после FIN противоположной стороны; ENOTCONN не превращается
+в успешный on_fin_sent. Существующая регрессия test_fin_shutdown_error сохраняет этот контракт.
+
+HUP — повод обработать завершение сокета, но не разрешение обойти high_water или явную pause_read.
+При достижении high_water чтение останавливается до low_water. Если level-triggered HUP
+не даёт event loop уснуть, регистрацию сокета нужно временно снять и восстановить по
+queue waiter; простой return с оставленным HUP в epoll/poll создаёт busy loop.
+Нужен один механизм восстановления регистрации в tcp_io, учитывающий connected,
+fin_remote, write_buf, write_queue и уничтожение владельца. Состояние fd/пулы сохраняются
+до окончательного destroy; запланированная запись не должна зависеть от паузы чтения.
+Повторное добавление использует новую generation uasync, старые события игнорируются.
+Явную паузу владельца следует отличать от паузы по high_water; HUP не снимает ни одну.
+
+Это наиболее чувствительный этап: перед реализацией проверить переходы регистрации
+при HUP с ожидающей записью, low_water, обеих FIN и destroy из callback.
+Не менять глобальную семантику всех регистраций uasync ради одного tcp_io-сценария.
+
+Поздние WINDOW/FIN/CLOSE/ERROR для отсутствующего потока игнорируются как события
+завершённого sid с debug-диагностикой. DATA не воскрешает поток, неверное окно живого
+потока по-прежнему является ошибкой. HTTP не обязан ждать FIN для ответа с известной длиной.
+Проверить синхронный loopback: состояние перед отправкой control резервируется заранее;
+после callback с возможным destroy нельзя обращаться к владельцу без проверки его жизни.
+
+HTTPS-тест разделить на нормальное двустороннее TLS shutdown и явный abrupt close.
+В первом случае ожидать отсутствие EPIPE/ENOTCONN; во втором — корректную ошибку,
+сохранность уже доставленного ответа и освобождение ресурсов. Proxy не разбирает TLS.
+Сначала проверить эту гипотезу управляемым тестовым сервером, затем менять fixture.
+
+Проверка после реализации
+
+- Fault injection: socket/nonblocking/bind/read registration/expire timer/sendto/OOM.
+  Проверять отсутствие fd/памяти/таймеров/handlers после каждого отказа и успешный повторный запуск.
+- client only, exit only, обе роли на одном instance, два независимых instance;
+  отказ raw сохраняет ICMP REPLY клиента, остановка одного TCP-модуля не ломает общие контексты.
+- UDP payload=0, краткая/ошибочная отправка, transient error и следующий успешный пакет.
+- HUP при полном proxy window и остановленном consumer: очередь остаётся ограниченной,
+  event loop не крутится, после снятия блокировки все байты и FIN доходят в правильном порядке.
+- pending write при HUP, manual pause, low_water/re-register, destroy в callback и stale events.
+- FIN в обе стороны при backpressure, RST до/после ответа, нормальный/оборванный TLS,
+  поздний WINDOW, синхронный loopback и HTTP keep-alive со сменой sid.
+- Текущие proxy9, test_tcp_io, тесты uasync/queue, затем ASAN/UBSan и полный check.sh.
+  Windows/FreeBSD требуют отдельной проверки poll/select; Linux PASS её не заменяет.
+
+Доказательства исходного анализа
+
+Диагностический test_socks_http_proxy под gdb: PASS, 16 byte-exact загрузок.
+Включены существующие proxy/socket debug через gdb, проектные файлы не менялись.
+Полный журнал: /tmp/proxy-design-debug.log; события lifecycle: /tmp/proxy-design-lifecycle.log.
+Системные вызовы TLS: /tmp/proxy-design-close.744427,
+сводка четырёх соединений: /tmp/proxy-design-close-summary.txt.
+Эти журналы относятся к реализации до исправлений.
+
+Реализация и проверка архитектуры
+
+1. UTUN_INSTANCE единолично создаёт и уничтожает общие UDP/ICMP-контексты. TCP-модули
+   владеют только своими bindings/listeners/потоками. Их rollback не затрагивает общие
+   контексты. Занятой binding не перезаписывается, повторный init TCP отклоняется.
+   Proxy закрывается и deferred free обрабатываются до остановки групп/транспорта.
+2. Все заданные listeners и TUN mappings обязательны. Частичный отказ возвращает NULL
+   и освобождает созданные ресурсы; create_from_config сохраняет config у вызывающего.
+3. ICMP init создаёт контекст/binding, enable_exit атомарно создаёт raw socket/регистрацию.
+   Отсутствие прав/поддержки отключает только ICMP exit с явным WARN. Клиентские REPLY
+   сохраняются; остальные ошибки запуска фатальны. Test loopback включается явно.
+4. UDP flow публикуется после всех обязательных шагов. Отказы создания/продления таймера
+   не оставляют бессрочных flows. Проверяются socket/nonblocking/bind/registration,
+   sendto, ответные выделения/router/TUN. EINTR повторяется, нулевая датаграмма допустима;
+   ошибки пакета логируются без очереди повторов, сломанный сокет закрывается.
+5. TCP HUP сохраняет high/low-water и ручную остановку чтения. Без доступного I/O
+   регистрация временно снимается; low_water восстанавливает её с новой generation.
+   fd/очереди сохраняются; запись обслуживается независимо. Ошибка восстановления
+   регистрации корректно вызывает on_error, включая destroy владельца из callback.
+6. Поздний WINDOW отсутствующего sid отбрасывается с DEBUG. Формат протокола и машина
+   CONNECTED/WINDOW/FIN сохранены. Реальные ошибки записи/SHUT_WR не превращаются в успех.
+   HTTPS fixture теперь завершает TLS двусторонне; abrupt close — отдельный режим.
+7. Неподдержанный enabled в серверных конфигурациях профильных и TUN-тестов заменён
+   поддержанным connect_timeout. Контракты заголовков и документы модулей обновлены.
+
+Проверено:
+- test_proxy_lifecycle: 25/25 изолированных сценариев, контроль fd/памяти/регистраций/таймеров.
+  Покрыты socket/nonblock/bind/registration/timer/OOM, отправка/EINTR/нулевой UDP,
+  частичный отказ instance, повторный запуск, ICMP REPLY после EPERM, HUP re-register,
+  ожидающая запись и destroy из error callback. /tmp/proxy-fix-lifecycle2.log.
+- test_tcp_io: 19/19, HUP high_water=4 на epoll/poll, парковка без busy loop,
+  точная доставка данных и FIN после low_water, ручная пауза и независимая запись.
+- SOCKS/HTTP/HTTPS: оба режима по 16 byte-exact загрузок. Штатный TLS shutdown без
+  EPIPE/ENOTCONN; abrupt сохраняет ошибки TCP без повреждения доставленных ответов.
+  /tmp/proxy-fix-check1/test_socks_http_proxy.log, /tmp/proxy-fix-tls-abrupt.log.
+- Основной make check: 185/185 PASS. /tmp/proxy-fix-full-check2.log.
+  Первый check.sh остановлен общим лимитом 141с; local_transport_packets отдельно PASS.
+  Повтор завершил основной набор, но TUN-этапу помешал чужой процесс на UDP 15002.
+- Те же TUN fixtures и идентичный src/utun выполнены в отдельном network namespace:
+  proxy9/9, burst1/1, load8/8 PASS; load проверил134217728 байт.
+  /tmp/proxy-fix-network-check.log; копия fixtures/логов: /tmp/utun-proxy-fix-network/.
+- Настоящий raw ICMP echo до127.0.0.1 через два ETCP-instance и явный loopback PASS.
+  UTUN_TEST_ICMP_RAW=1 требует raw socket и не переключается на виртуальный ответ.
+  /tmp/proxy-fix-icmp-raw.log, /tmp/proxy-fix-icmp-loopback.log.
+- ASAN/UBSan/LSan: 16/16 PASS с detect_leaks=1, включая оба TLS-режима, lifecycle,
+  tcp_io/flush, пакеты, regressions, HTTP, TCP/UDP/ICMP, services, uasync/queue и STCP.
+  Настоящий raw ICMP дополнительно PASS под теми же санитайзерами с root.
+  Все встроенные зависимости собраны с sanitizer-флагами в отдельной копии текущих
+  исходников /tmp/utun-proxy-fix-sanitizers; обычные объекты проекта не менялись.
+  /tmp/proxy-fix-sanitizer-results.log, /tmp/proxy-fix-sanitizer-icmp-raw.log.
+
+В проверенных Linux-сценариях противоречий владения/rollback/half-close не выявлено.
+Сборка и runtime Windows/FreeBSD не проверялись; Linux epoll/poll не заменяют эту проверку.

doc/proxy_protocol.md

@@ -0,0 +1,200 @@
+# Proxy: TCP, UDP и ICMP
+
+Клиент принимает IPv4 из отдельного TUN через lwIP либо TCP от локальных SOCKS5/HTTP
+listeners. Exit открывает обычный IPv4 TCP/UDP или raw ICMP socket. Вся передача proxy
+идёт через `etcp_route_send` в `TOPO_GROUP_UTUN`, mode=0. Протокол не имеет слоя
+совместимости с прежними форматами.
+
+## Сообщения для router и приёмные метаданные
+
+Это форматы **сервисного API**, а не полные ETCP wire packets. На отправке первый байт —
+svc_id, остальное — payload router. Router callback получает такой заголовок:
+
+| Смещение | Размер | Поле |
+|---|---|---|
+| 0 | 1 | svc_id |
+| 1 | 8 | src_node_id |
+| 9 | 8 | dst_node_id |
+| 17 | 1 | rx_flags |
+| 18 | 8 | group_id |
+| 26 | N | service payload |
+
+Смещения определены `ROUTER_SVC_*_OFF` в `src/routing_layer/etcp_router.h`.
+Заголовок callback имеет размер 26 байт. Сервис освобождает полученные entry/dgram
+при любом исходе. На отправке router принимает владение entry/dgram даже при ошибке;
+0 означает принятие сообщения router, а не доставку конечному TCP/UDP.
+
+TCP-клиент проверяет src_node_id==via_node_id и group_id==TOPO_GROUP_UTUN, включая
+пустые уведомления. UDP/ICMP допускают REQUEST при включённом exit, REPLY — только при
+наличии клиента и совпадении src_node_id с его via_node_id; отдельной проверки group
+в их callback нет. IP, TCP/UDP-порты и ICMP id/seq в proxy API передаются в network
+byte order. TCP stream_id и WINDOW credit копируются как host-order uint32_t:
+формат не нормализован между архитектурами с разным byte order.
+
+## TCP и управление окном
+
+Определения — `src/proxy/proxy_protocol.h`.
+На отправке: `svc:1, cmd:1, stream_id:4, data` (заголовок 6 байт).
+На приёме: router header(26), cmd(1), stream_id(4), data (заголовок 31 байт).
+Клиент отправляет в `ETCP_RT_ID_TCP_PROXY_SERVER=0x04`, exit отвечает в
+`ETCP_RT_ID_TCP_PROXY_CLIENT=0x08`. На exit поток определяется парой peer_node_id/stream_id;
+повторный CONNECT этой пары отклоняется с ERROR.
+
+| Команда | Код | Содержимое после stream_id |
+|---|---|---|
+| CONNECT | 1 | IPv4:4, порт:2 |
+| CONNECTED | 2 | Пусто; exit завершил реальный TCP connect |
+| DATA | 3 | 1..4096 байт |
+| CLOSE | 4 | Пусто; прекращение потока с дренажом принятой записи на exit |
+| ERROR | 5 | Пусто; отмена, на exit немедленно уничтожает TCP и очереди |
+| FIN | 6 | Пусто; конец одного направления после всех его DATA |
+| WINDOW | 7 | uint32_t дополнительного кредита, ровно 4 байта |
+
+Каждое направление начинает с окна 65536 байт. proxy_flow init оставляет ready=0.
+DATA ждёт CONNECTED; SOCKS success и HTTP CONNECT 200 также отправляются только после него.
+Локальный TUN TCP handshake выполняет lwIP и сам по себе connect назначения не подтверждает.
+При отправке DATA списывается tx_credit, при приёме — rx_credit.
+WINDOW допускает только ненулевой кредит без увеличения tx_credit сверх 65536.
+
+Кредит возвращается после потребления локальным TCP: на OS-сокетах после опустошения
+write_queue **и write_buf**, в lwIP после принятия байтов ограниченным send-buffer
+через tcp_write. Это не подтверждение чтения удалённым приложением.
+Для HTTP учитывается число исходных upstream байтов независимо от преобразования
+headers/chunks/trailers; кредит возвращается после доставки соответствующего результата в OS TCP.
+
+Backpressure router и окно потока независимы. При ошибке DATA остаётся в очереди/буфере
+владельца, регистрируется send-ready waiter и safety-net на 500 мс.
+У TCP-клиента с lwIP timer повторяет DATA с force=1, у exit и SOCKS/HTTP — обычный force=0.
+Force обходит лимит send_q router, но никогда не окно proxy.
+При отсутствии CONNECTED/кредита (-2) отправка ждёт ready/WINDOW, а не только router waiter.
+
+OS TCP сохраняет ограничение read_high_water и явную остановку чтения при HUP.
+Если HUP не оставляет работы для чтения/записи, tcp_io временно снимает регистрацию fd;
+low_water восстанавливает её с новой generation. Сокет и очереди сохраняются, запись
+обслуживается независимо от чтения. Ошибка повторной регистрации закрывает соединение.
+
+## Half-close и удаление потока
+
+Владелец выставляет fin_pending только после отправки всех исходящих DATA.
+proxy_flow не видит очередей владельца и сам это условие не проверяет.
+FIN не должен ждать записи противоположного направления: обе половины независимы.
+Приём FIN ставит FIN-маркер после ранее принятых DATA в OS write_queue; в lwIP FIN
+откладывается до дренажа to_lwip и успешного tcp_shutdown.
+
+Окончательное закрытие сырого TCP наступает после обоих FIN и необходимых локальных
+очередей/shutdown. Дополнительный обмен CLOSE при штатном half-close не требуется.
+На exit CLOSE паузит чтение, отбрасывает непрочитанный read_queue и закрывает сокет
+после принятой write_queue; ERROR уничтожает поток сразу. На клиенте CLOSE/ERROR
+прекращают поток; HTTP вне туннеля дополнительно проверяет завершённость ответа.
+
+Общий retry повторяет pending CONNECTED → WINDOW → FIN через 5000 tb (500 мс),
+используя force=1. CONNECT/CLOSE/ERROR в эту очередь не входят.
+Клиентский close_pending может повторяться в poll/free пока поток жив; сервер после
+ошибки TCP удаляет поток и делает попытку ERROR. Гарантированного повторения CLOSE/ERROR
+после освобождения владельца нет.
+Поздний WINDOW отсутствующего потока отбрасывается с debug-диагностикой, без создания потока.
+
+Router close/restart уведомляет сервис entry длиной 26 байт без payload.
+Proxy называет это CLOSE_ALL: exit удаляет потоки указанного peer, клиент — все свои
+TUN/SOCKS/HTTP потоки к настроенному exit. Это не самостоятельная подкоманда или
+9-байтовый пакет на проводе.
+
+## SOCKS5 и HTTP
+
+SOCKS реализует CONNECT к IPv4 или DNS-имени, метод аутентификации 0 (no auth).
+IPv6 отклоняется с REP=8; BIND и UDP ASSOCIATE не реализованы.
+DNS выполняется асинхронно на ingress, выбирается первая A-запись.
+Совмещённые и разделённые greeting/request/data сохраняют непрочитанный хвост.
+Ошибка DNS/connect до успеха даёт SOCKS REP=4 либо HTTP 502.
+
+HTTP/1.0–1.1 forward proxy требует absolute http:// URL; upstream получает origin-form,
+Host из URL и Via. Обычный запрос отправляется как HTTP/1.1 с Connection: close,
+кроме Upgrade. Frontend HTTP/1.1 может сохранять keep-alive: каждый запрос получает
+новый stream_id/upstream, pipelining обслуживается последовательно, включая разные цели.
+Новый stream начинается после доставки полного ответа и отправки CLOSE/ERROR старого.
+
+Codec проверяет headers до пересылки, поддерживает Content-Length, chunked
+с extensions/trailers, промежуточные ответы, HEAD/204/304 и тело до EOF.
+Hop-by-hop и proxy authentication поля удаляются, framing/Connection строятся заново.
+HTTP/1.0 получает декодированное chunked тело и закрытие. CONNECT ждёт полного блока
+headers и реального CONNECTED; согласованный 101 переводит соединение в сырой туннель.
+Ранний final response прекращает upload и требует закрытия клиента.
+Ошибка до final headers может дать собственный HTTP error; после них закрывает оборванный ответ.
+
+Лимиты: headers/trailers 32 KiB, start line и chunk/trailer line 8 KiB, 512 header fields.
+CL+TE, разные Content-Length, obs-fold, управляющие байты и неверные порты отклоняются.
+Поддержан только transfer coding chunked; HTTP IPv6-назначения отклоняются с 502.
+Headers имеют deadline 30 с, DNS/connect — 15 с, передача/idle/дренаж закрытия — 60 с.
+Deadline headers не продлевается каждым байтом. Установленные CONNECT/Upgrade-туннели
+используют TCP lifecycle без HTTP deadline. Детали codec — в `src/proxy/http_proxy.h`.
+
+## UDP и ICMP
+
+Контексты принадлежат конкретному UTUN_INSTANCE. REQUEST=1, REPLY=2.
+На отправке UDP: `svc:1, cmd:1, src_ip:4, src_port:2, dst_ip:4, dst_port:2, payload`.
+ICMP: `svc:1, cmd:1, dst_ip:4, orig_src_ip:4, echo_id:2, echo_seq:2, payload`.
+Заголовки отправки — 14 байт, приёма — 39. Отдельного sender_node_id в payload нет.
+
+UDP exit создаёт сокет на tuple client_node_id/src_ip/src_port/dst_ip/dst_port,
+проверяет источник ответа, меняет src/dst местами в REPLY. Удаляет неактивные flows
+при очередной периодической проверке с порогом >60 с. Клиент восстанавливает IPv4 checksum,
+UDP checksum=0 (допустимо для IPv4).
+Flow публикуется только после socket/nonblocking/bind/read registration и создания
+таймера очистки. Ошибка продления общего таймера закрывает оставшиеся flows.
+sendto проверяется по точной длине, включая успешный нулевой payload; EINTR повторяется.
+EAGAIN/ENOBUFS и ошибки отдельного пакета логируются без очереди повторов; сломанный
+сокет удаляется. Ошибки выделения ответа, router send и доставки в TUN диагностируются.
+
+ICMP exit использует один raw socket; заменяет id/seq token и сопоставляет
+wire_id/wire_seq/IP цели с pending. Исходные id/seq восстанавливаются для клиента.
+Порог ожидания >5 с проверяется периодически. Raw reply проходит проверку ICMP checksum.
+Нечётный хвост checksum обрабатывается без чтения за буфером.
+`icmp_proxy_init` создаёт общий контекст и binding; `icmp_proxy_enable_exit` отдельно
+открывает raw socket. EPERM/EACCES/отсутствие поддержки raw отключают только ICMP exit
+с WARN; клиентские REPLY сохраняются. Прочие ошибки запуска прерывают создание instance.
+Тестовый `test_loopback` включается явно, закрывает raw socket и даёт виртуальные ответы
+независимо от прав процесса. Production его не включает.
+Pending raw request создаётся только с рабочим таймером истечения срока ожидания.
+
+Send API принимает payload 0..65507, TUN delivery — 0..65506 из-за однобайтового
+префикса в uint16_t длине entry. UDP send требует локальный UDP-контекст, ICMP send
+его не требует. Доставка ответа требует клиентский TUN; своего окна/повтора датаграмм нет.
+
+## Жизненный цикл, диагностика и проверки
+
+Все операции и callbacks — в uasync владельца. Proxy init запрашивает binding
+после router init; client/server имеют разные service IDs. Общие UDP/ICMP создаёт
+и уничтожает UTUN_INSTANCE; TCP-модули освобождают только собственные ресурсы.
+Контексты нужны для включённого exit либо клиентского TUN; SOCKS/HTTP без TUN их не требуют.
+Заданные listeners, TUN mappings и bindings обязательны: ошибка откатывает создание.
+Повторный init активного модуля и попытка занять чужой binding отклоняются.
+При уничтожении instance TCP-клиент/сервер и общие контексты закрываются до остановки
+групп и транспорта; ua обрабатывает отложенные free. Точные контракты — в .h.
+
+Категория proxy: info — подключения/закрытия/транзакции, debug — окна/паузы/повторы,
+trace — трафик и секундная диагностика exit TCP-очередей/пулов/OS buffers.
+Для поиска проблемы также полезны socket и etcp_route.
+Регрессионный тест включает proxy=debug через UTUN_TEST_DEBUG=1.
+
+| Тест | Что проверяет |
+|---|---|
+| test_http_proxy | HTTP codec, разбиения headers/chunks, framing, лимиты, source credit, Upgrade |
+| test_proxy_packets | IPv4/UDP/ICMP, checksum и payload длиной 0..1501 |
+| test_proxy_regressions | Handshake/CONNECTED, HTTP pipeline/EOF/deadlines, окна/FIN, peer+sid, reentrancy, TUN options/fragment validation, per-instance UDP/ICMP |
+| test_proxy_lifecycle | 25 сценариев отказов/rollback, fd/память/таймеры, владение bindings, ICMP без raw, HUP re-register и destroy из callback |
+| test_tcp_proxy_client | Create/destroy с тестовым TUN, без утечек |
+| test_tcp_proxy_server | TCP echo через tcp_conn; сам по себе не проверяет протокол exit |
+| test_socks_http_proxy | Реальные SOCKS IPv4/domain, HTTP и HTTPS CONNECT, byte-exact загрузки; штатный TLS shutdown либо UTUN_TEST_TLS_ABRUPT=1 |
+| test_udp_proxy / test_icmp_proxy | Два instance через ETCP; ICMP: явный test_loopback, UTUN_TEST_ICMP_RAW=1 требует настоящий raw socket |
+| test_tcp_io | 19 сценариев, включая HUP high/low-water на epoll/poll, ручную паузу и независимую запись |
+| test_tcp_io_flush | Callback после последнего синхронного send |
+
+Проверка 2026-10-24: профильные тесты проходят на Linux. ICMP проверен и через явный
+test_loopback, и настоящим raw echo до 127.0.0.1 с правами root. Штатный TLS shutdown проходит без EPIPE/ENOTCONN;
+аварийный сохраняет реальные ошибки записи, все 16 загрузок остаются byte-exact.
+Тестовые конфиги используют поддержанный connect_timeout. Итоги полного прогона
+и sanitizer-проверок — в [proxy_fix_plan.txt](proxy_fix_plan.txt).
+Windows/FreeBSD runtime в этом окружении не проверены.
+Создание proxy из конфигурации в utun_instance.c исключено под _WIN32.
+IPv4-фрагменты на входе proxy TUN отклоняются; сборки фрагментов нет.
+Описания модулей: `src/proxy/*_doc.md`; все семь заголовков `src/proxy/*.h` сверены с реализацией.

doc/service_lifecycle.md

@@ -0,0 +1,409 @@
+# Жизненный цикл ядра и сервисов
+
+CLI выполняет daemon fork до создания `UASYNC`, SQLite, сокетов и фоновых потоков.
+Сервисы и их workers создаются уже в дочернем процессе. Родитель ждёт подтверждения
+успешной инициализации и записи PID-файла; ошибка старта возвращается вызывающему.
+`test_daemon_worker` проверяет настоящий запуск без `-f`, наличие дискового потока,
+штатный SIGTERM и ненулевой статус launcher при ошибке PID-файла.
+
+Все операции выполняются в потоке единственного `UASYNC` экземпляра, вне callbacks
+останавливаемых модулей. GUI передаёт команды в этот поток.
+
+```c
+struct UTUN_INSTANCE* inst = utun_instance_create_from_str(ua, config);
+if (!inst || utun_core_start(inst) < 0) /* обработать ошибку */;
+if (chat_service_start(inst) < 0) /* обработать ошибку */;
+if (utun_service_start(inst) < 0) /* обработать ошибку */;
+
+chat_service_stop(inst);  /* UTUN продолжает работать */
+chat_service_start(inst); /* загружает сохранённые каналы */
+utun_service_stop(inst);  /* чат продолжает работать */
+utun_instance_destroy(inst);
+```
+
+`utun_instance_init()` — сокращение для запуска ядра, UTUN и чата, если чат включён
+в конфигурации. Desktop GUI запускает ядро, UTUN и чат явно; TUN создаётся при
+`[global] tun_enabled=yes`. Без TUN и NAT запуск чата не требует прав администратора.
+Desktop подтверждает start только после готовности всех сервисов и uasync poll;
+ошибка TUN откатывает запуск и возвращается в GUI. Android запускает ядро и чат без UTUN.
+Повторный start работающего сервиса и повторный stop допустимы. Ошибка старта
+сервиса откатывает созданные им ресурсы. `utun_instance_stop()` останавливает цикл
+приложения; освобождение ядра выполняет `utun_instance_destroy()`.
+
+Для TUN в desktop `vibechat.cfg` задаются те же параметры, что и у CLI:
+
+```ini
+[global]
+tun_enabled=yes
+tun_ifname=vibechat
+tun_ip=10.42.0.1
+
+[routing]
+my_subnet=10.42.0.1/32
+route_subnet=10.42.0.0/24
+```
+
+Адреса и маршруты выбираются под свою сеть; изменения применяются после перезапуска.
+На Windows нужна `wintun.dll` рядом с `vibechat.exe` и запуск с правами администратора.
+CMake копирует DLL и лицензии из `lib/`; Windows-упаковка явно включает DLL, проверяет
+её архитектуру x64 и зависимости, поскольку `LoadLibrary` не отражается в импортах EXE.
+На Linux необходимы доступ к `/dev/net/tun` и права на настройку интерфейса и маршрутов.
+
+Успех запуска требует успешной инициализации всех обязательных ресурсов: заданных
+listen-сокетов, мониторинга, TUN и всех `route_subnet` при включённом TUN. Частичный
+набор сокетов или маршрутов — ошибка запуска. `utun_started` устанавливается только
+после завершения всех шагов. Системные маршруты хранятся отдельным списком успешно
+созданных записей; stop и откат удаляют только этот список, в обратном порядке.
+Маршрут, на добавлении которого ядро вернуло ошибку, не становится собственностью
+UTUN и при откате не удаляется. Ошибка одного удаления не прекращает очистку остальных.
+
+`auto_sockets=android` выбирает внешнее управление сетью: frontend регистрирует
+ConnectivityManager до запроса запуска и передаёт конфигурацию сокетов через JNI.
+Оба нативных монитора ОС в этом режиме не создаются. Рабочие listen-сокеты по-прежнему
+должны открыться полностью. Android подтверждает запуск по `SERVICE_STARTED`, а не
+по успешному созданию потока; после события передаётся свежий снимок адресов.
+
+| Владелец | Ресурсы |
+|---|---|
+| Ядро | Идентичность узла, реестр узлов и групп, SQLite, транспортные сокеты, NCD, маршрутизатор, общая репликация, время, мониторинг |
+| UTUN | Группа UTUN, запросы соединений из конфигурации, DATA binding, TUN, системные маршруты, NAT transport |
+| Чат | CHAT-группы, запросы подключения и join, экземпляры синхронизации каналов, chat API, медиа, личные сообщения, звонки и headless API |
+| Группа | Сессии пиров, её маршруты и логические каналы, планировщик подключения и recovery |
+| Сессия пира группы | NCD handle с момента CONNECTING, согласованные эпохи, состояние обмена таблицей, очередь отправки |
+
+Proxy настраивается при создании ядра. Instance владеет общими UDP/ICMP-контекстами;
+TCP client/server владеют только своими bindings, listeners и TCP-потоками.
+Общие контексты нужны для exit либо клиентского TUN; SOCKS/HTTP без TUN их не требуют.
+Ошибка обязательного listener, TUN mapping или регистрации откатывает создание instance.
+Недоступность raw ICMP по правам или поддержке отключает только ICMP exit с WARN;
+клиентские ICMP REPLY и TCP/UDP продолжают работать.
+`utun_instance_destroy()` закрывает proxy и обрабатывает отложенные free до остановки
+UTUN/CHAT-групп и транспорта. Waiters/таймеры снимаются до освобождения их владельцев.
+Остановка отдельного TCP proxy-модуля не уничтожает общие UDP/ICMP-контексты.
+
+SQLite открывается ядром один раз: `db_path/chats.db`, либо `:memory:`, если путь
+не задан. Остановка чата сохраняет каналы и сообщения в этой БД. В варианте
+`:memory:` данные сохраняются только до уничтожения ядра.
+
+Работающий общий транспорт сохраняется, пока он нужен хотя бы одному из пиров. Закрытие запроса одной группы
+не разрывает соединение, нужное другой группе. При остановке группы отменяются
+её планировщики, запросы, таймеры и ожидания очередей; отправляется LEAVE,
+закрываются логические каналы маршрутизатора и удаляется её ожидающий транзит
+на общих соединениях. Транзит других групп сохраняется. Отложенный LEAVE может временно
+удерживать транспорт самостоятельно, не обращаясь к уже удалённой группе.
+
+ETCP удаляет транспорт после 30 секунд непрерывного DOWN только при отсутствии локальных NCD handles.
+Первоначальное ожидание UP тоже учитывает владение. Повторный DOWN не продлевает
+таймаут; восстановление UP отменяет его. Если срок истёк при наличии handles, транспорт
+сохраняется, а исходный deadline остаётся. Освобождение последнего handle во время DOWN
+оставляет транспорт до этого deadline либо запускает удаление в следующем callback,
+если срок уже истёк. Внешние ETCP refs задерживают только освобождение памяти.
+Явный force-close и отмена неудачной попытки последнего владельца закрывают сразу.
+
+Входящий UP без локальных handles сохраняется: он может быть нужен пиру. CLOSE/KEEP_ALIVE
+привязан при запуске ядра, поэтому мягкое закрытие работает и на чисто входящем узле.
+На CLOSE при наличии handles отвечаем KEEP_ALIVE; без них закрываем транспорт.
+KEEP_ALIVE полностью отменяет FIN_WAIT. Ожидание CLOSE обычно занимает 5 секунд,
+для спящего пира увеличивается до его RX deadline. Сам факт DOWN во время FIN_WAIT
+завершает ранее запрошенное мягкое закрытие.
+
+Контроль RX независим от отправки keepalive. Объявленный сон не отключает проверку
+жизни: срок от последнего RX равен максимуму согласованного keepalive timeout и
+объявленного остатка ACTIVE+SLEEP с запасом normal timeout. Фазовые таймеры и наши
+отправки срок жизни пира не продлевают. Пробуждение сразу сокращает deadline до normal timeout.
+После истечения последнего линка транспорт
+становится DOWN, затем может удаляться через 30 секунд, когда локальных NCD handles нет. `test_etcp_server_lifecycle`
+проверяет сроки, несколько путей, восстановление, владение, сон и CLOSE/KEEP_ALIVE
+с управляемыми часами и контролем освобождения памяти/таймеров.
+
+Остановка чата сначала прекращает внешние команды и фоновые задания, затем
+закрывает медиа и сервисы, синхронизацию и группы, после чего освобождает chat core.
+`media_async_destroy()` дожидается завершения native workers и вызывает каждый
+ожидающий callback с `MEDIA_ASYNC_CANCELLED`, пока его контекст ещё существует.
+Worker резервирует completion до запуска и передаёт его через `uasync_post_reserved`;
+периодического polling нет. Destroy выполняется вне callbacks uasync, после join
+отменяет pending post и завершает done ровно один раз. Uasync живёт до конца этой очистки.
+Подготовленные блоки отменённых задач не регистрируются; учёт назначений подготовки
+сохраняется для последующей очистки. Это синхронное ожидание: длительное
+транскодирование или распознавание речи может задержать stop; принудительного
+прерывания этих библиотек нет.
+
+Владелец принимает не более 16 задач, включая уже завершённые workers до доставки
+completion. Отказ запуска/неверные аргументы дают синхронный done с -1, остановка
+владельца — с `MEDIA_ASYNC_CANCELLED`; при NULL done только логируется ошибка.
+Примитивы `media_async.h` синхронные: отмена задачи не откатывает выполненные ими
+действия. `ma_copy_file()` публикует копию внутри worker после проверенных записи и
+закрытия temp; вызывающий отвечает за очистку своего результата при отмене.
+Подробные файловые контракты, 64-битные размеры и ошибки RNG описаны в `media_async.h`.
+
+Групповой crypto worker хранит один `file_io_temp` прямо в задаче вложения.
+Общий валидатор MIME не выполняет I/O: send вызывает его в uasync до создания
+задачи/ключа, файловый codec повторяет проверку в worker до открытия файлов.
+`encrypted_file_write/read` только готовят закрытый durable temp; worker публикует
+его одним rename, completion подтверждает результат в БД/UI. Отмена до completion
+не публикует сообщение; cleanup учитывает реально созданные/заменённые файлы.
+Ошибка синхронизации каталога после rename означает установленное имя без подтверждённой
+durability; отложенный discard уже не удаляет результат. Общей транзакции ФС/БД нет.
+До запуска workers и после их завершения recovery очищает собственные stale temp
+в `media/decrypted`; общий file_io-реестр сохраняет активные temp всех instance.
+
+`media_delivery_init()` вызывается после подготовки chat core и media_index, пока
+общая БД и группы живы; подписка на роли обязательна. Репликация хранит отдельный
+контекст и CM handle для каждой пары «CHAT-группа–пир». DOWN отменяет текущий RPC,
+сохраняя handle для восстановления CM; TIMEOUT закрывает его перед повторным открытием.
+Отдельный ETCP DOWN не означает потерю всех путей CM. До free контекста отменяются
+его waiter, pump, watchdog и собственный handle; destroy отменяет также сверку ролей.
+Обычный stop сохраняет каталог, его эпоху и RX-курсоры. Потеря локальной роли удаляет
+чужие объявления вместе с RX-курсорами только этой группы одной транзакцией;
+удаление канала удаляет также собственные объявления. Страница репликации и её
+RX-курсор фиксируются одним самостоятельным commit; вложенная внешняя транзакция
+не считается сохранённым прогрессом. Wire-контракт находится в `media_delivery_proto.h`.
+
+Перед файловой подготовкой назначение записывается в `media_preparations`. Успешный
+`media_index_commit()` регистрирует весь файл и снимает эту запись в одном savepoint;
+после ошибки/отмены путь остаётся известен, даже если worker уже опубликовал копию.
+Это гарантия записи БД; файловые изменения и внешний SQL COMMIT ей не охватываются.
+При обычной ошибке откатывается только регистрация; SQLite может сама отменить всю
+транзакцию при тяжёлой ошибке. Общая база берётся из `ui_state.media_base` и повторно
+используется после stop/start. Загрузчик не меняет существующую базу.
+
+Входящая загрузка и исходящая подготовка резервируют нормализованный путь в общем
+media_delivery до начала записи. Отмена снимает загрузку с индекса, закрывает CM handles
+и таймеры, освобождает резервацию; выполняющийся обработчик удерживает сам контекст.
+Поэтому отмена и повторный start из progress callback допустимы, а done старой загрузки
+вызывается после возврата из progress. Каждая попытка блока имеет отдельные UUID и temp:
+поздние пакеты старого держателя/попытки не изменяют новый файл.
+
+Producer и relay-выдачи независимо удерживают файл блока. После отмены producer
+непроверенный источник завершается с ошибкой; проверенный может обслужить оставшихся
+читателей. Последний владелец удаляет temp. При удалении канала отменяются и producer,
+и все его выдачи; перед освобождением выдачи отменяются её waiter, pump и таймер.
+DONE выдачи следует только после проверки блока и принятия всех его данных router.
+
+После проверки всех блоков загрузчик собирает отдельный temp, проверяет операции
+чтения/записи/close, полный размер и SHA-256, затем атомарно заменяет имя назначения.
+Ошибка до публикации сохраняет прежний файл. Затем выполняется регистрация в SQLite:
+при её ошибке опубликованный файл остаётся учтён в media_preparations для очистки.
+Проверка и сборка блоков пока синхронны в uasync; контракт workers относится к исходящей подготовке.
+
+Локальное удаление канала ждёт его исходящие video/register задачи. Последний
+completion продолжает удаление; новые исходящие медиа канала в это время отклоняются,
+подготовленные результаты ожидающих отправок не публикуются как новые сообщения.
+После завершения задач отменяются загрузки/раздача и удаляются учтённые файлы, включая
+назначения неуспешных подготовок. Общие файлы других каналов сохраняются. Очистка файлов
+выполняется вне внешней транзакции: SQL-откат не восстанавливает удалённый файл.
+При ошибке очистки записи оставшихся файлов сохраняются для повторного вызова;
+удаление метаданных канала и неполная файловая очистка диагностируются отдельно.
+Низкоуровневый `media_index_delete_channel()` сам workers не останавливает.
+Точные ограничения путей и контракт повторной регистрации находятся в `media_index.h`.
+
+Подготовка файлов в `src/video/video.h` выполняет remux подходящих H.264/AAC либо
+перекодирование в MP4 H.264/YUV420P и AAC. Worker пишет уникальный соседний временный
+файл, завершает декодеры/ресемплер/FIFO/кодеры, проверяет trailer, закрытие и метаданные.
+Конечное имя заменяется только успешным completion в uasync. При отмене, включая
+отмену уже подготовленного результата до доставки completion, временный файл удаляется,
+старое назначение сохраняется. Совпадающие исходник/назначение и файловые алиасы
+отклоняются; исходный файл должен оставаться неизменным до done. В процессе занята
+одна задача до completion; атомарный захват исключает гонку между экземплярами ядра.
+Перед done занятость освобождается, поэтому callback может запустить следующую задачу.
+JPEG использует те же правила файлов, но извлекается синхронно в отдельном frontend worker.
+Probe также синхронен и не обещает ограниченного времени чтения.
+
+Live media хранится в RS-кольце с общим индексом PTS; каждый локальный handle владеет
+отдельным cursor. Пауза player не останавливает сетевой ingest и не закрепляет старые
+части против вытеснения. После FIN publisher может снять своё владение, сохранив
+завершённый источник для оставшихся локальных readers. Последний close освобождает
+источник, индекс и кольцо. Новая публикация отсоединяет readers прежней эпохи.
+Android preview собственного эфира не создаёт reader: Camera2 пишет прямо в TextureView
+и encoder Surface. UI attach/detach меняет лишь camera session; audio/encoder/origin сохраняются.
+UI, ожидающие команды camera handler и каждая camera session удерживают preview target отдельно.
+TextureView возвращает false при destroy и снимает ссылку UI; Surface/SurfaceTexture освобождаются
+после закрытия последней session. CameraDevice.onClosed снимает также оставшиеся ссылки своих
+sessions, если Android не прислал отдельные session.onClosed. Повторные callbacks безопасны.
+Capture stop запрещает attach и снимает своё владение target; camera HandlerThread завершается
+после camera close и освобождения outputs всех созданных sessions.
+Отказ preview output возвращает encoder-only session и не завершает сам эфир.
+При stop/destroy отменяются delivery и media-index callbacks до освобождения store;
+destroy отсоединённого cursor не обращается к store. Frontend прекращает audio callback
+и worker до освобождения своего DSP; borrowed handle/RS pointers между потоками не передаются.
+
+Чтение video cursor запрашивает следующий кадр по готовности decoder, независимо от
+PTS показа; audio cursor сохраняет временной lookahead. Viewers готовят ограниченный батч
+на запрос: отдельно задаются число видеокадров, audio lookahead и число всех записей.
+Desktop и Android принимают до 16 записей и обрабатывают треки по их готовности.
+VIDEO_END/AUDIO_END следуют за последними пакетами своего трека, не ожидая другого трека;
+общий END завершает вход, а окно ждёт опустошения обоих выходов. GAP/CLOSED отменяют старый батч.
+Получение батча погашает запрос, включая повторные обращения до pull; скрытого чтения следующего батча нет.
+Callback готовности только будит desktop worker и не вызывает API ядра/bridge. Stop снимает callback
+под mutex viewer до освобождения его контекста; detach будит ожидающие workers до уничтожения manager.
+На Android signal принадлежит audio worker и живёт до stream_stop, join video worker и close mixer input;
+ядро только уведомляет его. Surface освобождается после join video worker.
+В wait не удерживаются mutex bridge/ядра. Расход PCM будит тот же signal, уведомления сливаются без потери пробуждения.
+GUI и audio callback будят worker при движении часов/освобождении места; сна между готовыми пакетами нет.
+Каждый reader имеет отдельные audio/control и video workers. Audio worker читает батчи и готовит
+до 250ms PCM через Opus/SoundTouch, не удерживая блокировку consumer. Запас пополняется при наличии
+данных без обязательного prefill. SPSC передаёт PCM вместе с отображением исходных PTS; mixer/audio
+callback только копирует и смешивает. Короткая блокировка защищает output map/clock и lifetime,
+в ней нет декодирования, time-stretch или MediaCodec/FFmpeg. EOF продолжает prepare до опустошения DSP.
+Android video worker получает ограниченный mailbox (два кадра) и держит один рабочий input и один готовый output MediaCodec; свободный
+input buffer получает лишь для уже готовых данных и сразу возвращает codec.
+Первый decoded frame разрешает движение clock/audio. Будущий output ждёт PTS и
+приостанавливает новые video requests, сохраняя независимую обработку audio/control.
+Если первый доступный звук позже KEY, cursor отсчитывает стартовый audio lookahead от
+первого аудиопакета, сохраняя это основание неизменным. Opus/SoundTouch получает PCM до
+запуска audio clock; неподвижные часы не разрешают читать дальше этого ограниченного окна.
+PTS поданных кадров служат диагностике/проверке запаздывания, а не лимиту заполнения codec.
+Смена revision заменяет только video decoder и его диагностические измерения;
+GAP/EXPIRED начинают новую точку KEY. Нехватка сети сохраняет decoder references.
+Reset увеличивает video generation; результаты прежнего поколения не публикуются. Video worker
+после EOF остаётся доступен для reset до явного stop. Audio clock после старта не ждёт видео:
+просроченные изображения декодируются для сохранения references, но не показываются.
+Desktop FFmpeg держит один рабочий AVPacket и два готовых изображения; EAGAIN оставляет
+packet до следующего прохода. FIN подаёт EOS и дренирует выход до decoder EOF;
+конец GUI требует также показа оставшихся изображений и завершения audio tail.
+Отсутствие прогресса decoder при наличии работы имеет отдельную диагностику и срок 10s.
+
+ACK-история принадлежит ядру и обновляется только при первом найденном подтверждении
+пакета. REINIT/close соединения не стирает уже подтверждённые за последнюю секунду байты.
+Общий `stream_publisher` Android/desktop владеет отдельным 100ms таймером TX-снимков;
+close/detach отменяют его в uasync до уничтожения instance. Bridges копируют снимок
+под mutex, frontend не обращается к живым очередям транспорта. Android экран подписан
+на отдельный StateFlow статистики; desktop обновляет статистику отдельно от сырого превью.
+Publisher не регистрирует stream event callback и не подменяет callback viewer.
+Bridge удерживает внешний mutex на время producer/open/stop и destroy общего publisher;
+actor не вызывает frontend callbacks под своим mutex. Reserved post, media timer,
+stats timer и stream handle освобождаются до контекста publisher.
+
+Desktop `MainWindow` владеет `StreamPublishEngine`, а окно управления лишь отображает
+его состояние. Закрытие окна сохраняет эфир, новый запуск запрещён до конца FIN drain.
+Qt capture callback сохраняет последний `QVideoFrame` для preview и ограниченно ставит кадр
+в очередь отдельного долгоживущего image worker. Он конвертирует `QVideoFrame` в `QImage`;
+video worker получает готовый image и не создаёт Qt Multimedia TLS, которое могло задержать его exit на Windows.
+Video/audio workers выполняют encode/DSP вне GUI и hardware callbacks. Отдельные поколения источника и encoder позволяют менять
+видеокодек/bitrate/rotation без повторного выбора экрана в портале. Ошибки Qt capture
+обрабатываются через queued callback, чтобы не уничтожать backend из собственного callback.
+Stop запрещает producers, закрывает Qt capture и подписку на аудиозахват. Отдельный join worker
+дожидается полного выхода video/audio threads, включая native TLS Qt; GUI продолжает обрабатывать события.
+После join отправляется FIN с drain 2s; закрытие последнего микрофона может продолжаться параллельно.
+Microphone lease и owner сохраняются до завершения обоих путей. Новый start ждёт также FIN drain.
+При завершении приложения engine уничтожается до SoundManager и ядра; detach в uasync
+закрывает оставшийся publisher. Destructor ждёт workers в локальном event loop без пользовательского ввода,
+чтобы thread cleanup мог обратиться к GUI; start и внешние сигналы engine в это время запрещены.
+Workers никогда не держат borrowed instance/handle.
+Microphone lease публикации исключает call/recorder; рация согласует вход через `AudioCapture`.
+Одинаковый выбранный вход имеет одну аппаратную сессию и профиль трансляции. Разные входы независимы.
+Подключение/отключение рации не останавливает устройство трансляции: атомарный слот и счётчик readers
+дожидаются только callback удаляемого потребителя. Последняя подписка закрывает устройство.
+Если первой работала рация, публикация заменяет профиль захвата своим; после остановки публикации
+оставшаяся рация продолжает тот же захват. Recovery останавливает callbacks, workers TX и один раз
+открывает общий вход; RX рации сохраняется. Каждый потребитель обрабатывает собственную копию PCM.
+На Android `MediaAudioController` владеет общим выбором устройства, AudioManager и одним аппаратным reader.
+Маршрутизация использует `CallAudioRouter`; AudioTrack рации и микшера просмотра регистрируются у одного владельца.
+`MicrophoneCapture` раздаёт независимые ограниченные очереди постоянного PCM 48k stereo; моно апмиксуется.
+После подключения публикации встроенный микрофон использует CAMCORDER, сохраняемый до последней подписки.
+Смена профиля заменяет только аппаратный AudioRecord: камера, видеокодер и source_epoch продолжают работать.
+Общая сетка по capture timestamps имеет запас 200ms; пропуски заполняются тишиной, старый PCM не переносится вперёд.
+Stop публикации удаляет её подписку до join Opus worker и FIN, сохраняя захват для оставшейся рации.
+PTT и PCM рации проходят через одну очередь. Последняя подписка завершает общий reader;
+контроллер закрывает аппаратный вход, сохраняя выходы. Перед Telecom все владельцы снимаются,
+а `MediaAudioController.awaitIdle()` дожидается освобождения входа и глобального маршрута.
+Ограничения фонового захвата рации, её разрешения и foreground-сервис продолжают действовать.
+Fatal ошибка audio worker передаётся в GUI с session ID и завершает всю публикацию;
+откат видеоконфигурации применяется только к video/capture. Поздний отказ старого publisher
+не завершает новую сессию. Причина ошибки сохраняется в окне после окончания drain.
+
+Desktop-звонок и рация проверяют поступление корректного PCM, включая первый callback.
+Секунда без данных отключает TX и фиксирует понятную ошибку в GUI; цифровая тишина является данными.
+RX продолжает работать, рация снимает PTT, автоматического переоткрытия неисправного входа нет.
+Выбор другого микрофона или новая сессия снимают ошибку. Неисправное устройство закрывается
+в отдельном потоке; stop не присоединяет уже запущенный close worker. Новый захват ждёт его завершения.
+В звонке microphone lease удерживается до конца закрытия даже после stop. Общий AudioCapture
+рации сначала отсоединяет callback потребителя; последний владелец освобождает backend в worker.
+Сброс контекста и уничтожение владельца дожидаются worker до освобождения miniaudio-контекста.
+Штатное закрытие исправного устройства сохраняет синхронный порядок.
+
+`AudioDevice` подстраивает буфер по подтверждённым backend XRUN: WASAPI DATA_DISCONTINUITY
+на входе, ALSA EPIPE, PulseAudio capture hole/overflow и playback underflow. Notification
+только увеличивает атомарный счётчик, решение и лог выполняются в GUI recovery timer.
+Исходные параметры, включая Linux capture period=10мс, сохраняются до повторных сбоев.
+Первая секунда после start исключена; нужны ошибки в двух опросах за 5с. Период увеличивается
+на 5мс, не чаще раза в 5с, до общей запрошенной ёмкости 100мс с учётом числа периодов.
+Фактический размер согласует backend; исходный или уже достигнутый больший размер не уменьшается.
+При достижении предела повторные сбои логируются без новых перезапусков. Подобранный запрос
+сохраняется при recovery, сбрасывается при смене устройства/сессии; стабильный звук не вызывает reopen.
+Подстройка микрофона закрывает устройство асинхронно, останавливая TX worker и сохраняя RX.
+Общая capture-сессия отсоединяет callbacks до close и заново подготавливает потребителей после init.
+Новая подписка во время close откладывается, stop удаляет её без ожидания backend.
+Первое переоткрытие после подстройки не использует backoff; при ошибке открытия действует обычный retry.
+
+В desktop-видеозвонке Windows/Linux камера живёт в отдельном процессе того же
+`vibechat --call-camera-worker`. Служебный вход выполняется до конфига, БД и
+single-instance lock. Перечисление устройств, Qt/V4L2, преобразование и освобождение
+аппаратных кадров происходят только там. GUI получает собственный `QImage`; TX не
+обращается к драйверу. Смена codec не перезапускает захват и не ждёт следующего GOP.
+
+Пиксели одного кадра передаются через mapping (Windows — pagefile-backed объект ОС,
+Linux — временный файл), метаданные/команды — через локальный сокет.
+Worker записывает mapping до FRAME; следующий write разрешён
+только после ACK, который GUI посылает после копирования в свою память. Общего mutex
+нет. В worker ожидает только последний raw-кадр; поколения отсекают старые результаты.
+Preview обновляется по готовности, TX получает condition-variable wake. PTS сохраняет
+время захвата; кадры старше 250мс отбрасываются до encode и перед send. Отброшенный
+encoded frame требует следующего KEY, поскольку encoder уже продвинул reference chain.
+
+Отключение камеры и удаление окна не ждут worker. Независимый Session сохраняет
+QProcess и mapping до finished, затем удаляет себя после отсоединения владельца.
+Зависший stop получает kill через 1.5с, отсутствие прогресса — через 5с; таймеры
+живут в родительском процессе. При выходе приложения kill отправляется без wait;
+GUI не уничтожает живой QProcess. При отказе новый процесс запускается лишь по
+явной команде пользователя и после finished прежнего. Лог категории call показывает
+последнюю стадию enumerate/start/convert/release/stop и возраст кадра.
+`test_call_camera_capture` проверяет настоящую IPC-цепочку с подставным устройством:
+блокировки start/map/stop, поздние кадры после смены поколения, задержку 720p,
+повтор после отказа, отсутствие рестарта камеры при смене codec, удаление окна,
+выход приложения и независимое освобождение mapping в каждом процессе.
+
+Статус транспорта UP подтверждает восстановление физического пути. READY сессии
+группы означает согласованный JOIN/ACCEPT и завершённый обмен её таблицей; именно
+его ждёт recovery. REINIT меняет эпохи обмена, сохраняя рабочие маршруты. Эпохи
+защищают от сообщений старой сессии и не задают срок жизни маршрута.
+
+Проверки: `test_services` проверяет независимый stop/start, общий NCD в CONNECTING,
+сохранение идентичности/сокетов/БД, повторную загрузку каналов, отмену workers,
+заблокированного медиа-потока, транзита и ожиданий заменённой очереди. `test_chat_join_e2e`
+проверяет join и распространение membership между узлами без UTUN-сервиса.
+
+В Android звонковой сессией владеет `CallController` уровня приложения; события
+ядра и команды Telecom обрабатываются один раз в main thread, без повторного
+проигрывания событий при создании ViewModel. UI получает `StateFlow` и передаёт
+пользовательские команды. `CallService` владеет `CallAudioEngine` и частичным
+wake lock: перед исходящим вызовом или принятием входящего запускается foreground
+режим `phoneCall|microphone`, затем сигналинг и аудио. Завершение сначала
+останавливает I/O и дожидается аудиопотоков, затем освобождает native-аудио,
+wake lock и сервис. Перед `NativeLib.stop/restart/destroy` выполняется тот же
+порядок; новый звонок разрешается после `SERVICE_STARTED` нового ядра.
+
+Активность ядра задаётся явно: видимая Activity или незавершённый звонок удерживают
+ACTIVE и выключают Android standby. Состояние не истекает по таймеру. После
+завершения звонка в фоне возвращается standby; экран может гаснуть во время
+разговора независимо от частичного wake lock сервиса.
+
+Если работают рация, публикация или просмотр трансляции, исходящий Android-звонок
+требует подтверждения их остановки; входящий показывает предупреждение до принятия.
+После подтверждения/принятия `CallController` выключает участие в рации, завершает
+публикацию и просмотр, асинхронно ждёт освобождения их аудио и только затем запускает
+сигналинг и звонковое аудио. Foreground-сервис резервируется сразу из видимой Activity.
+Отмена во время освобождения не запускает устаревший звонок.
+До окончания звонка повторное включение рации/трансляции заблокировано.
+После закрытия звонкового аудио и Telecom Connection ранее включённая рация
+возвращается в прежний канал; удержания PTT сброшены. Удалённый канал и остановленное
+ядро не восстанавливаются. Публикация и просмотр трансляции автоматически не возобновляются.
+
+`utun_set_client_activity()` в сборке с `UTUN_HAVE_STANDBY` применяет фактический
+режим duty-cycle до рассылки событий активности; JNI не переключает его отдельно.
+Повторная команда не перезапускает фазу и анонсы, но первый фоновый запуск включает
+standby даже при начальном `client_activity=STANDBY`. Keepalive подписан на режим
+и фазы самого standby; новые UDP/TCP-линки сразу анонсируют текущую фазу после
+handshake. Пробуждение по таймеру и внешней сети сначала сообщает ACTIVE-окно
+пирам, затем запускает ожидающие задачи. При выходе сначала восстанавливаются
+линки; deinit отменяет ожидающие задачи и очищает подписки старого ядра.

doc/stun_nat.md

@@ -0,0 +1,104 @@
+# Независимая STUN-диагностика NAT
+
+Модуль `src/transport_layer/stun_nat.c/h` измеряет NAT на уникальных путях существующих IPv4 UDP-сокетов.
+Ключ группы — семейство, фактический IP и netif; имена и рабочие порты не участвуют.
+Для каждой группы создаётся один собственный неблокирующий UDP-сокет с тем же локальным IP,
+привязкой к устройству и Linux SO_MARK / FreeBSD FIB. Тестовый порт выбирается случайно из 49152–65535.
+Модуль сам регистрирует чтение в uasync, принимает STUN и закрывает свой сокет после измерения.
+STUN не меняет исходный ETCP fd, его порт и обработчики. Через `stun_nat` API модуль
+`nat_detection` получает предварительную оценку для рабочих сокетов того же IP/netif
+с совпадающими mark/FIB/device. Если два разных IP видят одинаковый стабильный внешний
+IP:порт и есть трансляция адреса, рабочий профиль получает EIM? с source=STUN и inbound=UNKNOWN.
+Это действует и для обычных серверов без запроса с незнакомого IP. Filtering тестового порта
+не переносится; измерение mapping рабочего сокета всегда имеет приоритет.
+Оценка снимается после TTL, отключения STUN, смены пути или противоречащего внешнего IP.
+Тестовый mapped endpoint не копируется в `nat_addr` и NODEINFO: адрес для подключения
+должен быть получен наблюдением самого рабочего сокета. Детектор описан в `doc/nat_detection.txt`.
+
+## Конфигурация
+
+```ini
+[stun]
+enabled=yes
+server=stun-a.example.org:3478
+server=stun-b.example.org:3478
+# Дополнительные строки — резервные серверы.
+
+[debug]
+nat=debug
+```
+
+Без `enabled=yes` модуль выключен. Без порта используется 3478. Список сохраняет порядок конфига.
+При включении нужны минимум две строки `server`; для измерения выбираются два ответивших сервера с различными IP.
+Совпадающие IP после DNS пропускаются. DNS асинхронный, с использованием существующего IPv4 A-резолвера.
+IPv6, SOCKS UDP и `only_local` пропускаются с явным статусом; TCP не проверяется.
+
+## Результат
+
+`stun_nat_get_result(instance, "имя исходного сокета", &result)` копирует локальный снимок:
+
+Имя сначала разрешается в текущий рабочий сокет, затем в группу. API ядра
+`stun_nat_get_socket_result(instance, socket, &result)` дополнительно проверяет
+текущие IP/netif и параметры маршрутизации. Несколько рабочих портов получают общий снимок.
+
+- `local` — тестовый IP:port; `servers[2]` и `mapped[2]` — реальные серверы и наблюдавшиеся внешние адреса;
+- `translated`: -1 неизвестно, 0 трансляция не наблюдалась, 1 внешний адрес отличается;
+- `mapping`: UNKNOWN, MATCH, DEPENDENT, EIM, ADM, APDM;
+- `filtering`: UNKNOWN, EIF, ADF, APDF;
+- причины неполного результата, статус, время измерения и обнаруженная поддержка RFC 5780.
+- ключ группы, generation, evidence_id, measured_at_us, количество рабочих сокетов и признак refresh.
+
+Обычный STUN даёт MATCH при одинаковых адресах и DEPENDENT при разных. MATCH не доказывает EIM,
+а обычные Binding-ответы не позволяют определить filtering. Первоначальный сервер опрашивается повторно:
+смена его mapping во время проверки инвалидирует классификацию как нестабильную.
+
+## RFC 5780
+
+Корректные OTHER-ADDRESS и RESPONSE-ORIGIN включают автоматическую попытку Behavior Discovery.
+Нужны две публичные IP и два порта на серверной стороне, доступные во всех четырёх комбинациях.
+
+1. Обычный Binding получает внешний адрес и альтернативный endpoint.
+2. CHANGE-REQUEST с флагами IP+port проверяет EIF.
+3. Если ответ не пришёл, контрольный Binding проверяет живость сервера и стабильность mapping.
+4. CHANGE-REQUEST только port различает ADF и APDF; после таймаута снова выполняется контрольный Binding.
+5. Перед публикацией ADF/APDF альтернативные endpoints проверяются обычными Binding-запросами.
+   Недоступный альтернативный endpoint даёт UNKNOWN, а не ложную строгую фильтрацию.
+6. После filtering проверяется mapping: альтернативный IP с первоначальным портом, затем при необходимости
+   альтернативный IP с альтернативным портом. Сравнение различает EIM, ADM и APDM.
+7. Второй сервер и повтор первого проверяют независимую пару и стабильность результата.
+
+Все filtering-тесты выполняются до открывающих фильтр отправок на альтернативные endpoints.
+Собственные предыдущие STUN-отправки учитываются: при пересечении адресов следующего сервера
+сомнительный тест filtering пропускается. ERROR 420 и игнорирование CHANGE-REQUEST дают UNKNOWN.
+Аутентификация STUN не реализована: требующий её сервер фиксируется как ошибка, затем используется резервный.
+
+Запрос содержит случайный 96-битный transaction ID и FINGERPRINT. Проверяются источник ответа,
+transaction ID, границы/выравнивание атрибутов, XOR-MAPPED-ADDRESS, RESPONSE-ORIGIN и FINGERPRINT при его наличии.
+Повторы одной транзакции сохраняют ID: RTO от 500 мс удваивается, всего семь отправок, последнее ожидание 8 секунд.
+Новые транзакции всех проб ограничены десятью в секунду; ожидания не блокируют event loop.
+
+## Жизненный цикл и проверки
+
+Ядро запускает модуль при `utun_core_start`; остановка уничтожает его до сетевых ресурсов и config.
+Перезагрузка конфига отменяет старые DNS/таймеры и создаёт новый модуль.
+Раз в три секунды выполняется локальная сверка групп: новые/изменённые проверяются,
+группа удаляется после исчезновения последнего рабочего сокета. Смена имени/представителя
+или удаление дубликата не теряет кэш. Несовпадение mark/FIB/device внутри одного ключа
+даёт UNKNOWN с причиной incompatible routing policy.
+TTL результата 300 секунд, refresh 180 секунд; неполные/неудачные проверки повторяются через 30 секунд.
+Во время штатного refresh доступен прежний результат до TTL; его возраст не обновляется.
+Использованные тестовые порты не переиспользуются в течение жизни ядра, включая reload STUN.
+История портов освобождается только при окончательном destroy ядра.
+`stun_nat_recheck(instance)` явно повторяет измерение на новых портах, в том числе после смены маршрута без смены IP.
+Публичные операции выполняются в uasync-потоке экземпляра.
+
+INFO содержит начало измерения и итог с адресами, классификацией и причинами UNKNOWN.
+DEBUG содержит этапы, transaction ID, повторы, RTT, DNS и очистку; WARN/ERROR описывают аномалии.
+
+Linux-тест `test_stun_nat` использует реальные локальные UDP-сокеты и ускоренные часы:
+обычный STUN, все классы RFC 5780, недоступные альтернативы, потеря запроса, неверные/поздние ответы,
+резервные серверы, DNS, нестабильный mapping, отмена и повторная проверка, изменение состава сокетов.
+Сценарии проверяют сохранность рабочего fd/порта, предварительный EIM?, приоритет ETCP,
+снятие оценки после TTL, совпадение IP/netif и освобождение таймеров.
+
+Ссылки: [RFC 5780](https://www.rfc-editor.org/rfc/rfc5780), [STUN RFC 8489](https://www.rfc-editor.org/rfc/rfc8489).

doc/tasks.md

@@ -0,0 +1,943 @@
+# Задачи по проекту
+
+Сюда пишется список задач с короткой аннотацией. Если задача большая и имеет ТЗ - то ТЗ оформляется отдельным файлом, а сюда помещается аннотация и ссылка на ТЗ.
+
+## Текущие задачи
+
+[ ] **member_files: cleanup удаляет чужой temp при отказе создания загрузки** — воспроизведено 24.10.2026 на a198cfb9.
+    test_member_files_network падает в фазе23: локальный O_EXCL open возвращает MF_EXISTS,
+    затем TRANSFER_FINISH без проверки владения вызывает mf_disk_local_remove(t->temp).
+    Прежнее назначение37байт сохраняется, заранее созданный чужой .part исчезает.
+    Проверены общий check.sh и отдельный повтор: одинаковый FAIL preservation case=0, target=1, foreign_temp=0;
+    отсутствие .part дополнительно проверено в обоих оставшихся тестовых каталогах.
+    Нужен учёт успешного создания собственного temp, включая отмену до PREPARE и отказ max_bytes;
+    проверять/удалять можно только созданный этой передачей файл. Код этого модуля в ETCP-ветке не менялся.
+    Логи: /tmp/etcp-solo-native-full-check.log, /tmp/etcp-solo-member-network-repeat.log;
+    подробный первый лог: /tmp/etcp-solo-member-network-suite-failed.log.
+
+[+] **media_async/media_delivery: завершить сверку контрактов и исправлений** — завершено 24.10.2026.
+    Проверены все11 заголовков двух каталогов по полным реализациям; исправлены alias файлов,
+    граница voice duration, переанонс SQLite и расхождение MIME. Результаты каждого фикса приведены ниже.
+    Устаревший _desc.txt заменён описанием текущей архитектуры; уточнены sync.md, encrypted_attachments.md
+    и media-раздел service_lifecycle.md. Общий lifecycle за пределами media остаётся частично проверенным.
+    Итог, границы и доказательства: [media_async_audit_findings.txt](media_async_audit_findings.txt).
+
+[+] **encrypted_file: одинаково проверять MIME при записи и чтении контейнера** — исправлено 24.10.2026.
+    Прежний write проверял только strlen(type)<32 и принимал пустое значение/недопустимые символы,
+    тогда как read их отвергает. Пять реальных write/read с теми же ключом/UUID/подписанным hash:
+    write=0, read=-1; контрольный application/octet-stream проходит полный roundtrip.
+    Прежний chat_attachment_send также проверял только длину и мог принять такой MIME до записи ключа/запуска worker.
+    Воспроизведение: /tmp/media-content-type-audit.c и .mk, /tmp/media-content-type-audit.log;
+    исходники/контейнеры: /tmp/media-content-type-audit-FdtMC3/. Исходный файл не меняется.
+    Реализован один bounded encrypted_file_validate_type для send/write/read; 1..31 байт,
+    ASCII33..126 без двойной кавычки/обратной косой черты — действующие ограничения read.
+    Отказ до создания ключа/файлов; формат, криптография и файловое владение сохранены.
+    Регрессии: все256 значений байта,92 допустимых;8 ранних отказов writer/send,3 roundtrip,
+    7 отказов чтения аутентифицированных плохих метаданных. Проверены прежние выходы, файлы, fd/temp и отсутствие ключей/worker.
+    ./build.sh --no-gui -j4 PASS; профиль10/10 и ASAN/UBSan/LSan4/4 PASS, detect_leaks=1.
+    Логи: /tmp/media-mime-fix-build.log, /tmp/media-mime-fix-profile-results.log,
+    /tmp/media-mime-sanitizer-results.log. Полный check и Windows/FreeBSD для этого фикса не запускались.
+    Подробности: [media_async_audit_findings.txt](media_async_audit_findings.txt). Сверка описаний завершена.
+
+[+] **media_delivery: проверять записи SQLite перед переанонсом локальных блоков** — исправлено 24.10.2026.
+    Прежний announce_local_blocks не проверял длины media_id/block_id, диапазон chunk и полный chat_id.
+    Реальный обработчик отправил все7 повреждённых записей: UUID длиной1/17 байт, chunk=-1/2^32, chat_id=111junk.
+    При UUID длиной1 байт остальные15 байт сетевого поля взяты за границей BLOB;
+    chunk=-1 превращается в4294967295, 2^32 — в0, 111junk — в группу111.
+    Стенд использует настоящие SQLite/Ed25519; отправка перехвачена, пакеты в реальную сеть не уходят.
+    Воспроизведение: /tmp/media-announcement-audit.c и .mk; лог: /tmp/media-announcement-audit.log.
+    Реализованы проверки типов/точных длин UUID, chunk через int64 и канонического ненулевого decimal chat_id
+    до копирования/кастов/отправки. Плохие строки пропускаются с WARN; prepare/bind/step/finalize проверяются.
+    UUID копируются до вложенных SQL. Сохранены void API, поштучные анонсы и формат wire.
+    test_media_delivery_sql: 36 случаев полей (32 отказа/4 корректных), смесь2/3 и5 SQL faults с recovery.
+    Проверяются точные wire UUID/group/chunk, отсутствие оставшихся statements и ERROR вместо успешного лога при отказе SQL.
+    Сборка PASS; профильные12/12 и ASAN/UBSan/LSan4/4 PASS, detect_leaks=1, все встроенные зависимости инструментированы.
+    Логи: /tmp/media-announcement-fix-profile-results.log, /tmp/media-announcement-fix-sql-final.log,
+    /tmp/media-announcement-sanitizer-results.log. Полный check и Windows/FreeBSD не запускались.
+    Архитектура, границы воспроизведения и регрессии: [media_async_audit_findings.txt](media_async_audit_findings.txt).
+    Последующая сверка описаний двух каталогов завершена; итог указан в начале списка.
+
+[+] **media_async voice_file: согласовать верхнюю границу длительности с метаданными** — исправлено 24.10.2026.
+    Прежняя проверка samples/channels/rate >86400 пропускала полные кадры 24ч+20..980мс,
+    хотя attachment_validate отклоняет duration_ms >86400000. В штатном pipeline это означает
+    лишнюю подготовку файла перед отказом публикации; дефект относится к граничным записям длиннее суток.
+    Диагностический вызов реального voice_file_encode с остановкой на создании Opus:
+    60 случаев, все пять частот и 1/2 канала; 20 подтверждённых расхождений проверки.
+    /tmp/media-voice-duration-repro.c, /tmp/media-voice-duration-repro.mk, /tmp/media-voice-duration-repro.log.
+    Реализован общий предел миллисекунд в attachment.h; voice_file проверяет 25..4320000 полных кадров
+    до создания encoder/открытия output. Валидатор и video completion используют тот же предел.
+    test_attachment: 120 граничных случаев; 70 ранних отказов, прежний файл и metadata сохранены.
+    Настоящий Opus encode/decode: 11 записей, включая 500мс с хвостом для всех пяти частот и 1/2 канала.
+    Границы метаданных voice/video 86400000/86400001мс проверены через validate/encode/decode.
+    ./build.sh --no-gui -j4 PASS; профильные тесты 10/10 PASS, включая DM, encrypted attachments и video.
+    Логи: /tmp/media-voice-fix-build.log, /tmp/media-voice-fix-profile-results.log, /tmp/media-voice-fix-profile-logs/.
+    Подробности и ограничения воспроизведения: [media_async_audit_findings.txt](media_async_audit_findings.txt).
+    На этом этапе новые полный check и sanitizer-прогоны не выполнялись; последующие проверки и итог аудита указаны выше.
+
+[+] **media_async encrypted_file: не уничтожать source через alias назначения** — исправлено 24.10.2026.
+    write/read отвергают только одинаковые строки; /./ и hardlink обходят проверку одного файла.
+    write возвращает0, заменяя исходные30 байт контейнером пустого файла; read возвращает0,
+    заменяя входной ciphertext182 байта plaintext30 байт. Проверены реальные функции, inode и SHA256.
+    Реализован один file_io_temp в ak_file; codec готовит закрытый проверенный temp,
+    worker публикует его одним rename. Target не открывается с усечением; alias проверяется до work и перед publish.
+    Durability задаётся на весь срок temp; ошибка directory sync после rename не считается откатом.
+    Cleanup удаляет только собственные артефакты; crash recovery учитывает temp в media и decrypted.
+    DM не вызывает codec: сохранить его контракт общих sync/publish helpers при изменениях file_io.
+    Детали, проверка архитектуры исправления и незавершённый аудит: [media_async_audit_findings.txt](media_async_audit_findings.txt).
+    Воспроизведение: /tmp/media-encrypted-alias-repro.c, /tmp/media-encrypted-alias-repro.log.
+    Добавлены восемь alias-сценариев, 23 отказа I/O с контролем fd/temp/метаданных,
+    отмена настоящего worker после rename до completion, startup/restart обоих деревьев.
+    Профильные21/21 и основной make check185/185 PASS; proxy9/9, burst1/1, load8/8 PASS
+    в отдельном network namespace,134217728 проверенных байт. ASAN/UBSan/LSan21/21 PASS, detect_leaks=1.
+    Логи: /tmp/media-fix-full-check.log, /tmp/media-fix-network-check.log, /tmp/media-fix-sanitizer-results.log.
+    Последующий аудит остальных контрактов media_async/media_delivery завершён; Windows/FreeBSD не проверялись.
+
+[+] **Proxy: исправить HUP/backpressure, владение и rollback** — завершено 24.10.2026.
+    Согласованный проект, причины и результаты: [doc/proxy_fix_plan.txt](proxy_fix_plan.txt).
+    HUP больше не обходит read_high_water/ручную паузу; idle HUP снимается с poll,
+    low_water восстанавливает регистрацию с новой generation, запись остаётся независимой.
+    Общими UDP/ICMP владеет instance; TCP-модули освобождают только свои ресурсы.
+    Proxy закрывается до групп/транспорта. Listeners/mappings обязательны, частичный запуск откатывается.
+    Raw ICMP запускается отдельно: EPERM сохраняет клиентские REPLY и TCP/UDP; остальные ошибки запуска фатальны.
+    UDP проверяет создание flow, таймеры и точную отправку; нулевой payload и EINTR обработаны.
+    Поздний WINDOW завершённого sid — DEBUG drop. Неверный enabled убран из серверных тестовых конфигов.
+    Штатный TLS shutdown проходит без EPIPE/ENOTCONN; abrupt сохраняет реальные ошибки TCP.
+    Оба TLS-режима: 16 byte-exact загрузок. Настоящий raw ICMP и явный loopback PASS.
+    test_proxy_lifecycle: 25/25 сценариев отказов без утечек fd/памяти; test_tcp_io: 19/19, epoll/poll HUP.
+    Основной make check: 185/185 PASS. Общий check.sh сначала не уложился в141с,
+    затем TUN-этапу помешал занятый другим процессом UDP15002. TUN-тесты повторены
+    с тем же бинарником в отдельном network namespace: proxy9/9, burst1/1, load8/8 PASS,
+    134217728 проверенных байт. ASAN/UBSan/LSan: 16/16 и отдельный raw ICMP PASS, detect_leaks=1.
+    Логи: /tmp/proxy-fix-full-check2.log, /tmp/proxy-fix-network-check.log,
+    /tmp/proxy-fix-sanitizer-results.log, /tmp/proxy-fix-icmp-raw.log.
+    Windows/FreeBSD runtime не проверялся.
+
+[ ] **ETCP: полезная утилизация нескольких каналов и доставка при зависании части линков** — общая задача открыта.
+    После push исследован одиночный дуплекс2Мбит/с на изолированной базе a198cfb9.
+    Точные7763 ACK показывают задержку обратной очереди: пример DATA15.909мс, hold0.029мс,
+    обратный ACK32.219мс; DOWN продолжает ждать flight7644 при цели5915байт.
+    Контрольный20-секундный замер1.726/1.658Мбит/с, retries=0; простой ACK-резерв/округление/уменьшение бюджета
+    не дают устойчивого прохождения. Предел окна DOWN сокращает фазу до6..22мс, но короткий FAIL1.656 остаётся.
+    Прототипы не перенесены в рабочий ETCP/BBR. Добавлены сценарий duplex-slow и UTUN_MULTIPATH_SAMPLE_MS=1000..60000
+    для длительных замеров; прежние пороги сохранены. Далее — причины остановки DATA в CRUISE/REFILL:
+    физическое окно, общий admission budget и pacer; подробные данные/команды — doc/etcp_multipath_plan.txt.
+    24.10.2026: исправлены RTT. min_rtt наследует метку короткого минимума, вместо омоложения кеша каждым ACK;
+    прежний минимум20мс заменяется после10с своего возраста (прежде15с). Метки/hold PROBE_RTT используют полные uint64 TB;
+    проверены 32-битная граница, нулевые младшие32бита срока, длительный idle, hold>=200мс и ACK-раунд.
+    Исправлено замораживание DATA-измерений при скачке RTT: RTO берёт max(DATA EWMA, timestamp-RTT своего линка).
+    Формула1.2*RTT+1.5*DATA_jitter+3мс и clamp10мс..1с сохранены; BBR обновляют только действующие DATA ACK.
+    Новый профиль rtt-change:20->100->20мс, проверяет обновление RTT, снятие stalled, старение/снижение minRTT и доставку.
+    DATA-измерения возобновились примерно за203мс, после перехода повторов нет; minRTT103.794мс, после возврата23.941мс.
+    До фикса стенд дал2035 повторов и остановку DATA ACK-модели; отдельная регрессия настоящего retrans-таймера также FAIL.
+    Пересчёт attempts-таймера вызывается и при сокращении timestamp-RTT без новых DATA/ACK: регрессия123->27мс
+    до фикса сохраняла96мс лишнего ожидания. Пересчёт идёт до внешнего RTT callback, который может закрыть conn/линк;
+    OOM таймера также безопасно закрывает conn из RX. Негативный ASAN-тест ловит UAF при обратном порядке.
+    BBR24/24; test_etcp_windows63 сценария в обоих режимах часов PASS; четыре ASAN/UBSan-теста и ASAN rtt-change без ошибок/утечек.
+    Check.sh186/186, proxy9/9, burst1/1, load8/8 PASS,134217728 проверенных байт,189с после последней правки.
+    Полная матрица: первые6 скоростных профилей, все9 отказов и rtt-change PASS; остался1 FAIL2Мбит/с:1.662<1.700.
+    Одиночный8Мбит/с7.076/7.019, агрегат8.737/8.717 из10. Далее —2Мбит/с, STCP backpressure, смена RTT нескольких путей/BW и повторный отказ.
+    Логи/CSV /tmp/etcp-rtt-complete-* и /tmp/etcp-rtt-close-*;8652 среза проверены, отдельные332 RTT: /tmp/etcp-rtt-complete-rtt-change.csv/.html.
+    Детали: doc/etcp_multipath_plan.txt. Предыдущий этап — исправление BW:
+    24.10.2026: исправлена недооценка BW растянутыми ACK: достоверный RX clock заменяет ACK clock,
+    interval=max(send_us,ceil(delivered*delta_rx_us/delta_rx_bytes)); без RX-базы/прогресса max(send_us,ack_us).
+    Сохранены send-граница, проверка пары/переполнения/idle и логические ACK; wire/RTT/RTO/окно не менялись.
+    DEBUG ACK показывает исходные интервалы и выбранные часы. До фикса точная регрессия FAIL, после PASS.
+    test_etcp_windows: 61 сценарий с обоими режимами часов PASS; BBR 20/20, восемь ASAN/UBSan-тестов без ошибок/утечек.
+    Check.sh 186/186, proxy 9/9, burst 1/1, load 8/8 PASS, 134217728 проверенных байт, 201с.
+    Полная последовательная матрица: все 7 скоростных и 9 отказных профилей PASS; дуплексный агрегат 8.768/8.789 из10.
+    Три прогона рабочего кода: одиночный 8Мбит/с даёт 7.045..7.081 в обе стороны, агрегат проходит каждый раз.
+    Ранних ACK-пакетов 0; steady retries=0; ACK на одиночном 8Мбит/с пути 0.170..0.180Мбит/с.
+    Остаётся нестабильность одиночного дуплекса 2Мбит/с: один повтор дал 1.672<1.700Мбит/с.
+    Далее — этот недобор, STCP backpressure, отдельные проверки смены RTT/BW и повторного отказа.
+    Обнаруженный на этом этапе дефект возраста min_rtt исправлен и проверен следующим этапом выше.
+    Логи/CSV: /tmp/etcp-rx-clock-*; 8372 среза проверены, HTML /tmp/etcp-rx-clock-matrix.html.
+    Подробности и предыдущие этапы: doc/etcp_multipath_plan.txt.
+    Предыдущий этап — диагностика до исправления ACK:
+    Продолжение 24.10.2026: диагностика срезов 100 мс (настройка 10..1000 мс), 104 поля; CSV и лог буферизуются до drain.
+    Видны очереди, callbacks/deferred waiter, DATA/ACK, flight/cwnd, BBR/RTT/RTO, долг/готовность pacer и канал эмулятора.
+    tools/etcp_diag_report.py проверяет CSV и строит автономные интерактивные графики с исходными срезами.
+    Дуплекс: 598 срезов; two-stuck/ASAN: 5208/5196 срезов, без ошибок sanitizer/утечек; CHECK сохраняет накопленный лог.
+    Итоговый check.sh 184/184, proxy 9/9, burst 1/1, load 8/8 PASS, 166 с; JS smoke-проверка графиков/фильтров PASS.
+    На одиночном 8 Мбит/с пути ACK занимают 0.347/0.390 Мбит/с, среднее ожидание ACK-only 230/271 мкс вместо окна 2 мс.
+    В срезах side=1 path=1 DATA готовы, а BBR задаёт около 6.3 Мбит/с; PROBE_RTT временно уменьшает окно до 32.9 тыс. байт.
+    Дедлайн обходит посторонний wake sender. Дальше разбирать абсолютные deadlines ACK; простого !timer недостаточно.
+    Алгоритмы протокола на этом этапе не менялись; полный дуплекс всё ещё не проходит скоростные пороги (5 нарушений, 8.513/8.337).
+    Логи/CSV: /tmp/etcp-duplex-diag-*; просмотр: /tmp/etcp-duplex-diag-view.html; детали — doc/etcp_multipath_plan.txt.
+    24.10.2026: реализованы сканирование send_q с приоритетом готовых повторов и ограниченная подгрузка новых DATA.
+    Заблокированный пакет пропускается. История путей пакета (32 байта) исключает новый обход до перебора допустимых;
+    история/RR фиксируются после принятого send, удаление линка очищает слот до callbacks/повторной выдачи ID.
+    После 3 RTO без ACK-прогресса tx_stalled исключает путь из повторов при наличии незастрявшего UP-пути.
+    Все застрявшие пути допускаются, новые DATA сохраняют прежний выбор; действующий ACK отправки после флага снимает его.
+    Старый/чужой ACK не восстанавливает путь; reset очищает состояние. Новых очередей/таймеров/копий нет, RTO сохранён.
+    Windows: 51 сценарий PASS с управляемыми/реальными часами; восемь ASAN/UBSan-тестов без ошибок/утечек.
+    Контроль занятого на 1 мс рабочего пути: latency 377.012 вместо 736.623 мс, ready_wait 2.318 мс, профиль PASS.
+    Отрицательный контроль задержки готового повтора 200 мс остаётся FAIL по очереди и общей задержке.
+    Полная последовательная multipath-матрица: все 9 профилей отказов PASS, первые 6 скоростных профилей PASS.
+    Two-stuck: latency 379.997 мс при пределе 462.219 мс; ещё 3/3 повтора — 374.981..378.557 мс.
+    Load-drop/load-hold: паузы 39.234/39.355 мс, steady goodput 7.221/7.468 из 8 Мбит/с.
+    Max latency под насыщенной нагрузкой 161.287/86.306 мс записана; отдельным порогом она здесь не ограничена.
+    Two-stuck/load-drop также проходят ASAN/UBSan с detect_leaks=1 без ошибок/утечек.
+    Остаётся дуплекс: 8.412/8.435 из 10 Мбит/с, все 7 нарушений матрицы — его скоростные пороги.
+    Далее — дуплекс, STCP backpressure, отдельные проверки смены RTT/BW и повторного отказа.
+    Полный check.sh: 184/184, proxy 9/9, burst 1/1, load 8/8 PASS, 134217728 проверенных байт, 197 с со сборкой.
+    Длинная multipath-матрица запускается отдельно; её общий результат остаётся FAIL из-за дуплекса.
+    Логи: /tmp/etcp-send-scan-*.log; подробности — doc/etcp_multipath_plan.txt.
+    Предыдущая диагностика:
+    24.10.2026: тесты отдельно проверяют обработку RTO (опоздание<=20мс), ожидание готового повтора (<=100мс)
+    и доставку сверх заданной задержки канала (<=100мс). TX учитывается после принятия send.
+    Быстрые профили сохраняют общий предел100мс; длинные учитывают по одному RTO отказавших путей плюс100мс.
+    Остальные8 профилей PASS; two-stuck нестабилен: обычный прогон дал738.317мс при пределе459.332мс,
+    история фрагмента324 —1->2->1->2->0. Готовый повтор не застревает: лишнее ожидание создаёт ещё один круг RTO.
+    Контроль с занятостью рабочего пути всего1мс воспроизводит736.623мс latency и534.548мс паузы;
+    точный лог показывает свободное окно рабочего пути и ожидание pacer при выборе2->1.
+    Контроль задержки уже готового повтора на200мс проваливает новую проверку очереди, а не маскируется бюджетом RTO.
+    Slow-drop/two-stuck/load-drop проходят ASAN/UBSan с detect_leaks=1 без ошибок/утечек.
+    Полный check.sh184/184, proxy9/9, burst1/1, load8/8 PASS,134217728 байт,161с; multipath запускается отдельно.
+    Перед изменением транспорта отдельно проработать выбор путей без DATA-прогресса, ограниченные пробы
+    и восстановление, сохраняя физический UP и защиту от поздних ACK. Ранние копии исключены; дуплекс не менялся.
+    Логи: /tmp/etcp-recovery-stages-*.log/.csv; подробности — doc/etcp_multipath_plan.txt.
+    Предыдущий этап:
+    24.10.2026: повтор ждёт другого initialized+UP канала, даже когда прежний уже готов.
+    При отсутствии таких альтернатив разрешён прежний; DOWN последней альтернативы будит sender.
+    Новых состояний/ресурсов/таймеров нет. ACK/control и burst-FILLER не блокируются ожиданием DATA.
+    Регрессия до исправления воспроизводит возврат на прежний путь; после — windows44 сценария
+    с управляемыми/реальными часами PASS, восемь ASAN/UBSan-тестов без ошибок/утечек.
+    Полный check.sh184/184, proxy9/9, burst1/1, load8/8 PASS,134217728 проверенных байт,161с.
+    Профили отказов:7/9 PASS. load-drop/load-hold проходят каждый3/3, паузы39.796..44.982мс,
+    steady goodput7.189..7.476 из8Мбит/с оставшегося канала. Пороги сохранены.
+    Slow-drop остаётся FAIL: пауза238.569мс, latency264.727мс; two-stuck219.338/380.177мс.
+    В них4 нарушения порогов; доставка/порядок/ресурсы проходят. Полная скоростная матрица не повторялась.
+    Трейс показал ожидание первого RTO на медленном пути и повторный выбор прежнего пути под нагрузкой;
+    ожидание в хвосте send_q в этих опытах не объясняет основную паузу (максимум2.6/3.5мс).
+    Ранние копии до RTO исключены пользователем24.10.2026. При UP повтор ждёт RTO своего пути;
+    закрытие линка по-прежнему возвращает недоставленные DATA без ожидания RTO.
+    При RTT200мс RTO уже243мс без jitter: порог паузы100мс этого ожидания не учитывает.
+    Пороги тестов не менялись; дальше отдельно оценивать ожидание RTO, готовность повтора и доставку.
+    Остаются здоровье/пробы каналов, STCP backpressure и дуплекс; спекулятивных ранних копий в плане нет.
+    Логи: /tmp/etcp-retry-alternative-*.log/.csv; диагностический observer — /tmp/etcp-recovery-probe.c/.mk.
+    Предыдущий контроль после исправления pacer: таймер ждёт первого разрешённого TB, а не погашения всего долга;
+    кредит1мс, BBR/cwnd/min_rtt, RTO и wire-формат сохранены. Нового состояния и ресурсов нет.
+    До исправления регрессия получает10TB вместо1TB; после него18 сочетаний долга/дроби проходят.
+    Проверены INT_MAX, ранний/поздний callback, ограниченный burst, OOM повторного таймера,
+    rate change и reset/close из настоящего uasync callback. Windows42 сценария PASS с обоими режимами часов;
+    восемь профильных тестов ASAN/UBSan с detect_leaks=1 без ошибок/утечек.
+    check.sh184/184, proxy9/9, burst1/1, load8/8 PASS (134217728 байт),162с.
+    Полная последовательная матрица c7a53009 с прежними порогами: FAIL,14 нарушений —
+    8 скоростных проверок дуплекса и6 проверок пауз/задержек slow-drop,two-stuck,load-drop/load-hold.
+    Equal14.438/16, bandwidth9.052/10, RTT20/200:14.299/16Мбит/с; первые6 скоростных профилей PASS.
+    Дуплекс8.394/8.458 из10Мбит/с остаётся FAIL. Drop-forward PASS: пауза58.001мс, задержка83.656мс.
+    Паузы slow-drop/two-stuck/load-drop/load-hold:239.421/201.381/213.644/208.899мс;
+    задержки slow-drop/two-stuck:264.044/482.693мс. Доставка, порядок и контроль ресурсов проходят.
+    Это один прогон; сравнение с исходными15 нарушениями не доказывает устойчивое улучшение всей матрицы.
+    Далее отдельно разбирать ограничения BBR/cwnd и PROBE_RTT, здоровье линков и STCP backpressure.
+    Результаты/план: doc/etcp_multipath_plan.txt; /tmp/etcp-pacer-ready-matrix.log/.csv,
+    /tmp/etcp-pacer-ready-{windows-final,real-time,full-check}.log и /tmp/etcp-pacer-ready-asan-test_*.log.
+    Реализованы начальный pacing от 4*MSS/RTT, точные DATA B/s и ограниченный кредит shaper,
+    разделение логического seq/payload и физических attempt_id, ACK/RTT/RTO каждого пути,
+    ротация повторов A→B→C→A при UP-каналах, rollback отказавшего send и запрос потерянного till.
+    Wire attempt_no сокращён до2 байт, общий для всех каналов одного seq; внутренний ключ — (seq<<16)|attempt_no.
+    DATA header7 вместо13 байт, ACK entry10 вместо16. Номер1..65535; исчерпание номера/seq меняет эпоху через REINIT.
+    Normalizer не менялся. Пара seq/номер не повторяется в одной эпохе; старые ACK отсекаются до разбора.
+    Проверка компактного формата: windows38 сценариев, session/BBR/transport/init_liveness PASS;
+    те же5 тестов ASAN/UBSan с detect_leaks=1 без ошибок/утечек. check.sh184/184, proxy9/9, burst1/1, load8/8 PASS.
+    bandwidth2+8 RTT20/20:8.715Мбит/с, retries=0, профиль PASS. Логи: /tmp/etcp-attempt16-*.log/.csv.
+    RTO=clamp(ceil(1.2*RTT+1.5*jitter+3мс),10мс,1с), округление до мкс. Пределы: попытки 16384/линк,
+    32768/соединение, ACK 16384/линк. Без RTT начальный RTO=1с.
+    STARTUP завершается после целого раунда устойчивой очереди выше бюджета, без искусственного изменения BW.
+    BBR20/20, windows26 сценариев PASS; восемь тестов ASAN/UBSan с detect_leaks=1 PASS; основной набор183/183 PASS.
+    check.sh завершён успешно; дополнительные tcp_proxy_full/burst/load PASS (8 соединений,134217728 проверенных байт).
+    Полная штатная multipath-матрица до смены формулы RTO: FAIL, 20 нарушений. Есть недобор RTT20/200мс и bidirectional;
+    slow-drop даёт паузу401мс, два зависших пути676мс, DROP/HOLD под нагрузкой229–243мс.
+    После смены RTO один полный прогон даёт 15 нарушений: slow-drop244мс, two-stuck278мс,
+    load-drop/load-hold96/83мс; установившиеся интервалы исправных каналов без повторов.
+    windows31 (20 наборов проверки реального RTO), BBR20/20, session/transport PASS;
+    windows/session/transport ASAN/UBSan с detect_leaks=1 PASS. Логи: /tmp/etcp-rto-margin-*.log.
+    Jitter-контроль RTT20/200мс: при случайной добавке 0..10/30мс новая формула даёт отдельные лишние повторы,
+    старая в контрольном прогоне — без повторов. При jitter30мс скорость снижена у обеих формул;
+    коэффициенты не объявлены оптимальными. Логи: /tmp/etcp-rto-jitter-review.log, /tmp/etcp-rto-jitter-old.log.
+    Последний check.sh после смены RTO: 182/183, FAIL только test_bgp_route_exchange (повтор отдельно с debug PASS).
+    test_encrypted_attachment в этом прогоне PASS; воспроизведённый ранее дефект media остаётся открытым.
+    Логи: /tmp/etcp-rto-margin-full-check.log, /tmp/etcp-rto-margin-bgp-repeat.log.
+    Три прогона скоростей: 8+8 RTT20/20 — 13.868..14.083Мбит/с; RTT20/200 — 13.567..13.951;
+    2+8+2 RTT20/80/200 — 10.566..10.749 из12; 2+8 одновременно в обе стороны — 8.080..8.379 из10 на направление.
+    DATA-повторов в измеряемых исправных интервалах нет. Подробные результаты: /tmp/etcp-multilink-quality-20261023.csv/.txt.
+    BGP-падение из-за INIT/remote_keepalive исправлено; отдельная задача ниже содержит итог проверки.
+    Дуплекс проверен18 последовательными опытами в /tmp/etcp-duplex-native/, исходники проекта не менялись.
+    ACK compression завышает BW:170502 байта приняты за186.36мс, sender sample использует150.73мс.
+    Нативный прототип counter/time в ACK сокращает пики очереди до23.1мс вместо52.9мс, но все скоростные пороги не проходит.
+    Коэффициент282/256+3мс и запас10мс при busy-флаге не дали устойчивого выигрыша, пики очереди выросли до35.5/33.7мс.
+    В штатном агрегате ACK занимает0.515..0.559Мбит/с на направление (5.15..5.59% полосы), большая часть — ACK-only.
+    Реализована только коррекция BW по точке приёма:16 байт добавляются при count>0, пустой ACK остаётся8-байтовым.
+    Перестановка/дубли ACK, независимые часы, простой/reset, переполнения и границы MTU/формата проверены.
+    Windows35 сценариев и ещё4 профильных теста PASS, те же5 тестов ASAN/UBSan без ошибок/утечек;
+    check.sh184/184, proxy9/9, burst1/1, load8/8 PASS (/tmp/etcp-bw-correction-full-check.log).
+    Отдельный дуплекс2+8 RTT20/80:8.223/8.182Мбит/с, пики очереди агрегата22.8мс, retries=0;
+    профиль остаётся FAIL по5 прежним порогам скорости. bandwidth2+8 RTT20/20:8.844Мбит/с, PASS.
+    RTT20/200,8+8:13.453Мбит/с, очередь<=24мс, retries=0, FAIL по3 прежним порогам скорости.
+    Логи: /tmp/etcp-bw-duplex-final.log/.csv, /tmp/etcp-bw-{bandwidth,rtt}.log/.csv, /tmp/etcp-bw-asan-*.log.
+    Объединение ACK в пределах прежнего дедлайна2мс отложено; окно/RTT/RTO и политика ACK не менялись.
+    Дуплексный запас и busy-флаг не добавлялись и не считаются подтверждённым исправлением.
+    One-way->duplex->one-way:3/3 PASS; ASAN/UBSan не нашли ошибок/утечек, скоростной профиль остаётся FAIL.
+    Подробности/уточнённый план: doc/etcp_multipath_plan.txt; результаты: /tmp/etcp-duplex-native/results.json,
+    /tmp/etcp-duplex-native/summary.csv и ack_bandwidth.csv. Политика окна прототипов в репозиторий не переносилась.
+    Здоровье/пробы каналов и STCP backpressure пока не реализованы; ранние копии исключены, пороги тестов сохранены.
+    OOM после принятия данных исправлен аварийной сменой эпохи с сохранением физических линков.
+    Старый поток отбрасывается без воспроизведения; после согласования владельцы получают REINIT.
+    Очистка reset не выделяет память; убрана реконструкция inflight, новых OOM-очередей/таймеров нет.
+    Проверены отказы RX/TX, flush/waiter/session-таймеров, RNG, reset/close из callback и ноль выделений при reset.
+    windows31 сценарий, queue_regressions77/77 и шифрованное восстановление обеих сторон PASS;
+    десять тестов ASAN/UBSan с detect_leaks=1 PASS. Далее — здоровье каналов; ранние повторы исключены.
+    После OOM-правок полный check.sh: 181/183; FAIL BGP route exchange и encrypted attachment.
+    BGP отдельно с диагностикой PASS; encrypted attachment повторно FAIL из-за удаления активного temp кешем (задача ниже).
+    Отдельно proxy9/9, burst1/1 и load8/8 PASS (134217728 проверенных байт); /tmp/etcp-oom-reinit-proxy-check.log.
+    План и подробные результаты: [doc/etcp_multipath_plan.txt](etcp_multipath_plan.txt).
+    Логи: /tmp/etcp-attempts-matrix.log, /tmp/etcp-attempts-asan-test_*.log,
+    /tmp/etcp-oom-reinit-asan-test_*.log, /tmp/etcp-abort-encrypted-recovery.log.
+
+[+] **Crypto: повторное освобождение ключа после отказа инициализации потоковой подписи** — исправлено 24.10.2026:
+    Оба init создают ключ и SHA-512-контекст локально, заполняя state только после полного успеха.
+    Перед первым использованием state={0}; отказ оставляет его пустым. Повторный init активного state
+    отклоняется без потери ресурсов и накопленного хеша. Cleanup обнуляет все поля и допускает повторы.
+    Final проверяет capacity до финализации; недостаточный буфер позволяет повторить вызов с сохранённым хешем.
+    Контракты и обработка ошибок отражены в .h и примере документации; формат подписи прежний.
+    Регрессия до исправления падает на непустом state после отказа EVP_MD_CTX_new.
+    Проверены 6 отказов init, 8 отказов final/verify, 4 сочетания повторного init, capacity0/63/64,
+    повторная очистка/использование и совпадение с независимой one-shot подписью SHA512 сообщения.
+    Тесты не перехватывают free. Восемь профильных тестов ASAN/UBSan с detect_leaks=1 PASS;
+    check.sh184/184, proxy9/9, burst1/1, load8/8 PASS. Пример документации компилируется с -Werror.
+    Логи: /tmp/sc-sign-regression-before.log, /tmp/sc-sign-fix-full-check.log, /tmp/sc-sign-fix-asan-*.log.
+
+[+] **Media: очистка кеша удаляла временный файл активной загрузки** — исправлено 24.10.2026:
+    file_io хранит общий защищённый mutex реестр владельцев temp по фактическим нормализованным путям.
+    Владение сохраняется от создания до publish/discard, включая интервал после finish; очистка кеша
+    проверяет владение и удаляет сироту под тем же mutex. Угадывание суффиксов не используется.
+    Регрессии проверяют открытый/закрытый temp, барьеры создания/finish и очистку после реального BLOCK_CHUNK.
+    Полный check.sh: 184/184, proxy9/9, burst1/1, load8/8 PASS; пять профильных тестов ASAN/UBSan PASS,
+    test_encrypted_attachment дополнительно повторён пять раз без отказов.
+    Логи: /tmp/media-orphan-full-check.log, /tmp/media-orphan-asan-*.log, /tmp/media-orphan-repeat-*.log.
+
+[+] **ETCP: входящий INIT сохранял устаревший признак обратной достижимости** — исправлено 23.10.2026:
+    Принятый INIT обновляет RX и remote_keepalive до переиспользования буфера для ответа; flag_up=0 снимает ложный UP.
+    INIT/INIT_RESPONSE и обычный RX публикуют переходы живости с защитой от close/удаления линка из callback.
+    При DOWN handshake продолжает ответ/keepalive; исправный второй линк сохраняет UP соединения.
+    INIT_RESPONSE проверяет длину тела (>=64 байт без timestamp/flag_up) и node_id до изменения состояния.
+    Раньше проверка общей длины принимала усечённое тело 61..63 байта. Новых таймеров/очередей/полей нет.
+    test_etcp_init_liveness: 130 отказов без изменения link/conn и передачи владения pkt, 12 допустимых ответов;
+    оба направления односторонней потери, оба порядка ключей, восстановление без смены эпохи, резервный линк,
+    close и удаление link из INIT/keepalive callback PASS, также с обычными часами.
+    Семь профильных тестов ASAN/UBSan с detect_leaks=1 PASS; дополненный тест удаления link повторён отдельно.
+    BGP route exchange: 100/100 PASS (A<B:48, A>B:52; последние пять с debug). Основной набор: 184/184 PASS.
+    Логи: /tmp/etcp-init-boundary-before.log, /tmp/etcp-init-final-{liveness,realtime,asan-liveness}.log,
+    /tmp/etcp-init-fix-asan-test_*.log, /tmp/etcp-init-bgp-stable-*.log, /tmp/etcp-init-fix-full-check.log.
+
+[+] **ETCP/BBR: бюджет очереди в установившемся режиме** — реализовано 23.10.2026 по выбору пользователя:
+    В PROBE_BW окно ограничено max(4*MSS, BDP + BW*20мс), с насыщением арифметики и учётом ACK/PROBE_UP резервов
+    внутри общего предела. Ограничение применяется также на fast path и до callback. 0 отключает политику.
+    STARTUP/DRAIN не ограничены этим бюджетом; это мягкая цель модели, а не гарантия физической очереди <=20мс.
+    До политики bandwidth давал очередь 47.1–47.9мс >40мс при корректных единицах и сложении резервов;
+    после политики профиль проходит по скорости и очереди, equal также PASS. Разные RTT и отказы не закрыты.
+    BBR 18/18, windows 16 сценариев PASS; BBR/windows/session/transport/STCP traffic/NCD ASAN/UBSan
+    с detect_leaks=1: 6/6 PASS. Полный check.sh: 180/183, FAIL NAT detection/fault и encrypted_attachment;
+    связь падений с BBR не установлена, отдельная открытая задача сохраняется.
+    Логи: /tmp/etcp-queue-budget-fastpath.log, /tmp/etcp-queue-budget-windows.log,
+    /tmp/etcp-queue-limited-asan-results.log, /tmp/etcp-queue-limited-asan-test_*.log,
+    /tmp/etcp-queue-limited-full-check.log. Политика описана в etcp_bbr.h, etcp_bbr_doc.md и doc/etcp_protocol.txt.
+
+[+] **ETCP/BBR: единое окно DATA и корректное осушение PROBE_RTT** — исправлено 23.10.2026:
+    BBR использует MSS=normalizer->frag_size, а не wire-MTU/размер STCP-кадра. Начальное окно UDP/STCP равно 4*MSS;
+    MTU пересчитывается после включения нового линка в список. init_cwnd инициализируется четырьмя фрагментами.
+    Транспорт применяет положительное окно с верхним ограничением bbr_max_cwnd, не поднимая его до 8192.
+    INFLIGHT_LIM_MIN=8192 остаётся нижней допустимой границей настройки максимального окна; нулевое окно отклоняется с логом.
+    PROBE_RTT осушает до max(4*MSS, 0.5*BDP), ждёт >=200мс и раунд ACK, затем восстанавливает предыдущее окно.
+    Отправленные при осушении DATA помечаются app_limited. Ограничения после потерь больше не уменьшают окно ниже 4*MSS.
+    BBR 15/15, отправитель 16 сценариев; ETCP session/transport, STCP traffic и NCD PASS.
+    Те же шесть тестов ASAN/UBSan с detect_leaks=1: 6/6 PASS, ошибок и утечек не обнаружено.
+    Общий check.sh: 181/183, FAIL test_nat_detection_faults/test_nat_detection (contact_history/UNKNOWN);
+    test_encrypted_attachment в этом прогоне PASS. NAT-падения и отдельный повтор отмечены следующей открытой задачей.
+    Логи: /tmp/etcp-probe-test_*.log, /tmp/etcp-probe-asan-results.log, /tmp/etcp-probe-asan-test_*.log;
+    полный прогон: /tmp/etcp-probe-full-check.log.
+    исходные нарушения: /tmp/etcp-probe-contract-{bbr,windows}-before.log, /tmp/etcp-probe-lossfloor-before.log.
+
+[+] **ETCP/BBR: байтовые единицы, delivery clock и независимость ACK от локального DATA-pacer** — исправлено 23.10.2026:
+    Устранено повторное умножение на MSS при расчёте pacing/BDP: доставка 1MB/s давала 570240000B/s при MSS=576,
+    теперь cruise pacing=990000B/s независимо от MSS. Q16 байт/мкс сохраняет многогигабитные оценки;
+    выходы pacing/BDP/cwnd и рост inflight_hi насыщаются вместо переполнения.
+    PROBE_UP растит inflight_hi на MSS за подтверждённое окно; резерв равен 2*MSS, Reno rounds считаются в пакетах.
+    Счётчики ACK aggregation расширены до 32 бит, подтверждения свыше 64KiB больше не усекаются.
+    Delivery sample использует снимки delivered/time/send-time пакета и max(send_elapsed, ack_elapsed);
+    несколько ACK в одном tick больше не создают ложный пик скорости. Суммарный delivered растёт только на новые ACKed байты.
+    ACK без DATA обходит локальный DATA-cwnd и DATA-pacer и не начисляет их нагрузку: низкая исходящая DATA-скорость
+    получателя не тормозит обратные подтверждения. Физическая очередь канала остаётся общей для DATA/ACK.
+    dummynet измеряет максимальное время очереди/сериализации отдельно от заданной propagation delay;
+    multipath проверяет его предел base_RTT+20ms наряду с полезной утилизацией, FILLER/повторы не засчитываются.
+    BBR 14/14, window/sender 14 сценариев PASS. ASAN/UBSan с detect_leaks=1: BBR/windows/calibration/session/transport/STCP/NCD 7/7;
+    после последнего исправления переполнения BBR/windows повторены отдельно. Основная multipath-задача остаётся открытой.
+    Общий check.sh перед последним исправлением переполнения: 181/183; падения вынесены отдельной задачей ниже.
+    Логи: /tmp/etcp-recovery-overflow-{before,after,windows}.log, /tmp/etcp-recovery-asan-results.log,
+    /tmp/etcp-recovery-asan-overflow-{bbr,windows}.log, /tmp/etcp-multipath-recovery-check.log.
+
+[ ] **Разобрать падения NAT detection/fault и encrypted attachment в общем прогоне** — обнаружено 23.10.2026:
+    check.sh: test_nat_detection_faults завершился assert в run_alias (ожидался inbound OPEN, получен UNKNOWN/contact_history);
+    отдельный повтор тоже упал, уже в run_case mode=5: mapping DEPENDENT корректен, inbound UNKNOWN вместо ожидаемого.
+    test_encrypted_attachment достиг phase=3/12001 heartbeat и упал; отдельный повтор завершился phase=10/560 heartbeat PASS.
+    После исправления окна BBR общий прогон снова 181/183: encrypted_attachment PASS, но FAIL оба NAT-теста.
+    test_nat_detection_faults упал в run_case mode=1 (UNKNOWN/contact_history); test_nat_detection не дождался профиля
+    за 18с на socket=udp. Его отдельный повтор тоже упал, уже на socket=second, с той же причиной contact_history/UNKNOWN.
+    После бюджета очереди полный check.sh: 180/183, повторились оба NAT-падения и encrypted_attachment.
+    Связь с изменениями BBR не установлена. Разобрать фикстуры/таймеры по логам, не ослаблять ожидания.
+    Логи: tests/logs/test_nat_detection_faults.log, tests/logs/test_encrypted_attachment.log,
+    /tmp/etcp-recovery-nat-retry.log, /tmp/etcp-recovery-attachment-retry.log,
+    /tmp/etcp-probe-full-check.log, /tmp/etcp-probe-nat-retry.log, /tmp/etcp-queue-limited-full-check.log.
+
+[+] **ETCP: единый установщик прямого транспорта через NCD** — исправлено 22.10.2026:
+    Удалён неиспользуемый рабочим кодом etcp_connect с EARLY/LATE, отдельными линками и таймерами;
+    три тестовых файла переведены на NCD handles с начала подключения. Сохранены проверки независимых владельцев,
+    отмены отложенного UP, TIMEOUT, выхода из UTUN с сохранением транспорта и shutdown с pending LEAVE.
+    Состояние реестра, физический UP, готовность ETCP-сессии и READY группы разделены в контрактах.
+    Начальный отправитель не создаёт преждевременный UP. Merkle-фикстура ждёт готовности обоих потоков.
+
+[+] **ETCP: индивидуальные окна DATA, ACK и корректный учёт повторов** — исправлено 22.10.2026:
+    Выбор линка проверяет место для целого DATA, ACK не блокируется DATA-cwnd; burst без места использует FILLER.
+    WAIT_ACK занимает окно, RTO освобождает его до постановки в WAIT_SEND; поздний ACK не вычитает байты повторно.
+    BBR получает факт ограничения окном до вычитания ACK; app_limited учитывает подготовленные данные и normalizer.
+    Один call_soon объединяет пробуждения без таймерной задержки/рекурсии; OOM retry через 10ms, reset/close отменяет token.
+    Невозможность запланировать отправку закрывает транспорт отложенно, сохраняя вызывающий стек.
+    Проверяются размер max_cwnd, переполнение суммы окон; ошибки [global] теперь отклоняют конфигурацию.
+    Новый test_etcp_windows: 12 сценариев настоящих очередей/отправителя, сверка счётчиков и внедрение отказов.
+    STCP-тест проверяет каждый байт двустороннего 1MiB трафика при окнах 8KiB и независимых тестовых командах.
+    ASAN/UBSan с detect_leaks=1: windows/session/transport/connect/stcp_traffic/SIGPIPE/NCD, 7/7;
+    результаты /tmp/etcp-asan-complete-results.log, логи /tmp/etcp-asan-complete-logs/.
+    Финальный check.sh: 182/182, TCP proxy 9/9, burst/load PASS (210s);
+    полный лог /tmp/etcp-full-check-complete.log. Ветка fix/etcp-connect-link-windows.
+
+[+] **STCP: запись в закрытый TCP-сокет завершала библиотечный процесс SIGPIPE** — исправлено 22.10.2026:
+    В общем прогоне STCP traffic завершался сигналом 13 после передачи данных, при teardown;
+    воспроизведено первым же повтором ASAN. Оба send-пути STCP используют socket_send с MSG_NOSIGNAL
+    либо SO_NOSIGPIPE; обработчики сигналов процесса не меняются. Ошибка EPIPE обрабатывается штатным путём.
+    test_stcp_sigpipe проверяет raw/buffered send в дочерних процессах с SIGPIPE=SIG_DFL.
+    20 повторов STCP traffic под ASAN/UBSan с detect_leaks=1 прошли без сигналов/ошибок/утечек;
+    логи /tmp/etcp-asan-traffic-fixed-*.log, детерминированная проверка включена в общий Linux-набор.
+
+[ ] **Аудит .h ETCP/STCP: оставшиеся расхождения контрактов** — проверено 22.10.2026:
+    stcp.h: do_close уже очищает оба sc_stream и планирует free для allocated/free_on_close; комментарий утверждает обратное.
+    Разделить контракты finish (drain/запрет новых данных/до 1с) и do_close (немедленное закрытие/потеря очередей/callback).
+    Описать владение внешними rx_queue/tx_queue, преусловия размера frame и callback/reentrancy/lifetime.
+    stcp_client.h: ping автоматически освобождается после завершения; NULL на ошибке запуска не вызывает ping callback.
+    RTT пинга — uint16_t в 0.1мс, от отправки STCP handshake, без TCP/SOCKS/REALITY dial; явно описать срок out_cli/handle.
+    inst также нужен для NTP-времени и профиля REALITY, а не только padding автономного STCP.
+    stcp_link.h/stcp_server.h: дополнить параметры, возвраты, время жизни callbacks/inst и различие handles
+    серверного адаптера stcp_server_listen и базового stcp_server_create (одно имя opaque-типа, разные реализации).
+    etcp.h: ref_count удерживает объект/phase-2, но close уже освобождает normalizer и линки в phase-1;
+    reset_done не блокирует reinit (в реализации только запись/диагностика); last_rx_id не обновляется при RX.
+    etcp_connection_ready объявлена без реализации/вызовов; рабочая функция — etcp_conn_ready.
+    etcp_connections.h проверен частично: у data_len исключены все 3 байта timestamp/flag, не только timestamp;
+    send_hook уступает SOCKS UDP; etcp_send_tcp_ping при отказе запуска возвращает отрицательный код без callback.
+    etcp_session.h и etcp_padding.h сверены с реализацией без подтверждённых смысловых расхождений.
+    Подробности: /tmp/protocol-header-audit.txt. Продолжить протоколы перед routing/BGP; media/file_transfer отложен.
+
+[+] **Android: приём рации через SCO после отпускания PTT** — исправлено 22.10.2026:
+    Общий MediaAudioController сохраняет разговорный тракт для SCO-only выхода, даже без подписчиков микрофона.
+    AudioTrack рации снова использует USAGE_VOICE_COMMUNICATION: Android учитывает playback как разговорную активность.
+    Добавлены логи фактического routedDevice/mode/SCO и аппаратная проверка после закрытия последнего input.
+    Samsung + C1 PRO: PHONE → Bluetooth → PHONE, 35с приёма без микрофона и холодный запуск SCO без PTT прошли.
+    На Q8 прошли общий захват/переключения/сохранение playback. JVM 145/145, сборки ядра и APK успешны.
+
+[ ] **Android: просмотр трансляции через SCO без работающей рации** — воспроизведено 22.10.2026:
+    Media-выход с USAGE_MEDIA после закрытия микрофона теряет SCO: mode=0, sco=false,
+    хотя общий контроллер продолжает владеть выходом и сам больше не закрывает разговорный тракт.
+    AudioService учитывает VOICE_COMMUNICATION playback/record для активности MODE_IN_COMMUNICATION.
+    Повтор: adb -s RZ8R72MG64B shell am instrument -w -e output media com.utun.chat/com.utun.chat.data.MediaAudioProbe.
+    Радио с USAGE_VOICE_COMMUNICATION проходит ту же проверку, media-вариант её не проходит.
+    Сохранить media-назначение/громкость обычных выходов; для SCO переключать аппаратный AudioTrack на VOICE_COMMUNICATION.
+    При пересоздании только аудиовыхода сохранить недописанный PCM, учесть уже записанный буфер и непрерывный played;
+    видео и его кодеки не перезапускать. Проверить оба направления смены выхода и длительный playback без микрофона.
+
+[+] **media_async: файловые примитивы и точные контракты .h** — исправлено 22.10.2026:
+    ma_copy_file проверяет существование/идентичность, сохраняет один regular-файл при ./ или hardlink;
+    ссылки назначения отклоняются, копирование идёт через соседний temp с проверенными записью/close/publish.
+    Общие примитивы lib/file_io используются также video, сохраняя публикацию видео только в completion.
+    ma_uuid возвращает ошибку RNG и обнуляет выход; media_index не регистрирует блоки при отказе media/block UUID.
+    ma_file_size и переменные вызывающего кода — int64_t; проверяются смещения, число блоков и размеры выделений.
+    Обход передаёт ошибки, пропускает ссылки/reparse points, проверяет длину/глубину; Windows использует wide API.
+    Контракты .h и service_lifecycle описывают синхронные отказы, лимит 16 до completion и отсутствие отката work при отмене.
+    Неверные аргументы дают -1, closing/destroy — CANCELLED; повторный вход в destroy диагностируется и отклоняется.
+    Новый test_media_primitives проверяет сохранность при I/O/fdopen ошибках, RNG/seek без записей блоков в БД,
+    sparse-размеры на границах 2/4 ГиБ, ошибки обхода, ссылки/глубину и ownership задач с внедрением ошибок.
+    Все шесть тестов media_primitives/video/media_index/attachment_send/services/dm_worker прошли ASAN/UBSan с detect_leaks=1.
+    Общий check.sh: 176/176 и proxy/burst/load. Windows runtime/сборка не проверялись: кросс-компилятора в окружении нет.
+    Логи: /tmp/media-primitives-full-check-final.log, /tmp/media-primitives-final.log, /tmp/media-asan-test_*.log.
+
+[+] **media_index: пути без обрезания и единая media_base** — исправлено 22.10.2026:
+    Общие location/path проверяют границу базы, компоненты и пределы UTF-8 путей (1024/512 с NUL).
+    Путь в 550 байт полностью сохраняется, читается и удаляется. Проверки предшествуют файловой подготовке.
+    Выдача использует UTF-8 file_io; загрузчик проверяет общую базу, stop/start сохраняет выбранную базу БД.
+    Писатели, backfill, выдача и удаление используют один формат; контракты находятся в media_index.h.
+
+[+] **media_index_commit: атомарная регистрация и проверяемые повторы** — исправлено 22.10.2026:
+    Единый commit регистрирует весь авторский/скачанный файл через SAVEPOINT; key=NULL означает скачанный файл.
+    Проверяются геометрия/массивы, bind/step/finalize и управление транзакцией.
+    Ошибка второго блока откатывает оба пути регистрации; обычная ошибка сохраняет внешнюю транзакцию.
+    SQLite может сама откатить её целиком — это обнаруживается и диагностируется.
+    Совпадающий повтор сохраняет node_sign и timestamp; противоречащие метаданные дают ошибку без замены старых.
+    Файловые изменения worker не входят в SQL-атомарность.
+
+[+] **Удаление канала: дождаться исходящих медиа и учесть незавершённые файлы** — исправлено 22.10.2026:
+    Канал ждёт свои video/register completions; новые исходящие задачи отклоняются до завершения удаления.
+    Последний completion продолжает удаление. Подготовленные ожидающие отправки не становятся новыми сообщениями.
+    Контекст остаётся у владельца во время синхронного MSG_SUBMITTED; повторный вход обработчика проверен.
+    До worker путь учитывается в media_preparations; успешный commit снимает запись в той же транзакции.
+    После ошибки хеширования/отмены опубликованная копия остаётся известна для очистки канала.
+    Проверены две ожидающие задачи, повтор удаления, создание того же channel_id и удаление из обработчика события.
+
+[+] **media_index_delete_channel: ошибки и повторяемая частичная очистка** — исправлено 22.10.2026:
+    Полный снимок и проверка путей предшествуют удалению; внешняя транзакция отклоняется.
+    Общие файлы других каналов сохраняются; ENOENT считается успехом.
+    SQL/файловые ошибки возвращают -1, записи неочищенных путей сохраняются для повтора.
+    Проверен отказ DELETE после unlink: повтор завершает очистку без восстановления файла.
+    Очистка включает media_preparations; ошибки очистки и удаление метаданных канала сообщаются раздельно.
+
+[+] **media_index_init: ошибки всех индексов доходят до запуска чата** — исправлено 22.10.2026:
+    Проверяется каждый CREATE INDEX. Ошибка прерывает chat_core_init с освобождением собственных ресурсов;
+    общая БД ядра сохраняется. Проверены запрет каждого индекса и успешный повтор старта после снятия запрета.
+    Дополнительно исправлены дубликат start (отказ без callback) и доступ к dl после синхронного завершения QUERY.
+    Тесты используют реальную схему БД и проверяют новый контракт владения.
+    Итог: check.sh — 177/177, proxy/burst/load PASS, 159с.
+    Девять тестов index_regressions/index/delivery_download/download_timeout/services/delivery_full/delivery_chat/attachment_send/video
+    прошли ASAN/UBSan с detect_leaks=1. Windows runtime/сборка не проверялись: кросс-компилятора нет.
+    Логи: /tmp/media-index-full-check-final.log, /tmp/media-index-final-test_media_index_regressions.log,
+    /tmp/media-index-asan-test_*.log. Новый тест: tests/test_media_index_regressions.c.
+
+[+] **media_delivery QUERY/QUERY_RESP: проверять длины до чтения записей** — исправлено 22.10.2026:
+    Проверяются точный размер, счётчики и все записи до SQL/изменений состояния. Ответ связан с media_id,
+    UUID попытки, группой и end-to-end отправителем router; дубликаты, истёкшие и старые ответы игнорируются.
+    test_media_query защищает точную границу payload под ASAN и проверяет все усечения, чужие ответы,
+    повреждение последней записи без изменения первой, отмену и повторный start того же media_id.
+
+[+] **media_delivery QUERY: устранить потерю блоков и держателей из-за разных лимитов** — исправлено 22.10.2026:
+    Одна пачка до 32 block_id — один полный ответ, до четырёх кандидатов на каждый блок (максимум 1604 байта).
+    Нулевой результат и ошибка БД различаются. Неполная пачка не принимается; держатели других пачек и текущие CM сохраняются.
+    QUERY имеет отдельный дедлайн и курсор источников каждого блока; чанки не продлевают поиск остальных блоков.
+    Источники своей CHAT-группы, автор последний; HAVE_BLOCK не зависит от курсора поиска.
+    Peer-слоты переиспользуются после освобождения; SLOT/SEARCH/RETRY различаются, OVERLOADED соблюдает retry_after.
+    Отменяется поздний CM UP, события обрабатываются после open. Устранено двойное освобождение при отказе router.
+    Проверены 65 блоков/260 записей, старт 4100 блоков, сборка с 13 держателями при 10 слотах,
+    настоящий watchdog при входящих чанках, SQL-ошибка второго блока, RNG/send failures и отсутствие повторного done_cb.
+    Сетевой integration проверяет содержимое QUERY_RESP вместо безусловного smoke PASS.
+    Восемь тестов query/delivery_download/download_timeout/delivery_sql/delivery_integration/delivery_chat/delivery_full/services
+    прошли ASAN/UBSan с detect_leaks=1. Итоговый check.sh: 178/178, proxy/burst/load PASS, 172с.
+    Логи: /tmp/media-query-regressions.log, /tmp/media-query-full-check-final.log, /tmp/media-query-asan-final-test_*.log.
+    Windows runtime/сборка не проверялись: кросс-компилятора нет. Контракты — в соответствующих .h.
+
+[+] **media_delivery QUERY_RESP: устранить неверное поле chunk** — исправлено 22.10.2026:
+    Неиспользуемые chunk/rtt удалены из нового формата QUERY_RESP. Блок однозначно задаётся block_id,
+    а его номер загрузчик берёт из сохранённых метаданных; позиция в выборочной пачке не считается номером блока.
+
+[+] **media_delivery CHUNK: прогресс только после проверенного приёма и записи** — исправлено 22.10.2026:
+    Реальные router callbacks/SQLite, корректные подпись блока и ключ автора. CHUNK с data_len=1 без payload
+    оставляет файл пустым, но устанавливает bytes_received=1, RECV и обновляет last_progress_tb.
+    То же при внедрённом fwrite=0/ENOSPC. Текущий unit-тест допускает 456 байт при expected_size=100.
+    Проверять полный payload, геометрию/непрерывность, текущего держателя и попытку до файловых операций;
+    не считать дубли и неудачную запись прогрессом. Нужна привязка пакетов к отдельной попытке передачи блока.
+    Стенд /tmp/media-block-audit.c; логи /tmp/media-block-audit-truncated.log, /tmp/media-block-audit-write.log.
+    Реализованы строгие размеры/непрерывность, tuple группы/держателя/блока/UUID и отдельный temp каждой попытки.
+    Прогресс публикуется после проверенного close. Регрессии: tests/test_media_blocks.c, включая реальные I/O-сбои.
+
+[+] **media_delivery DONE: проверка ключа и конечный результат ошибки хеша** — исправлено 22.10.2026:
+    Для настоящей Ed25519 пары с pubkey[0]=0 корректно подписанный блок отвергается: наличие ключа определяется
+    первым байтом. При отсутствии ключа проверка заменяется сравнением wire block_sig с метаданными.
+    Отдельно: при верной подписи блока и несовпадающем хеше файла state=DONE, validated=0/1, active=1;
+    три проверки watchdog возвращают 0, done не вызывается. Итоговая ошибка должна завершать загрузку,
+    а публикация назначения и регистрация допустимы только после проверенных чтения/записи/close/SHA256.
+    Обязателен ключ ровно 32 байта; проверяется подпись метаданных по фактическим байтам и ожидаемый размер.
+    Сборка идёт в собственный temp, SHA-256 проверяется всегда, затем publish и регистрация SQLite.
+    Ошибка до publish сохраняет старое назначение; ошибка SQLite сохраняет подготовленный опубликованный файл.
+    Регрессии с настоящим pubkey[0]=00, неверной подписью/хешем, сбоями I/O/rename/SQLite: tests/test_media_blocks.c.
+
+[+] **media_delivery progress_cb: отмена освобождает dl внутри обработчика DONE** — исправлено 22.10.2026:
+    progress_cb вызывает media_download_cancel, md_dl_finish освобождает dl; media_download_handle_done затем
+    вызывает md_dl_send_have_block с освобождённым указателем. ASAN heap-use-after-free, чтение 8 байт.
+    Обработчик явно удерживает контекст. Terminal снимает загрузку с индекса и отменяет её timers/CM/waiters;
+    освобождение и done выполняются после выхода последнего удерживающего обработчика, ровно один раз.
+    После progress проверяется terminal: отменённая загрузка не продолжает финализацию. Один перенос callback
+    в конец функции/отложенный финализатор не заменяет владение. Relay-получатели отдельно удерживают файл блока.
+    Проверить также отмену с повторным start того же media_id, отмену на последнем progress и поздние пакеты.
+    Лог /tmp/media-block-audit-cancel-asan.log; стенд вне репозитория /tmp/media-block-audit.c.
+    Реализовано явное удержание контекста обработчиком; отдельные ссылки producer/выдач удерживают файл блока.
+    Единый TX pump готовых/растущих источников соблюдает backpressure для DATA и DONE; remote CANCEL привязан к UUID.
+    Проверены отмена/повторный start из последнего progress и старые relay-читатели при успехе/отмене новой загрузки.
+    Полный ./check.sh: 179/179, proxy/burst/load PASS (/tmp/media-block-full-check-final.log).
+    Десять целевых наборов ASAN+UBSan с detect_leaks=1: PASS (/tmp/media-block-asan-test_*.log).
+    Windows runtime/сборка не проверялись. Синхронные проверка и сборка блоков остаются в uasync.
+
+[+] **media_delivery: исправить репликацию суперузлов** — исправлено 22.10.2026. Воспроизведения прежней реализации:
+    SUPER_REPL с num_entries=1 и одним заголовком: ASAN use-after-poison при чтении id в media_delivery.c:622.
+    ACK от известного пира в другой router-группе без ожидающей пачки: inflight 0→255, tx_cursor=77, запускается timer.
+    HELLO двух пустых узлов: после 20 доставок остаётся следующий HELLO, обмен сам не завершается.
+    Для 9 записей sender ставит 4 одинаковые пачки первых 4 записей. По таймауту 20000→40000 при inflight=4
+    отправляет 0 повторов, хотя timer снова вооружён. На потерю ACK эта схема не восстанавливается.
+    При id=4294967297 первая запись остаётся 64-битной, но seq максимума пачки усечён до 4.
+    Ошибка INSERT второй строки оставляет первую применённой, сохраняет RX cursor=2 и отправляет ACK=2: теряются данные.
+    Группа из тела HELLO переопределяет router-группу (111→333); ответ включает записи групп 111 и 222.
+    Старая пачка уменьшает сохранённый RX cursor 2→1. После supernode stop/start чужие записи удалены,
+    но cursor=2 сохранён и рекламируется в HELLO. Принятая запись не будит выдачу третьему готовому супер-пиру.
+    Уточнение прежней записи: смешения направлений курсоров в БД нет — md_ss_set вызывается только при приёме REPL;
+    ACK обновляет peer_last_recv_id в памяти. Исправлять нужно подтверждение ожидающей пачки и жизненный цикл курсоров.
+    Стенд вне репозитория /tmp/media-super-audit.c; обычные логи /tmp/media-super-audit-{ack,hello,pages,timeout,wide,sql,group,purge,replay,forward}.log.
+    ASAN: /tmp/media-super-audit-truncated-asan.log, exit=1 ожидаем из-за подтверждённой ошибки, не успешный regression.
+    Реализованы receiver-driven SYNC_REQ/SYNC_RESP и CHANGED вместо HELLO/ACK/inflight: одна страница с UUID на (group,peer).
+    Группа/источник только из router, актуальные подписанные роли обоих участников; CM владеет прямым/непрямым путём.
+    Страницы до 32 строк, little endian, 64-битные ID; high-water из sqlite_sequence, сохранённая эпоха каталога.
+    Весь RX packet и курсор фиксируются собственной транзакцией после полной проверки, включая ошибки commit/rollback SQLite.
+    Идемпотентный максимум (status,timestamp) выдаёт новый локальный ID только при изменении; собственные блоки сеются из media_files.
+    Таймаут повторяет прежний запрос, CHANGED/dirty и периодическая сверка не теряют обновление около последней страницы.
+    Репликация соблюдает backpressure; ограниченный слот ответа и watchdog восстанавливаются после reset router send_q.
+    Потеря роли/удаление канала очищают строки вместе с RX-курсорами только своей группы; обычный stop сохраняет БД.
+    test_media_replication: 10000 строк, id>2^32, усечения/дубли/чужие ответы, SQL read/write/commit faults,
+    потеря запросов/ответов/CHANGED, DOWN/UP, новая эпоха, две группы, смена роли, три узла, заполнение/reset очередей.
+    SQL-тест использует настоящую схему; сетевые full/chat/integration — CHAT-группы и подписанные роли member_sync.
+    Финальный ./check.sh: 180/180, proxy 9/9, burst/load PASS (/tmp/media-repl-full-check-final.log).
+    11 целевых наборов ASAN+UBSan с detect_leaks=1: PASS (/tmp/media-repl-asan-final-test_*.log).
+    Контракты обновлены в media_delivery.h/media_delivery_proto.h, sync.md и doc/service_lifecycle.md. Windows не проверялся.
+
+[+] **test_stream_service: убрать зависимость bootstrap-проверки от гонки TCP-handshake** — исправлено 22.10.2026:
+    Падение на строке 409: REINIT=0 при probes=1/subflows=1/failures=0 и доставленной первой пачке.
+    Встречный TCP-линк успевает сообщить peer_reset_id до ETCP CONFIRM: начальная эпоха уже известна,
+    поэтому etcp_session_receive не вызывает REINIT. При другом порядке событий REINIT=1 и тест проходит.
+    Холодная подписка проверяет одну пробу/выдачу и доставку без ошибок, число начальных REINIT диагностическое.
+    Отдельная автоматическая подписка удерживает INFO_RESP, выполняет настоящий REINIT и продолжает ту же пробу.
+    Проверяются новые epoch/nonce, отсутствие лишних проб/CLOSED и пустой локальный буфер перед получением DATA.
+    Ручные проверки старых ответов и исходного deadline сохранены; ожидания привязаны к поколениям и событиям.
+    Добавлен --bootstrap-only: 8 повторов с ускоренными и 2 с обычными часами прошли.
+    Полный test_stream_service прошёл ASAN/UBSan с detect_leaks=1; check.sh — 175/175 и proxy/burst/load.
+    Изолированная потеря pending-пробы вызвала ожидаемый отказ новой автоматической проверки; мутация убрана.
+    Логи: /tmp/stream-service-original-failure.log, /tmp/stream-bootstrap-repeat-*.log,
+    /tmp/stream-service-asan-final.log, /tmp/stream-bootstrap-mutant.log, /tmp/stream-bootstrap-full-check-final.log.
+
+[+] **video: сохранность файлов, JPEG и подготовка MP4** — исправлено 22.10.2026:
+    Одинаковые файлы/алиасы и недопустимые пути отклоняются без изменения исходника.
+    JPEG и MP4 пишутся в эксклюзивный временный файл; запись, drain, trailer и close проверяются.
+    Только успешный completion публикует результат; отмена до callback сохраняет старое назначение.
+    Превью получает задержанные B-кадры. MOV/H.264/AAC проходит remux в MP4; остальные профили
+    перекодируются с audio FIFO, сохранением временного смещения и хвоста ресемплера.
+    Атомарный global slot удерживается до completion, ошибки имеют точную фазу и контекст в логе.
+    Контракты описаны в src/video/video.h и doc/service_lifecycle.md.
+    test_video проверяет реальные кадры/сигнал, 1080p→720p, PCM/MP3/AAC, resample 12345→12000 Гц,
+    файловые ошибки, отмену, повтор из callback и конкурентные start; test_video_no_ffmpeg — стабы.
+    Оба теста, test_services и test_attachment_send прошли ASAN/UBSan с detect_leaks=1.
+    Отдельная конфигурация всего ядра/тестов без FFmpeg собрана, оба video-теста прошли.
+    Логи: /tmp/video-asan-final.log, /tmp/video-services-asan.log, /tmp/video-attachment-send-asan.log,
+    /tmp/video-without-ffmpeg-build-final.log; общий прогон: /tmp/video-full-check-final.log.
+
+[+] **tcp_io: владение connect-таймером и повторный FIN** — 21.10.2026:
+    Замена таймаута сохраняет старый таймер при ошибке создания нового; <=0 отменяет таймер.
+    Возвращаемые ошибки и диапазон INT_MAX/10 проверяются API и TCP-прокси; connect/error/destroy отменяют таймер.
+    FIN различает fin_pending и fin_local, ошибка shutdown идёт в on_error без ложного on_fin_sent.
+    Уточнены отложенное освобождение, синхронные callbacks очередей и платформенный выбор IPv6/маршрута.
+    Проверено: 15 сценариев test_tcp_io, test_tcp_io_flush, test_proxy_regressions и test_socks_http_proxy
+    (16 загрузок с побайтной сверкой). test_tcp_io и flush также прошли ASAN с detect_leaks=1 без ошибок.
+    Логи: /tmp/tcp-io-fix-unit.log, /tmp/tcp-io-fix-asan-unit.log, /tmp/tcp-io-fix-asan-flush.log,
+    /tmp/tcp-io-fix-proxy-regressions.log, /tmp/tcp-io-fix-socks-http.log.
+
+[ ] **Desktop publisher: проверить восстановление после недопустимого FPS в Xvfb-тесте** — 20.10.2026:
+    Широкий screenAndWindowCapture прошёл закрытие управления с active=1 и продолжением публикации,
+    затем не получил видео revision>=3 после запроса fps=61 и возврата engine.config().video.fps к 15.
+    Перед этим применены VP9/rotation=90; worker продолжает кодировать generation=4.
+    Причина и связь с UI-изменениями не установлены; отдельная проверка закрытия управления PASS.
+    Лог /tmp/desktop-stream-controls-xvfb.log, тест tools/chatgui/tests/test_stream_publish.cpp.
+
+[ ] **Проверить одновременную собственную и удалённую трансляции в multiview** — 20.10.2026:
+    Собственный preview и удалённые readers по отдельности проверены; их совместный живой сценарий в одном канале не проверялся.
+    На desktop/Android проверить переход в управление своей публикацией и возврат, fullscreen/Back/Esc,
+    сохранение удалённых readers и общего звука, отсутствие местного звука и остановку собственной публикации.
+
+[ ] **Multiview desktop: terminal CLOSED оставляет аудиовход и timer** — проверка 20.10.2026:
+    fail(reason, false) ставит complete=true/failed=false, но tick снимает audio только по ended/failed.
+    После STREAM_CLOSE_GROUP воспроизведено complete=1, failed=0, attached=1, timer=1.
+    При valid=0 каталог сохраняет плитки, поэтому состояние живёт до ручного закрытия окна.
+    Отделить завершение от разрешения retry и освобождать output при любом terminal CLOSED.
+    Временный regression-проверочный стенд и лог: /tmp/multiview-review/test_stream_view.cpp,
+    /tmp/multiview-review/lifecycle.log. Исходники реализации при проверке не менялись.
+
+[ ] **Проверить ожидание запросов ключей в test_encrypted_attachment** — 21.10.2026:
+    До rebase исправлений control_server: check.sh вне sandbox 165/166; отдельный повтор также
+    phase=5/heartbeats=12001, ожидание двух pending incoming-запросов после перезапуска автора.
+    Логи: /tmp/control-server-full-check.log, /tmp/control-server-attachment-recheck.log;
+    артефакты общего прогона: /tmp/utun_encrypted_attachment_6JMO0c. Код вложений в этой работе не менялся.
+
+[ ] **Разобрать нестабильную загрузку storage-узлов в test_media_delivery_chat** — 19.10.2026:
+    В том же общем прогоне storage st1/st2 не собрали файл, n2 исчерпал попытки блока 0 (15/19 внутренних проверок).
+    Отдельный повтор прошёл 19/19. Причина не установлена; сравнить маршруты и готовность storage под общей нагрузкой.
+    Логи: tests/logs/test_media_delivery_chat.log, /tmp/phone-busy-media-recheck.log.
+    Повторилось 21.10 при аудите ID сервисов: 164/165, те же 15/19 внутренних проверок.
+    Отдельный запуск и 16 параллельных повторов прошли. Причина остаётся открытой;
+    тест теперь сохраняет подробный media/router лог и БД при отказе в /tmp/utun_mdc_*/.
+    Логи /tmp/service-ids-full-check.log, /tmp/service-ids-media-chat-debug.log, /tmp/service-ids-media-chat-stress/.
+
+[ ] **Разобрать нестабильное ожидание ACK в test_local_transport** — 19.10.2026:
+    Общий check.sh: 161/162, chat_adapter упал на строке 173 при ожидании LOCAL_DELIVERY_FORBIDDEN для request=508.
+    В логе получатель дважды отклонил приглашение и отправил ACK; отправитель до проверки получил только late ACK request=507.
+    Отдельный повтор прошёл. Причина не установлена; проверить доставку UDP и шаги ускоренных часов под параллельной нагрузкой.
+    Логи: /tmp/config-name-local-transport-failure.log, /tmp/config-name-local-transport-retry.log.
+    Ещё один общий прогон 19.10: 161/162, chat_adapter упал на строке 145 при ожидании доставки request=501.
+    Получатель принял приглашение и дважды отправил ACK; до проверки в логе отправителя нет приёма этого ACK. Отдельный повтор прошёл.
+    Логи: /tmp/utun-stream-preview-local-transport-failure.log, /tmp/utun-stream-preview-local-transport-retry.log.
+
+[ ] **Разобрать нестабильную проверку аудиопауз desktop-трансляции** — 17–20.10.2026:
+    test_stream_view::realH264RenderingAndClose нестабильно получает silenceGaps=3–4 вместо 2.
+    Зафиксированы pcm_short с got=96/480 и 288/480; видео продолжало выводиться.
+    Сбой повторялся с общей нагрузкой и после её завершения; изолированные повторы проходили.
+    Проверить актуальные PCM workers/часы под нагрузкой; единичный PASS не подтверждает устранение.
+    Логи: /tmp/stream-zoom-full-view-audio-gap.log, /tmp/stream-zoom-full-view.log,
+    /tmp/multiview-review/desktop-review.log, /tmp/multiview-review/audio-original.log.
+
+[ ] **Устранить коллизию порта при перезапуске узла в test_dm_e2e** — 16.10.2026:
+    Общий check.sh при проверке Windows-курсора: 155/156, test_dm_e2e упал в phase=9 на создании B2.
+    Повторный bind 127.0.0.1:33843 вернул Address already in use; отдельный повтор теста проходит.
+    Проверить владение/резервирование порта между остановкой B и созданием B2 при параллельном прогоне.
+    Логи: /tmp/win-stream-cursor-dm-e2e-failure.log, /tmp/win-stream-cursor-dm-e2e-retry.log.
+
+[ ] **Проверить Windows-трансляцию на исходной машине после исправлений playback/stop** — 16.10.2026:
+    Цикл ожидания позднего аудио исправлен; join и закрытие микрофона выполняются асинхронно,
+    QVideoFrame::toImage() вынесен в долгоживущий image worker. Linux/Xvfb-регрессии проходят.
+    Осталась свежая трансляция Windows → Samsung и stop после пересборки Windows: исходный Qt backend ещё не проверен.
+    На RYS HFR USB2.0 Camera проверить сообщение об отсутствии PCM, отзывчивость при завершении WASAPI,
+    отказ/согласие на CPU после отказа NVENC. Причина frames=0 микрофона пока не установлена;
+    подробный AudioDiag реализован только для Linux. libx265 3440×1440 на исходном CPU выдаёт около 2–3fps.
+    Логи: 4.log, /tmp/stream-viewer-new-run.log, /tmp/late-audio-test.log,
+    /tmp/stream-persistent-image-xvfb.log, /tmp/stream-audio-stop-full-check.log.
+
+[ ] **Проверить появление значка свежей трансляции на SM после сна через colo2** — 16.10.2026:
+    Пробуждение и перезапуск SM во время сна уже проверены на обновлённом colo2:
+    новый линк снимает прежний таймер, Merkle завершается без ожидания полного сна 120с.
+    Осталась визуальная проверка значка новой desktop-трансляции после возврата SM в foreground;
+    в прежнем прогоне активных источников не было (count=0).
+    Логи: /tmp/stream-wake-live-{sm,colo2}-*.log.
+
+[ ] **Проверить остаточные паузы видеозвонка на актуальном playout** — 15.10.2026:
+    После исправления TX flush живой звонок 12694689407894286842 дал SM 29.87fps без drops,
+    desktop 29.91fps/3 late drops за последние 20с; отдельные промежутки SM доходили до 63.8мс.
+    В старой трассе краткие invalid audio clock сбрасывали якорь, точная причина invalid не была видна.
+    После переработки playout/ACK и чтения аудиочасов 19–20.10 повторить оба направления на устройствах,
+    сопоставить gap_pts_us/gap_rx_us/gap_dispatch_us и причины недоступности часов, если паузы сохраняются.
+    Текущий контракт и результаты поздних проверок: doc/call_video.txt.
+
+[ ] **Доступность разговорного динамика в UI звонка** — при подключённой проводной гарнитуре Samsung убирает
+    EARPIECE из Telecom endpoints, но кнопка остаётся доступной по наличию физического встроенного устройства.
+    Нажатие создаёт отложенный запрос, который исполняется после отключения гарнитуры. Согласовать UI с доступными endpoints.
+    Также выбор проводной гарнитуры в CallScreen сейчас запрашивает BLUETOOTH_CONNECT при отсутствии этого разрешения;
+    проверку разрешения нужно привязать к выбранному типу гарнитуры.
+
+[ ] **Ручная приёмка видеозвонков Android и ChatGUI после последних исправлений** — 14–20.10.2026:
+    Сигналинг, CAPS, реальные codecs/камера/render и A/V подключены; живые звонки уже проводились.
+    Осталась полная проверка после изменений Full HD/50–60fps, HEVC High tier, Surface ACK и фоновых codec probes:
+    Windows ↔ Samsung/Q8, камеры и оба направления, первый и повторный звонок, смена камеры/разрешения/кодека/битрейта,
+    A/V, завершение и освобождение Surface/видеопорта. Аппаратные probes не заменяют эту проверку.
+    Архитектура, контракты и выполненные проверки: doc/call_video.txt, doc/chat_call_arch.md.
+
+[ ] **Тесты: нестабильное завершение test_stcp_traffic** — 14.10.2026:
+    В полном прогоне после NCD CLOSE server получил 1029466/1048576 bytes (done=0), client — 1048576 (done=1).
+    Упала проверка test_stcp_traffic.c:216; отдельный повтор прошёл. Причина не установлена, сетевой код в задаче zoom не менялся.
+    Проверить завершение двусторонней передачи относительно закрытия handle; первичный лог сохранён: /tmp/stream-zoom-stcp-first.log.
+
+[ ] **Тесты: диагностировать нестабильную проверку TX snapshot в test_android_stream** — 14.10.2026:
+    В полном прогоне один раз упала строка 177: snapshot успешен и 0 < video_bytes < 500000 после test_clock_run_for(ua, 1000).
+    Сам publisher обновляет snapshot таймером 1000; текущий CHECK не выводит result/sample_us/video_bytes.
+    Отдельный повтор и следующий полный прогон прошли. Добавить значения и проверить ожидание конкретного снимка;
+    причина не установлена, Kotlin-аудиовывод этот C-тест не вызывает.
+    Логи прогонов: /tmp/stream-audio-check-host.log, /tmp/stream-audio-native-retry.log, /tmp/stream-audio-check-final.log.
+
+[ ] **Общий AGC: клиппинг после резкого роста сигнала при max_gain=45dB** —
+    на SM при проверке CAMCORDER с настройками рации rise=6/release=30 наблюдались
+    4581 обрезанный отсчёт за интервал около 1s. Это общий алгоритм radio/stream,
+    плавное снижение gain может не успеть за скачком входа. Проверить ограничение пиков
+    без щелчков и ухудшения адаптации. Лог: `/tmp/stream-camcorder-sm-live.log`.
+
+[ ] **Desktop: выход после SIGTERM оставляет GUI после остановки ядра** — 13.10.2026:
+    при обновлении live-плеера старый vibechat завершил ядро/worker, но процесс остался
+    в QCoreApplication::exec с работающим audio output. В логах также DM SELECT после
+    уничтожения SQLite (`bad parameter or other API misuse`). Проверить отмену Quit
+    в MainWindow::closeEvent (всегда ignore), порядок уведомлений и отключение GUI от БД.
+    Снимок: `/tmp/stream-desktop-shutdown-backtrace.log`, лог vibechat 13:04:09.
+
+[ ] **Стриминг SM → colo2 → desktop: восстановление частично остановившихся субпотоков** —
+    13.10.2026: помощь подключилась за ~8 с, все 8 субпотоков через colo2 приняты с общего индекса 5844.
+    Позже шесть субпотоков перестали продвигаться около seq=111625; четыре restart не восстановили
+    просмотр, desktop завершился по таймауту в 11:10:48 (colo2: 12:10:48). На SM публикация продолжилась,
+    colo2 снял свою подписку через 3 с. В том же интервале сервер видит RX timeout/переподключения TCP к SM;
+    первопричина остановки выдач пока не установлена: stream на colo2 наследовал error, детальных логов не было.
+    Повторить с заранее включённой диагностикой stream/etcp на SM и colo2, проверить upstream handles,
+    аренды, позиции и повторное согласование. Логи: `/tmp/stream-live-gui-final.log`,
+    `/tmp/stream-live-colo2-final.log`, `/tmp/stream-live-sm-final.log`.
+    Повтор 13.10 со stereo: до 15:20 desktop показывал ~30fps, затем video/audio очереди опустели;
+    decodeFps упал до 7–18 и viewer завершился по таймауту в 15:21:13 после пяти restart.
+    SM при этом сохранял ~30fps без dropped. Новые логи: `/tmp/stream-stereo-desktop-delivery-stall.log`,
+    `/tmp/stream-stereo-colo2-delivery-stall.log`, `/tmp/stream-stereo-sm-delivery-stall.log`.
+
+[ ] **Android: отмена асинхронного запуска до готовности ядра** — при проверке
+    мониторинга 12.10.2026 обнаружено: `NativeLib.stop()` пропускает native stop,
+    если `isReady()==false`, а `instance_lite_stop()` возвращается при `g_inst==NULL`.
+    Поэтому запрос stop до завершения конструктора может не отменить запускаемый
+    поток. Согласовать отмену с состоянием потока и единым сигналом завершения;
+    проверить stop до SERVICE_STARTED, отказ конструктора и последующий start.
+
+[ ] **Android: повторные отказы persisted node snapshots** — замечено 12.10.2026
+    на устройстве D2AR10P3600820 при проверке live media. В сохранённой БД ряд узлов
+    регулярно получает `invalid persisted snapshot` в `topo_node_sqlite_snapshot_load`,
+    затем NCD сообщает `node not found`; повторные попытки засоряют лог.
+    Лог: `/tmp/stream-av-device-initial.log`. Причина пока не установлена: текущий
+    текст объединяет отказ deserialize, несовпадение ID и отказ verify. Разделить
+    диагностику этих ветвей и проверить повторные попытки загрузки отвергнутого снимка.
+    Существующую БД устройства при проверке стриминга не очищали.
+
+[ ] **STUN IPv6** — отдельный этап: IPv6 endpoint/config/DNS и XOR-MAPPED,
+    scope/netif, тесты IPv6/NAT66. IPv4-оценки не переносить на IPv6 или TCP.
+
+[ ] **check.sh: изоляция сетевых integration-тестов** — после основного набора
+    автоматически запускает check-proxy/burst/load при доступном sudo. Скрипты
+    меняют rp_filter, таблицу 100 и iptables главного namespace; cleanup выставляет
+    rp_filter=1 вместо сохранённого значения. Перенести тесты в отдельный namespace
+    и проверять неизменность родительской сети, как в tests/stream_netns.
+
+[ ] **Стриминг: оставшиеся длительные и масштабные сетевые проверки** — 10–12.10.2026:
+    Реализация ядра, публикации, приёма и автоматического выбора поставщиков завершена; контракт — doc/stream.txt.
+    Есть 16-процессный namespace-стенд с NAT/reverse и выбором UDP/TCP: tests/stream_netns/README.md.
+    Осталось подтвердить покрытие длительной нагрузки, смены адресов/мультилинка, одновременной перестройки
+    нескольких ретрансляторов, нескольких автоматических источников/групп и mobile standby на устройстве
+    (doc/stream.txt, раздел 16). Сохранённые проверки отдельных этапов не закрывают всю матрицу.
+
+[ ] **Member files: исчерпание кеша результатов массовых изменений** — 10.10.2026:
+    Воспроизведено test_member_files_browser::recursiveDeletion(server-busy): из 76 объектов удаляются 64,
+    следующая команда получает MF_BUSY, остаются 12. storage.c: STORE_RECEIPTS=64, RECEIPT_TB=1200000 (120 секунд).
+    Лимит общий для успешных COMMIT/MKDIR/RENAME/REMOVE; затрагивает также рекурсивное копирование.
+    Нужен отдельный этап управления временем жизни receipts с сохранением идемпотентности повторных запросов;
+    простое вытеснение старых записей нарушает гарантию повторного ответа. После исправления изменить регрессию
+    на успешное удаление более 64 объектов и проверить повторные запросы/потерю ответа.
+
+[ ] **Desktop: провалы вероятности VAD при компрессии** — диагностика 09.10.2026:
+    Воспроизведение пользователя: длительная гласная, затем временная нечувствительность; ближе к концу лога несколько повторов.
+    Новый лог 14:32:14–14:34:38: на 14:34:07–18 и 14:34:20–38 все 556 окон с RMS > -30dBFS имеют p < 0.5;
+    PCM непрерывен, errors=0, RX-gate не мешает, clips=5 не растёт. Сигнал не исчезает, порог остаётся 0.5.
+    --probe-stream: C-обёртка + реальный AGC + две Silero на одинаковом PCM, отличие — один reset состояния второй модели.
+    Синтезированный flite ah растянут до 24.576с: без AGC/клиппинга p первой секунды следующей речи 0.027 против 0.674 после reset.
+    При AGC 1dB (clips=0) — 0.012 против 0.662. Влияние истории модели подтверждено, провал на десятки секунд целиком не воспроизведён.
+    Лог стенда: /tmp/vad-vowel-context.log; запуск: test_silero_vad lib/silero_vad.onnx --probe-stream /tmp/vad-vowel-context48.pcm 993.
+    Вход стенда: mono s16le/48кГц, reset_window — индекс окна 512/16кГц; режим проверяет без AGC, 1dB и 15dB.
+    Автоматические сбросы в рабочем VAD не добавлялись; test_silero_vad PASS.
+    Уточнение: низкая вероятность держится десятки секунд, затем распознавание восстанавливается; краткий клиппинг это не объясняет.
+    Локальный лог 14:00:10–14:00:58: 15 сбросов AEC при пропусках референса, 16 clipped samples в VAD; vad DEBUG не был включён.
+    Добавлены секундные уровни raw/clean/reference и причина bypass/reset AEC; отдельное предупреждение о клиппинге VAD.
+    Секундный отчёт захвата работает также без PCM: возраст кадра, очередь, максимальная задержка и предупреждение о простое.
+    TRACE каждого окна содержит DC, число нулей и gain вместе с вероятностью/уровнем/паузой между окнами; видны сбросы и RX-gate.
+    В локальном build/vibechat.cfg включены vad=trace, aec/radio/call=debug, general=info; после диагностики вернуть обычные уровни.
+    Стенд --probe повторяет одинаковый PCM без reset: AGC 15/30dB после паузы обрезает пики (468/5625 samples на чистой записи).
+    Полного провала всей фразы почти до нуля стенд не воспроизвёл; нужен повтор живой речи с новыми логами для связи с AEC/AGC.
+    Алгоритмы обработки сигнала пока не менялись; исправление причины выбирается по результатам повтора.
+
+[ ] **Linux headless CMake: актуализировать зависимости общего ядра** — 07.10.2026:
+    чистая сборка tools/chatgui-android/build_headless останавливается на lib/speex_aec.c:
+    speex/speex_echo.h не найден. utun_setup_sources включает этот исходник, но UTUN_INCLUDE_DIRS не содержит
+    lib/speexdsp/include. Проверить полный состав Speex/voice зависимостей отдельного каркаса;
+    основная Autotools C-сборка и Android NDK-сборка проходят.
+
+[ ] **Завершить проверку реакций и голосов на SM** — 07.10.2026:
+    Исправления подписей корней и их сохранения реализованы, проверены тестами; local и копия SM проверены.
+    Последующие APK уже устанавливались на SM, поэтому прежнее ожидание подключения ADB неактуально.
+    Осталась явная проверка реакции/голоса на устройстве с текущей БД и сборкой.
+    Разовый скрипт и резервная копия подписей: /home/user/utun2-backups/root-certificates-20261007.
+
+[ ] **rlottie: разбор предупреждений GCC 15 в импортированных исходниках** — 05.10.2026:
+    при сборке `tools/chatgui/rlottie_src` GCC сообщает `-Wuninitialized` в
+    `VArenaAlloc::reset()`: fFirstBlock/fFirstSize/fFirstHeapAllocationSize читаются
+    после явного вызова деструктора. Проверить сохранение значений до разрушения
+    и повторный reset с реальными выделениями. Также проверить `-Wfree-nonheap-object`
+    в `vcow_ptr`: статическая модель default_s сохраняет базовую ссылку.
+    Лог: `/tmp/utun-rlottie-vendor-build.log`. Сборка библиотеки и подключение её
+    экспортированного CMake-пакета к ChatGUI на Linux прошли; Windows ещё не проверен.
+
+[ ] **ChatGUI Windows: подтверждение обновления runtime компилятора** — 05.10.2026:
+    `cc-probe.log`: cc1 запускается из корня, но в `tools/chatgui/build` завершается
+    с `0xC0000139`; локальные DLL GCC/math/runtime отличаются от UCRT64.
+    Перед обеими точками сборки добавлено обновление существующих копий этих DLL;
+    раскладка FFmpeg использует для них UCRT64. Проверены обновление, повторный вызов,
+    сохранение кодеков и ошибки. Требуется Windows-прогон `check_cc.bat`: cc1 после
+    обновления, повтор команды Ninja и сборка Opus должны завершиться с кодом 0.
+
+[ ] **ChatGUI Windows: обновление остальных DLL приложения после обновления MSYS2** — 05–06.10.2026:
+    Пропуск раскладки при наличии основного комплекта уже убран: зависимости проверяются на каждой сборке,
+    Qt DLL/плагины и собственный комплект FFmpeg копируются заново; runtime GCC обновляется отдельно.
+    Осталось определить обновление прочих уже существующих транзитивных DLL: рекурсивный проход
+    по-прежнему копирует только отсутствующие файлы. Сохранить приоритет собственной сборки FFmpeg
+    и проверить запуск приложения после обновления MSYS2.
+
+[ ] **Android: время жизни config provider** — 03.10.2026: `utun_bridge_init()`
+    передаёт адрес локального `utun_config_provider_t` в `utun_config_set_provider()`,
+    который хранит указатель. После возврата из init он недействителен; перед
+    использованием `cfg_get_*` обеспечить постоянное хранение provider.
+
+[ ] **Общий лимит check.sh после clean** — 01.10.2026: расчёт по времени предыдущего
+    прогона дал 205с вместе с полной сборкой и оборвал проверку после успешных тестов
+    до `test_uasync_socket_race`. Повторный запуск на готовой сборке с большим лимитом
+    прошёл за 206с, включая proxy/burst/load. Разделить бюджет сборки и запуска тестов
+    либо учитывать clean при расчёте.
+
+[ ] **Повторно проверить паузы desktop-аудио при звонке с SM** — 01.10.2026:
+    В звонках 939a3ea36f3eeac3/b2a423ed2d36ed83 частота callback падала до 4–40/с,
+    входящий PCM продолжал приходить, очередь росла до нескольких секунд без dropped.
+    Диагностика backend, интервалов callback и capture/playback уже добавлена; позднее менялись аудиовывод и его буферы.
+    Нужен повтор на текущей сборке с CALL_STATS и временными метриками, чтобы проверить сохранение исходного сбоя.
+    Сетевую задержку оценивать отдельно: в одном из прежних звонков DIRECT RTT был 2–3мс.
+
+[ ] **Измерить оставшуюся задержку запуска аудио SM после исправлений** — 01.10.2026:
+    В исходном звонке 2b9ad4e21a54d8ba первый capture приходил через 1140мс от startAudio;
+    router.start=781мс, startRecording → первый кадр=328мс, AudioTrack.play=327мс.
+    Независимый запуск capture/playback, отмена частичного старта и подробные замеры уже реализованы;
+    позднее добавлен выбор AAudio/AudioTrack. Осталось измерить текущую сборку на SM:
+    callbackMs/btProfileMs/applyMs/refreshMs, первый AudioRecord.read и первая запись playback,
+    начальное накопление очереди. Старые длительности не считать характеристиками текущей реализации.
+
+[ ] **Гонка invite-файла в test_chat_join_e2e** — `wait_file()` проверяет только
+    существование файла, а `wf()` создаёт его до записи. Читатель иногда получает
+    пустую ссылку и ошибку префикса `utun://`. Публиковать готовый файл атомарно.
+
+[+] **Linux ONNX Runtime: повторная регистрация схем при запуске теста** — проверено 21.10.2026:
+    Причина в системной сборке `1.23.2+dfsg-6ubuntu1`: Runtime вручную регистрирует схемы,
+    затем динамическая `libonnx.so.1` повторяет регистрацию в `OpSchemaRegistry::map()`.
+    Подтверждено GDB (`/tmp/silero-schema-gdb.log`) и исходниками обеих библиотек.
+    Текущая Linux x64 CMake-сборка переключена на [официальный Runtime 1.23.2](https://github.com/microsoft/onnxruntime/releases/tag/v1.23.2).
+    Архив `onnxruntime-linux-x64-1.23.2.tgz` распакован в `.cache/onnxruntime/`;
+    SHA-256: `1fa4dcaef22f6f7d5cd81b28c2800414350c10116f5fdd46a2160082551c5f9b`.
+    Для существующего include `onnxruntime/onnxruntime_c_api.h` создана ссылка
+    `.cache/onnxruntime/include/onnxruntime` → `../onnxruntime-linux-x64-1.23.2/include`.
+    В CMake явно заданы абсолютные пути: `ONNXRUNTIME_INCLUDE_DIR=<repo>/.cache/onnxruntime/include`,
+    `ONNXRUNTIME_LIB=<repo>/.cache/onnxruntime/onnxruntime-linux-x64-1.23.2/lib/libonnxruntime.so`.
+    Выбор сохраняется в `tools/chatgui/build/CMakeCache.txt`; после удаления cache его нужно повторить.
+    `ldd` подтверждает официальный Runtime без отдельной `libonnx`; весь `test_silero_vad` проходит без `Schema error`.
+    Лог проверки: `/tmp/silero-runtime-test.log`, полный вывод — `tools/chatgui/build/Testing/Temporary/LastTest.log`.
+
+[ ] **debug_parse_config: формат и индексы категорий** — parser ожидает `:`, документация
+    описывает `=`; преобразование битовой маски осталось после перехода enum на индексы.
+    [Разбор](etcp_full_suite_findings.md).
+
+[ ] **Повторно проверить crypto-шум при автоподключении в сценарии A–C–B**:
+    В старом test_dm_e2e попытка прямого A↔B через topo_group_connect давала packet undecryptable примерно раз в секунду.
+    Наблюдение относилось к прежним настройкам приёма и архитектуре подключений; устранение не подтверждено.
+    Воспроизвести на текущих NCD/ETCP и установить точную причину по логам до изменения политики подключения.
+    Отсутствие [client] само по себе не считать основанием запрета: CHAT использует собственных NCD-владельцев.
+
+[ ] **lwip/proxy: утечка pcb в FIN_WAIT_2** — `tcp_shutdown(pcb,0,1)` (half-close по FIN от
+    exit) не ставит `TF_RXCLOSED`, поэтому таймаут FIN_WAIT_2 в `tcp_slowtmr` не срабатывает:
+    если браузер никогда не пришлёт FIN, pcb навсегда остаётся в FIN_WAIT_2 (утечка, не crash).
+    Двойной free по TIME_WAIT уже закрыт (detach по локальному закрытию + guard abort).
+
+## Открытые флаки
+
+[ ] **test_etcp_transport: таймаут восстановления REALITY-сессии** — 18.10.2026:
+    в общем `./check.sh` сценарий `reality=1 simultaneous=0 restart=0` завершился
+    `Session recovery timed out: phase=1 stream=15 control=6`. Перед таймаутом —
+    `record socket read failed: err=104`, клиент ждал server-handshake.
+    Отдельный повтор того же бинарника прошёл. Причина нестабильности пока не установлена;
+    изменения Android JNI/UI транспортные исходники не затрагивали.
+
+[ ] **test_etcp_reconnect** — флаки под параллельной нагрузкой `make check -j4`:
+    phase 4 (reconnect после server restart) таймаутит (`sent=480 recv=0`), при одиночном
+    запуске стабильно `TEST PASSED`. Наш код (chat_join/chat_sync) его не трогает.

lib/COPYING.silero-vad

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present Silero Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lib/Makefile.am

@@ -15,6 +15,8 @@ libuasync_a_SOURCES = \
 	socket_compat.h \
 	platform_compat.c \
 	platform_compat.h \
+	file_io.c \
+	file_io.h \
 	getmyip.c \
 	getmyip.h \
 	swm_min.c \
@@ -25,6 +27,10 @@ libuasync_a_SOURCES = \
 	radix.h \
 	serialize.c \
 	serialize.h \
+	video_plane.c \
+	video_plane.h \
+	reed_solomon.c \
+	reed_solomon.h \
 	json_flat.c \
 	json_flat.h \
 	tcp_io.c \
@@ -40,17 +46,48 @@ libuasync_a_SOURCES = \
 	dns.c \
 	dns.h \
 	async_dns.c \
-	async_dns.h
+	async_dns.h \
+	speex_aec.c \
+	speex_aec.h \
+	speexdsp/mdf.c \
+	speexdsp/fftwrap.c \
+	speexdsp/kiss_fft.c \
+	speexdsp/kiss_fftr.c
+
+if HAVE_SILERO_VAD
+libuasync_a_SOURCES += \
+	silero_vad.c \
+	silero_vad.h
+endif
 
 libuasync_a_CFLAGS = \
 	-D_ISOC99_SOURCE \
 	-DDEBUG_OUTPUT_STDERR \
 	-DSQLITE_THREADSAFE=1 \
 	-DDNS_RANDOM=RAND_bytes \
+	-DFLOATING_POINT \
+	-DUSE_KISS_FFT \
+	-DEXPORT= \
 	-g \
 	-I$(top_srcdir)/src \
 	-I$(top_srcdir)/lib \
-	-I$(top_srcdir)/lib/libopus/include
+	-I$(top_srcdir)/lib/libopus/include \
+	-I$(top_srcdir)/lib/speexdsp \
+	-I$(top_srcdir)/lib/speexdsp/include
+
+if HAVE_SILERO_VAD
+libuasync_a_CFLAGS += -DHAVE_SILERO_VAD
+endif
+
+# Вшитая модель Silero VAD (включается из silero_vad.c)
+EXTRA_DIST = silero_vad_model.inc \
+	COPYING.silero-vad \
+	wintun-LICENSE.txt \
+	wintun-api-LICENSE.txt \
+	speexdsp/COPYING \
+	liblmdb/LICENSE \
+	liblmdb/COPYRIGHT \
+	soundtouch-master/COPYING.TXT
 
 # Clean build directory
 clean-local:

lib/async_dns.c

@@ -20,6 +20,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <ctype.h>
 
 #ifdef _WIN32
 #include <iphlpapi.h>
@@ -37,6 +38,9 @@ struct adns_query {
     void* timer;        /* handle таймаута (NULL когда нет) */
     int   finished;
     char* name;
+    int   fast;                  /* 1 = готовый /etc/hosts-ответ, без libdns */
+    struct adns_result fast_result;
+    void* call_soon_id;          /* отложенный вызов (fast-путь и первый драйв slow-пути) */
 };
 
 static void adns_drive(struct adns_query* q);
@@ -44,6 +48,8 @@ static void adns_finish(struct adns_query* q, int status, struct sockaddr_in* ad
 static void adns_read_cb(socket_t sock, void* arg);
 static void adns_write_cb(socket_t sock, void* arg);
 static void adns_timer_cb(void* arg);
+static void adns_fast_ready_cb(void* arg);
+static int  adns_hosts_lookup(const char* name, struct sockaddr_in* out);
 
 /* ─── system DNS servers discovery ─── */
 
@@ -124,6 +130,49 @@ int adns_system_servers(struct sockaddr_in* out, int max) {
 }
 #endif
 
+/* ─── синхронный /etc/hosts-лукап (быстрый путь, без libdns) ─── */
+
+// Ищет name в /etc/hosts. Возвращает 1 если найден IPv4-адрес (out заполнен).
+// Блокирующее чтение небольшого файла — только для локальных имён (localhost и т.п.).
+static int adns_hosts_lookup(const char* name, struct sockaddr_in* out) {
+#ifndef _WIN32
+    if (!name || !out) return 0;
+    FILE* f = fopen("/etc/hosts", "r");
+    if (!f) return 0;
+    char line[512];
+    int found = 0;
+    while (!found && fgets(line, sizeof(line), f)) {
+        char ip[64]; int n = 0;
+        const char* p = line;
+        while (*p && !isspace(*p) && n < 63) ip[n++] = *p++;
+        ip[n] = '\0';
+        if (!ip[0] || ip[0] == '#') continue;
+        struct in_addr a;
+        if (inet_pton(AF_INET, ip, &a) != 1) continue;
+        while (*p && isspace(*p)) p++;
+        while (*p && *p != '\n') {
+            if (*p == '#') break;
+            char h[256]; int hn = 0;
+            while (*p && !isspace(*p) && *p != '#' && hn < 255) h[hn++] = *p++;
+            h[hn] = '\0';
+            if (h[0] && strcasecmp(h, name) == 0) {
+                memset(out, 0, sizeof(*out));
+                out->sin_family = AF_INET;
+                out->sin_addr = a;
+                found = 1;
+                break;
+            }
+            while (*p && isspace(*p)) p++;
+        }
+    }
+    fclose(f);
+    return found;
+#else
+    (void)name; (void)out;
+    return 0;
+#endif
+}
+
 /* ─── resolver setup ─── */
 
 static struct dns_resolver* adns_open_resolver(const struct sockaddr_in* servers, int count,
@@ -155,6 +204,11 @@ static struct dns_resolver* adns_open_resolver(const struct sockaddr_in* servers
         dns_resconf_close(rc);
         return NULL;
     }
+#ifndef _WIN32
+    // Локальные имена из /etc/hosts (localhost и т.п.). Не фатально, если файла нет.
+    if (dns_hosts_loadpath(hosts, "/etc/hosts") != 0)
+        DEBUG_DEBUG(ADNS_DEBUG_CAT, "adns: /etc/hosts not loaded");
+#endif
 
     struct dns_hints* hints = dns_hints_local(rc, &error);
     if (!hints) {
@@ -197,7 +251,7 @@ static void adns_rearm(struct adns_query* q) {
         }
         q->cur_fd = -1;
         if (fd >= 0) {
-            q->socket_id = uasync_add_socket_t(q->ua, (socket_t)fd, adns_read_cb, adns_write_cb, NULL, q);
+            q->socket_id = uasync_add_socket_t(q->ua, (socket_t)fd, adns_read_cb, adns_write_cb, NULL, "dns_query", q);
             if (q->socket_id) q->cur_fd = fd;
             else DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: uasync_add_socket_t(%d) failed", fd);
         }
@@ -326,6 +380,34 @@ static void adns_finish(struct adns_query* q, int status, struct sockaddr_in* ad
     u_free(name);
 }
 
+// Отложенный вызов коллбэка для fast-пути (/etc/hosts): сохраняет async-контракт
+// (adns_resolve возвращает handle, коллбэк вызывается в потоке event loop).
+static void adns_fast_ready_cb(void* arg) {
+    struct adns_query* q = (struct adns_query*)arg;
+    q->call_soon_id = NULL;
+    if (q->finished) return;   // отменён до срабатывания
+    q->finished = 1;
+    adns_done_cb cb = q->cb;
+    void* a = q->arg;
+    struct adns_result res = q->fast_result;
+    char* nm = q->name;
+    q->name = NULL;
+    u_free(q);
+    if (cb) cb(&res, a);
+    u_free(nm);
+}
+
+// Отложенный первый драйв slow-пути (libdns): adns_resolve возвращает живой handle,
+// а реальный запуск запроса происходит в event loop. Это исключает ситуацию, когда
+// dns_res_check завершается синхронно прямо внутри adns_resolve() и освобождает q
+// до того, как вызывающий код получил и сохранил handle.
+static void adns_drive_trampoline(void* arg) {
+    struct adns_query* q = (struct adns_query*)arg;
+    q->call_soon_id = NULL;
+    if (q->finished) return;   // отменён до срабатывания
+    adns_drive(q);
+}
+
 /* ─── public API ─── */
 
 struct adns_query* adns_resolve(struct UASYNC* ua, const char* name,
@@ -334,6 +416,28 @@ struct adns_query* adns_resolve(struct UASYNC* ua, const char* name,
     if (!ua || !name || !name[0] || !cb) return NULL;
     if (strlen(name) > 255) { DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: name too long"); return NULL; }
 
+    // Быстрый путь: имя из /etc/hosts (localhost и т.п.) — без libdns и сети.
+    // libdns по умолчанию идёт в DNS первым (lookup="bf"), поэтому локальные имена
+    // ждали бы таймаут DNS-запроса (2×2s); обрабатываем их сразу.
+    {
+        struct sockaddr_in ha;
+        if (adns_hosts_lookup(name, &ha)) {
+            struct adns_query* q = u_calloc(1, sizeof(*q));
+            if (!q) { DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: calloc failed"); return NULL; }
+            q->ua = ua; q->cb = cb; q->arg = arg;
+            q->name = u_strdup(name);
+            if (!q->name) { u_free(q); DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: strdup failed"); return NULL; }
+            q->fast = 1;
+            q->fast_result.status = ADNS_OK;
+            q->fast_result.count = 1;
+            q->fast_result.addrs[0] = ha;
+            q->call_soon_id = uasync_call_soon(ua, q, adns_fast_ready_cb);
+            if (!q->call_soon_id) { u_free(q->name); u_free(q); return NULL; }
+            DEBUG_DEBUG(ADNS_DEBUG_CAT, "adns: '%s' resolved from /etc/hosts (fast)", name);
+            return q;
+        }
+    }
+
     struct sockaddr_in servers[3];
     int count;
     if (opts && opts->server.sin_family != 0) {
@@ -373,13 +477,26 @@ struct adns_query* adns_resolve(struct UASYNC* ua, const char* name,
     DEBUG_DEBUG(ADNS_DEBUG_CAT, "adns: resolving '%s' via %d server(s), timeout=%dms attempts=%d",
                 name, count, timeout_ms, attempts);
 
-    adns_drive(q);
+    q->call_soon_id = uasync_call_soon(ua, q, adns_drive_trampoline);
+    if (!q->call_soon_id) {
+        DEBUG_ERROR(ADNS_DEBUG_CAT, "adns: uasync_call_soon failed for '%s'", name);
+        dns_res_close(q->res);
+        u_free(q->name);
+        u_free(q);
+        return NULL;
+    }
     return q;
 }
 
 void adns_cancel(struct adns_query* q) {
     if (!q || q->finished) return;
     q->finished = 1;
+    if (q->call_soon_id) { uasync_call_soon_cancel(q->ua, q->call_soon_id); q->call_soon_id = NULL; }
+    if (q->fast) {
+        u_free(q->name);
+        u_free(q);
+        return;
+    }
     adns_teardown(q);
     u_free(q->name);
     u_free(q);

lib/async_dns.h

@@ -34,23 +34,27 @@ struct adns_result {
     struct sockaddr_in addrs[ADNS_MAX_ADDRS];  /* AF_INET, sin_port = 0 */
 };
 
+/* res заимствован до возврата callback; handle запроса к этому моменту уже освобождён. */
 typedef void (*adns_done_cb)(const struct adns_result* res, void* arg);
 
 struct adns_opts {
     struct sockaddr_in server;   /* sin_family != 0 → использовать этот сервер (иначе системные) */
-    int timeout_ms;              /* таймаут на сервер, по умолчанию 2000 */
+    int timeout_ms;              /* Таймаут на сервер в мс; <=0 → 2000, округляется вверх до целых секунд. */
     int max_attempts;            /* попыток на сервер, по умолчанию 2 */
 };
 
 struct adns_query;  /* opaque */
 
 /* Запускает асинхронный A-запрос. Коллбэк вызывается в потоке event loop.
-   Возвращает handle (NULL при немедленной ошибке: невалидные аргументы/нет памяти). */
+ * Возвращает handle, автоматически освобождаемый до callback либо при отмене.
+ * NULL: неверные аргументы, нехватка памяти, отсутствие DNS-серверов, ошибка создания
+ * резолвера, постановки запроса или регистрации отложенного запуска; callback не вызывается. */
 struct adns_query* adns_resolve(struct UASYNC* ua, const char* name,
                                 const struct adns_opts* opts,
                                 adns_done_cb cb, void* arg);
 
-/* Отмена ожидающего запроса: коллбэк НЕ вызывается. Только из потока loop. */
+/* Отмена ожидающего запроса: освобождает handle, коллбэк НЕ вызывается. Только из потока loop.
+ * После завершения/отмены handle недействителен; NULL допустим. */
 void adns_cancel(struct adns_query* q);
 
 /* Системные DNS-серверы (IPv4). Возвращает количество; out[].sin_port = htons(53).

lib/audio_compressor.c

@@ -3,223 +3,144 @@
 #include "mem.h"
 #include <math.h>
 #include <string.h>
-#include <stdlib.h>
-
-#define BLOCK_LEVELS_CHUNK 64
-#define PENDING_CHUNK       32
+#include <stdint.h>
 
+/* История и задержанные блоки ограничены окном настройки. Только запись накапливает output. */
 struct audio_compressor {
     audio_compressor_config_t cfg;
-    int enabled;
-
-    int block_samples;
-    int lookback_blocks;
-    int lookahead_blocks;
-    float rise_factor_per_block;
-    float max_gain;
-    float gain_smoothed;
-
-    float*   block_levels;
-    size_t   block_levels_count;
-    size_t   block_levels_cap;
-
-    struct pending_block {
-        int16_t* samples;
-        size_t   count;
-        size_t   level_index;
-    }*       pending;
-    size_t   pending_count;
-    size_t   pending_cap;
-
-    int16_t* accumulator;
-    size_t   accum_count;
-
+    int enabled, configured, failed, block_samples, lookback_blocks, lookahead_blocks;
+    float rise_factor_per_block, release_factor_per_block, max_gain, gain_smoothed;
+    float* block_levels;
+    size_t levels_cap, blocks_seen;
+    int16_t* pending;
+    size_t pending_cap, pending_head, pending_count, accum_count;
     int16_t* output;
-    size_t   output_size;
-    size_t   output_cap;
-
-    int dbg_counter;
+    size_t output_size, output_cap;
+    uint32_t clip_count;
+    unsigned dbg_counter;
 };
 
+/* Начальное усиление в середине диапазона в дБ. */
+static float initial_gain(float max_gain) { return max_gain > 0.0f ? sqrtf(max_gain) : 1.0f; }
+
 struct audio_compressor* audio_compressor_create(void) {
     struct audio_compressor* ac = u_calloc(1, sizeof(*ac));
-    if (!ac) {
-        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "audio_compressor_create: OOM");
-        return NULL;
-    }
+    if (!ac) { DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: state allocation failed"); return NULL; }
     ac->enabled = 1;
-    ac->gain_smoothed = 1.0f;
-    DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "audio_compressor_create: ok");
     return ac;
 }
 
 void audio_compressor_destroy(struct audio_compressor* ac) {
     if (!ac) return;
-    for (size_t i = 0; i < ac->pending_count; i++)
-        u_free(ac->pending[i].samples);
-    u_free(ac->pending);
-    u_free(ac->block_levels);
-    u_free(ac->accumulator);
-    u_free(ac->output);
-    u_free(ac);
-    DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "audio_compressor_destroy");
-}
-
-void audio_compressor_configure(struct audio_compressor* ac, const audio_compressor_config_t* cfg) {
-    if (!ac || !cfg) return;
-    ac->cfg = *cfg;
-    if (ac->cfg.sample_rate <= 0) ac->cfg.sample_rate = 48000;
-    if (ac->cfg.channels <= 0)    ac->cfg.channels = 1;
-    if (ac->cfg.block_duration_ms <= 0) ac->cfg.block_duration_ms = 20;
-    if (ac->cfg.lookback_ms <= 0)  ac->cfg.lookback_ms = 200;
-    if (ac->cfg.lookahead_ms <= 0) ac->cfg.lookahead_ms = 100;
-    if (ac->cfg.target_level <= 0.0f) ac->cfg.target_level = 0.25f;
-
-    ac->block_samples = ac->cfg.sample_rate * ac->cfg.block_duration_ms / 1000 * ac->cfg.channels;
-    ac->lookback_blocks  = ac->cfg.lookback_ms / ac->cfg.block_duration_ms;
-    ac->lookahead_blocks = ac->cfg.lookahead_ms / ac->cfg.block_duration_ms;
-    ac->rise_factor_per_block = powf(ac->cfg.rise_rate_per_sec, (float)ac->cfg.block_duration_ms / 1000.0f);
-    ac->max_gain = powf(10.0f, ac->cfg.max_gain_db / 20.0f);
-
-    DEBUG_INFO(DEBUG_CATEGORY_GENERAL,
-        "audio_compressor_configure: rate=%d ch=%d block=%dms lookback=%dms lookahead=%dms maxGain=%.0fdB riseRate=%.1f/sec target=%.0fdBFS",
-        ac->cfg.sample_rate, ac->cfg.channels, ac->cfg.block_duration_ms,
-        ac->cfg.lookback_ms, ac->cfg.lookahead_ms, ac->cfg.max_gain_db,
-        ac->cfg.rise_rate_per_sec, 20.0f * log10f(ac->cfg.target_level));
+    u_free(ac->pending); u_free(ac->block_levels); u_free(ac->output); u_free(ac);
 }
 
 void audio_compressor_reset(struct audio_compressor* ac) {
     if (!ac) return;
-    for (size_t i = 0; i < ac->pending_count; i++)
-        u_free(ac->pending[i].samples);
-    ac->pending_count = 0;
-    ac->block_levels_count = 0;
-    ac->accum_count = 0;
-    ac->output_size = 0;
-    ac->gain_smoothed = 1.0f;
-    ac->dbg_counter = 0;
+    ac->pending_head = ac->pending_count = ac->accum_count = ac->blocks_seen = ac->output_size = 0;
+    ac->gain_smoothed = initial_gain(ac->max_gain);
+    ac->clip_count = ac->dbg_counter = 0;
+    ac->failed = 0;
 }
 
-void audio_compressor_set_enabled(struct audio_compressor* ac, int enabled) {
-    if (!ac) return;
-    ac->enabled = enabled ? 1 : 0;
+/* Ноль lookahead означает отсутствие задержки; defaults остальных полей задаются явно здесь. */
+int audio_compressor_configure(struct audio_compressor* ac, const audio_compressor_config_t* config) {
+    if (!ac || !config) { DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: missing configuration"); return -1; }
+    audio_compressor_config_t cfg = *config;
+    if (!cfg.sample_rate) cfg.sample_rate = 48000;
+    if (!cfg.channels) cfg.channels = 1;
+    if (!cfg.block_duration_ms) cfg.block_duration_ms = 20;
+    if (!cfg.lookback_ms) cfg.lookback_ms = 200;
+    if (!cfg.target_level) cfg.target_level = 0.25f;
+    if (!cfg.rise_rate_per_sec) cfg.rise_rate_per_sec = 4.0f;
+    if (!cfg.release_rate_per_sec) cfg.release_rate_per_sec = cfg.rise_rate_per_sec * 5.0f;
+    if (cfg.sample_rate < 8000 || cfg.sample_rate > 192000 || cfg.channels < 1 || cfg.channels > 2 ||
+        cfg.block_duration_ms < 1 || cfg.block_duration_ms > 1000 || cfg.lookback_ms < 0 || cfg.lookback_ms > 5000 ||
+        cfg.lookahead_ms < 0 || cfg.lookahead_ms > 5000 || !isfinite(cfg.target_level) || cfg.target_level <= 0 ||
+        !isfinite(cfg.max_gain_db) || cfg.max_gain_db < 0 || cfg.max_gain_db > 60 ||
+        !isfinite(cfg.rise_rate_per_sec) || cfg.rise_rate_per_sec <= 0 ||
+        !isfinite(cfg.release_rate_per_sec) || cfg.release_rate_per_sec <= 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: invalid rate=%d ch=%d block=%d back=%d ahead=%d",
+                    cfg.sample_rate, cfg.channels, cfg.block_duration_ms, cfg.lookback_ms, cfg.lookahead_ms);
+        return -1;
+    }
+    int block = cfg.sample_rate * cfg.block_duration_ms / 1000 * cfg.channels;
+    int back = cfg.lookback_ms / cfg.block_duration_ms, ahead = cfg.lookahead_ms / cfg.block_duration_ms;
+    size_t levels_cap = (size_t)back + ahead + 2, pending_cap = (size_t)ahead + 2;
+    float* levels = u_calloc(levels_cap, sizeof(float));
+    int16_t* pending = u_calloc(pending_cap * (size_t)block, sizeof(int16_t));
+    if (!levels || !pending) {
+        u_free(levels); u_free(pending);
+        DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: buffers allocation failed");
+        return -1;
+    }
+    u_free(ac->block_levels); u_free(ac->pending);
+    ac->cfg = cfg; ac->block_samples = block;
+    ac->lookback_blocks = back; ac->lookahead_blocks = ahead;
+    ac->block_levels = levels; ac->levels_cap = levels_cap;
+    ac->pending = pending; ac->pending_cap = pending_cap;
+    ac->rise_factor_per_block = powf(cfg.rise_rate_per_sec, (float)cfg.block_duration_ms / 1000.0f);
+    ac->release_factor_per_block = powf(cfg.release_rate_per_sec, (float)cfg.block_duration_ms / 1000.0f);
+    ac->max_gain = powf(10.0f, cfg.max_gain_db / 20.0f);
+    ac->configured = 1;
+    audio_compressor_reset(ac);
+    DEBUG_INFO(DEBUG_CATEGORY_MEDIA, "compressor: configured rate=%d ch=%d ahead=%dms history=%zu pending=%zu",
+               cfg.sample_rate, cfg.channels, cfg.lookahead_ms, levels_cap, pending_cap);
+    return 0;
 }
 
-int audio_compressor_is_enabled(const struct audio_compressor* ac) {
-    return ac ? ac->enabled : 0;
+struct audio_compressor* audio_compressor_clone_config(const struct audio_compressor* source) {
+    if (!source || !source->configured) { DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: cannot clone configuration"); return NULL; }
+    struct audio_compressor* copy = audio_compressor_create();
+    if (copy && audio_compressor_configure(copy, &source->cfg) != 0) { audio_compressor_destroy(copy); return NULL; }
+    if (copy) copy->enabled = source->enabled;
+    return copy;
 }
 
+void audio_compressor_set_enabled(struct audio_compressor* ac, int enabled) { if (ac) ac->enabled = !!enabled; }
+int audio_compressor_is_enabled(const struct audio_compressor* ac) { return ac && ac->enabled; }
+
+/* Одна оценка для всех каналов сохраняет баланс стерео. */
 static float compute_block_level(const int16_t* samples, size_t count) {
     double sum_sq = 0.0;
     float peak = 0.0f;
     for (size_t i = 0; i < count; i++) {
         float v = (float)samples[i] / 32768.0f;
         sum_sq += (double)v * v;
-        float av = fabsf(v);
-        if (av > peak) peak = av;
+        if (fabsf(v) > peak) peak = fabsf(v);
     }
-    float rms = (float)sqrt(sum_sq / (double)count);
-    return (rms * 2.0f + peak) / 2.0f;
+    return (2.0f * sqrtf((float)(sum_sq / count)) + peak) / 2.0f;
 }
 
-static void ensure_output_cap(struct audio_compressor* ac, size_t needed) {
-    size_t want = ac->output_size + needed;
-    if (want <= ac->output_cap) return;
-    size_t new_cap = ac->output_cap ? ac->output_cap * 2 : 4096;
-    while (new_cap < want) new_cap *= 2;
-    int16_t* tmp = u_realloc(ac->output, new_cap * sizeof(int16_t));
-    if (!tmp) return;
-    ac->output = tmp;
-    ac->output_cap = new_cap;
-}
-
-static void append_output(struct audio_compressor* ac, const int16_t* samples, size_t count) {
-    ensure_output_cap(ac, count);
-    memcpy(ac->output + ac->output_size, samples, count * sizeof(int16_t));
-    ac->output_size += count;
-}
-
-static void ensure_block_levels_cap(struct audio_compressor* ac) {
-    if (ac->block_levels_count < ac->block_levels_cap) return;
-    size_t new_cap = ac->block_levels_cap ? ac->block_levels_cap * 2 : BLOCK_LEVELS_CHUNK;
-    float* tmp = u_realloc(ac->block_levels, new_cap * sizeof(float));
-    if (!tmp) return;
-    ac->block_levels = tmp;
-    ac->block_levels_cap = new_cap;
-}
-
-static void add_block_level(struct audio_compressor* ac, float level) {
-    ensure_block_levels_cap(ac);
-    ac->block_levels[ac->block_levels_count++] = level;
-}
-
-static void ensure_pending_cap(struct audio_compressor* ac) {
-    if (ac->pending_count < ac->pending_cap) return;
-    size_t new_cap = ac->pending_cap ? ac->pending_cap * 2 : PENDING_CHUNK;
-    struct pending_block* tmp = u_realloc(ac->pending, new_cap * sizeof(*tmp));
-    if (!tmp) return;
-    ac->pending = tmp;
-    ac->pending_cap = new_cap;
-}
-
-static void process_pending_block(struct audio_compressor* ac);
-
-void audio_compressor_push(struct audio_compressor* ac, const int16_t* samples, size_t count) {
-    if (!ac || !samples || count == 0) return;
-
-    if (!ac->enabled) {
-        append_output(ac, samples, count);
-        return;
+/* Выход записи растёт только вне аппаратного callback; OOM переводит запись в failed. */
+static int reserve_output(struct audio_compressor* ac, size_t count) {
+    if (count > SIZE_MAX / sizeof(int16_t) - ac->output_size) goto failed;
+    size_t want = ac->output_size + count;
+    if (want <= ac->output_cap) return 0;
+    size_t capacity = ac->output_cap ? ac->output_cap : 4096;
+    while (capacity < want) {
+        if (capacity > SIZE_MAX / sizeof(int16_t) / 2) { capacity = want; break; }
+        capacity *= 2;
     }
-
-    size_t remaining = count;
-    const int16_t* src = samples;
-
-    while (remaining > 0) {
-        size_t need = (size_t)ac->block_samples - ac->accum_count;
-        size_t take = remaining < need ? remaining : need;
-
-        size_t new_cnt = ac->accum_count + take;
-        int16_t* tmp = u_realloc(ac->accumulator, new_cnt * sizeof(int16_t));
-        if (!tmp) return;
-        ac->accumulator = tmp;
-        memcpy(ac->accumulator + ac->accum_count, src, take * sizeof(int16_t));
-        ac->accum_count = new_cnt;
-
-        src += take;
-        remaining -= take;
-
-        if (ac->accum_count == (size_t)ac->block_samples) {
-            float level = compute_block_level(ac->accumulator, ac->accum_count);
-            add_block_level(ac, level);
-
-            ensure_pending_cap(ac);
-            ac->pending[ac->pending_count].samples    = ac->accumulator;
-            ac->pending[ac->pending_count].count       = ac->accum_count;
-            ac->pending[ac->pending_count].level_index = ac->block_levels_count - 1;
-            ac->pending_count++;
-
-            ac->accumulator = NULL;
-            ac->accum_count = 0;
-        }
-    }
-
-    while (ac->pending_count > (size_t)ac->lookahead_blocks)
-        process_pending_block(ac);
+    int16_t* samples = u_realloc(ac->output, capacity * sizeof(int16_t));
+    if (!samples) goto failed;
+    ac->output = samples; ac->output_cap = capacity;
+    return 0;
+failed:
+    ac->failed = 1;
+    DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: recording output allocation failed samples=%zu", count);
+    return -1;
 }
 
-static void process_pending_block(struct audio_compressor* ac) {
-    if (ac->pending_count == 0) return;
-
-    size_t idx = ac->pending[0].level_index;
-
-    size_t win_start = idx >= (size_t)ac->lookback_blocks ? idx - (size_t)ac->lookback_blocks : 0;
-    size_t win_end = idx + (size_t)ac->lookahead_blocks;
-    if (win_end >= ac->block_levels_count) win_end = ac->block_levels_count - 1;
-
-    float envelope = 0.0f;
-    for (size_t i = win_start; i <= win_end; i++) {
-        if (ac->block_levels[i] > envelope) envelope = ac->block_levels[i];
+/* Общий алгоритм усиления для записи с lookahead и потокового кадра без lookahead. */
+static void apply_gain(struct audio_compressor* ac, int16_t* samples, size_t count, size_t idx) {
+    size_t begin = idx >= (size_t)ac->lookback_blocks ? idx - ac->lookback_blocks : 0;
+    size_t end = idx + ac->lookahead_blocks;
+    if (end >= ac->blocks_seen) end = ac->blocks_seen - 1;
+    float envelope = 0;
+    for (size_t i = begin; i <= end; i++) {
+        float level = ac->block_levels[i % ac->levels_cap];
+        if (level > envelope) envelope = level;
     }
     if (envelope < 0.0001f) envelope = 0.0001f;
 
@@ -227,66 +148,106 @@ static void process_pending_block(struct audio_compressor* ac) {
     float G_prev = ac->gain_smoothed;
 
     if (G_raw > ac->gain_smoothed) {
+        /* сигнал стал тише — плавно поднимаем gain (атака) */
         float max_rise = ac->gain_smoothed * ac->rise_factor_per_block;
         ac->gain_smoothed = G_raw < max_rise ? G_raw : max_rise;
     } else {
-        ac->gain_smoothed = G_raw;
+        /* сигнал стал громче — плавно опускаем gain (release), без мгновенной ступеньки
+         * (мгновенный дроп давал клик на границе 20мс-блока). */
+        float min_fall = ac->gain_smoothed / ac->release_factor_per_block;
+        ac->gain_smoothed = G_raw > min_fall ? G_raw : min_fall;
     }
     if (ac->gain_smoothed > ac->max_gain) ac->gain_smoothed = ac->max_gain;
 
     float gain_db = 20.0f * log10f(ac->gain_smoothed > 0.0001f ? ac->gain_smoothed : 0.0001f);
     float prev_db = 20.0f * log10f(G_prev > 0.0001f ? G_prev : 0.0001f);
     if (ac->dbg_counter % 25 == 0 || fabsf(gain_db - prev_db) > 3.0f) {
-        DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "audio_compressor: block %zu level=%.4f envelope=%.4f gainRaw=%.1fdB gain=%.1fdB",
-                    idx, ac->block_levels[idx], envelope, 20.0f * log10f(G_raw), gain_db);
+        DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "audio_compressor: block %zu level=%.4f envelope=%.4f gainRaw=%.1fdB gain=%.1fdB clip=%u",
+                    idx, ac->block_levels[idx % ac->levels_cap], envelope, 20.0f * log10f(G_raw), gain_db, (unsigned)ac->clip_count);
     }
     ac->dbg_counter++;
 
-    for (size_t i = 0; i < ac->pending[0].count; i++) {
-        float v = (float)ac->pending[0].samples[i] * ac->gain_smoothed;
-        if (v > 32767.0f) v = 32767.0f;
-        if (v < -32768.0f) v = -32768.0f;
-        ac->pending[0].samples[i] = (int16_t)(int)v;
+    for (size_t i = 0; i < count; i++) {
+        float v = (float)samples[i] * ac->gain_smoothed;
+        if (v > 32767.0f) { v = 32767.0f; ac->clip_count++; }
+        if (v < -32768.0f) { v = -32768.0f; ac->clip_count++; }
+        samples[i] = (int16_t)(int)v;
     }
-    append_output(ac, ac->pending[0].samples, ac->pending[0].count);
-    u_free(ac->pending[0].samples);
-
-    /* shift remaining pending blocks down */
-    if (ac->pending_count > 1)
-        memmove(ac->pending, ac->pending + 1, (ac->pending_count - 1) * sizeof(*ac->pending));
-    ac->pending_count--;
 }
 
-void audio_compressor_flush(struct audio_compressor* ac) {
-    if (!ac) return;
-    if (!ac->enabled) return;
+/* Слить один готовый блок записи. История хранится по абсолютному номеру в кольце. */
+static int drain_block(struct audio_compressor* ac, size_t count) {
+    if (reserve_output(ac, count) != 0) return -1;
+    int16_t* samples = ac->pending + ac->pending_head * ac->block_samples;
+    apply_gain(ac, samples, count, ac->blocks_seen - ac->pending_count);
+    memcpy(ac->output + ac->output_size, samples, count * sizeof(int16_t));
+    ac->output_size += count;
+    ac->pending_head = (ac->pending_head + 1) % ac->pending_cap;
+    --ac->pending_count;
+    return 0;
+}
 
-    if (ac->accum_count > 0) {
-        float level = compute_block_level(ac->accumulator, ac->accum_count);
-        add_block_level(ac, level);
-
-        ensure_pending_cap(ac);
-        ac->pending[ac->pending_count].samples    = ac->accumulator;
-        ac->pending[ac->pending_count].count       = ac->accum_count;
-        ac->pending[ac->pending_count].level_index = ac->block_levels_count - 1;
-        ac->pending_count++;
-
-        ac->accumulator = NULL;
-        ac->accum_count = 0;
+/* Ровно один кадр, без output-накопителя и выделений памяти. in/out могут совпадать. */
+int audio_compressor_process_frame(struct audio_compressor* ac, const int16_t* in, int16_t* out, size_t count) {
+    if (!ac || !ac->configured || ac->failed || !in || !out || count != (size_t)ac->block_samples ||
+        ac->lookahead_blocks || ac->pending_count || ac->accum_count) {
+        DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: invalid streaming frame count=%zu", count);
+        return -1;
     }
-
-    if (ac->pending_count > 0)
-        DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "audio_compressor_flush: %zu pending blocks (gainSmoothed=%.1fdB)",
-                   ac->pending_count, 20.0f * log10f(ac->gain_smoothed > 0.0001f ? ac->gain_smoothed : 0.0001f));
-
-    while (ac->pending_count > 0)
-        process_pending_block(ac);
+    memmove(out, in, count * sizeof(int16_t));
+    if (ac->enabled) {
+        size_t idx = ac->blocks_seen++;
+        ac->block_levels[idx % ac->levels_cap] = compute_block_level(in, count);
+        apply_gain(ac, out, count, idx);
+    }
+    return 0;
 }
 
-const int16_t* audio_compressor_output(const struct audio_compressor* ac) {
-    return ac ? ac->output : NULL;
+int audio_compressor_push(struct audio_compressor* ac, const int16_t* samples, size_t count) {
+    if (!ac || !ac->configured || ac->failed || (!samples && count)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: invalid recording input"); return -1;
+    }
+    if (!ac->enabled) {
+        if (reserve_output(ac, count) != 0) return -1;
+        if (count) memcpy(ac->output + ac->output_size, samples, count * sizeof(int16_t));
+        ac->output_size += count;
+        return 0;
+    }
+    while (count) {
+        size_t take = (size_t)ac->block_samples - ac->accum_count;
+        if (take > count) take = count;
+        int16_t* block = ac->pending + ((ac->pending_head + ac->pending_count) % ac->pending_cap) * ac->block_samples;
+        memcpy(block + ac->accum_count, samples, take * sizeof(int16_t));
+        samples += take; count -= take; ac->accum_count += take;
+        if (ac->accum_count == (size_t)ac->block_samples) {
+            ac->block_levels[ac->blocks_seen++ % ac->levels_cap] = compute_block_level(block, ac->accum_count);
+            ac->accum_count = 0; ++ac->pending_count;
+            if (ac->pending_count > (size_t)ac->lookahead_blocks && drain_block(ac, ac->block_samples) != 0) return -1;
+        }
+    }
+    return 0;
 }
 
-size_t audio_compressor_output_size(const struct audio_compressor* ac) {
-    return ac ? ac->output_size : 0;
+int audio_compressor_flush(struct audio_compressor* ac) {
+    if (!ac || !ac->configured || ac->failed) { DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "compressor: invalid flush"); return -1; }
+    if (!ac->enabled) return 0;
+    size_t tail = ac->accum_count;
+    if (tail) {
+        int16_t* block = ac->pending + ((ac->pending_head + ac->pending_count) % ac->pending_cap) * ac->block_samples;
+        ac->block_levels[ac->blocks_seen++ % ac->levels_cap] = compute_block_level(block, tail);
+        ac->accum_count = 0; ++ac->pending_count;
+    }
+    while (ac->pending_count) {
+        size_t count = tail && ac->pending_count == 1 ? tail : (size_t)ac->block_samples;
+        if (drain_block(ac, count) != 0) return -1;
+    }
+    return 0;
+}
+
+const int16_t* audio_compressor_output(const struct audio_compressor* ac) { return ac ? ac->output : NULL; }
+size_t audio_compressor_output_size(const struct audio_compressor* ac) { return ac ? ac->output_size : 0; }
+void audio_compressor_clear_output(struct audio_compressor* ac) { if (ac) ac->output_size = 0; }
+uint32_t audio_compressor_clip_count(const struct audio_compressor* ac) { return ac ? ac->clip_count : 0; }
+float audio_compressor_gain_db(const struct audio_compressor* ac) {
+    return ac && ac->configured && ac->enabled ? 20.0f * log10f(ac->gain_smoothed) : 0.0f;
 }

lib/audio_compressor.h

@@ -1,3 +1,9 @@
+/* audio_compressor — адаптивное усиление int16 PCM (моно/стерео) с общей огибающей каналов.
+ * create → configure → обработка → destroy; объект использует один владелец, блокировок нет.
+ * Запись: push принимает произвольные порции, flush завершает хвост и lookahead; output принадлежит объекту.
+ * Поток: process_frame обрабатывает ровно sample_rate*block_duration_ms/1000*channels отсчётов,
+ * требует нулевого lookahead и пустого входного накопителя; in/out могут совпадать.
+ * count/output_size — interleaved отсчёты, не байты и не кадры на канал. Выключение даёт исходный PCM. */
 #ifndef AUDIO_COMPRESSOR_H
 #define AUDIO_COMPRESSOR_H
 
@@ -18,24 +24,40 @@ typedef struct {
     int lookahead_ms;
     float max_gain_db;
     float rise_rate_per_sec;
-    float target_level;
+    float release_rate_per_sec;   /* скорость плавного снижения gain (0 = авто: rise*5) */
+    float target_level;           /* Линейная амплитуда огибающей, не дБ; 0 задаёт default 0.25. */
 } audio_compressor_config_t;
 
 struct audio_compressor* audio_compressor_create(void);
+/* Новый пустой compressor с теми же настройками; позволяет передать запись worker без копии PCM. */
+struct audio_compressor* audio_compressor_clone_config(const struct audio_compressor* source);
 void audio_compressor_destroy(struct audio_compressor* ac);
 
-void audio_compressor_configure(struct audio_compressor* ac, const audio_compressor_config_t* cfg);
+int audio_compressor_configure(struct audio_compressor* ac, const audio_compressor_config_t* cfg);
+/* Потоковый кадр без lookahead: результат немедленный, память не выделяется; 0 / -1. */
+int audio_compressor_process_frame(struct audio_compressor* ac, const int16_t* in, int16_t* out, size_t count);
 void audio_compressor_reset(struct audio_compressor* ac);
 
 void audio_compressor_set_enabled(struct audio_compressor* ac, int enabled);
 int  audio_compressor_is_enabled(const struct audio_compressor* ac);
 
-void audio_compressor_push(struct audio_compressor* ac, const int16_t* samples, size_t count);
-void audio_compressor_flush(struct audio_compressor* ac);
+/* push копирует вход; push/flush возвращают 0 / -1. Ошибка накопления требует reset перед повтором. */
+int audio_compressor_push(struct audio_compressor* ac, const int16_t* samples, size_t count);
+int audio_compressor_flush(struct audio_compressor* ac);
 
+/* Указатель действителен до изменения/освобождения выходного буфера; вызывающий его не освобождает. */
 const int16_t* audio_compressor_output(const struct audio_compressor* ac);
 size_t         audio_compressor_output_size(const struct audio_compressor* ac);
 
+/* Сбросить накопленный выход (output_size=0) после слива — для потокового режима.
+ * НЕ трогает gain_smoothed (адаптивная громкость сохраняется). */
+void           audio_compressor_clear_output(struct audio_compressor* ac);
+
+/* Число сэмплов, обрезанных по потолку int16 (клиппинг) с момента create/reset. */
+uint32_t       audio_compressor_clip_count(const struct audio_compressor* ac);
+/* Текущее фактическое усиление в дБ; выключенный compressor возвращает 0. */
+float          audio_compressor_gain_db(const struct audio_compressor* ac);
+
 #ifdef __cplusplus
 }
 #endif

lib/debug_config.c

@@ -129,6 +129,15 @@ static const struct {
     {"chat_sync", DEBUG_CATEGORY_CHAT_SYNC},
     {"member_sync", DEBUG_CATEGORY_MEMBER_SYNC},
     {"proxy", DEBUG_CATEGORY_PROXY},
+    {"video", DEBUG_CATEGORY_VIDEO},
+    {"reality", DEBUG_CATEGORY_REALITY},
+    {"dm", DEBUG_CATEGORY_DM},
+    {"call", DEBUG_CATEGORY_CALL},
+    {"radio", DEBUG_CATEGORY_RADIO},
+    {"vad", DEBUG_CATEGORY_VAD},
+    {"aec", DEBUG_CATEGORY_AEC},
+    {"stream", DEBUG_CATEGORY_STREAM},
+    {"discovery", DEBUG_CATEGORY_DISCOVERY},
     {"all", DEBUG_CATEGORY_ALL},
     {NULL, DEBUG_CATEGORY_NONE}
 };
@@ -263,6 +272,10 @@ void debug_set_masks(debug_category_t category_idx, debug_level_t level) {
     debug_set_category_level(category_idx, level);
 }
 
+void debug_enable_timestamp(int enable) {
+    g_debug_config.timestamp_enabled = !!enable;
+}
+
 void debug_enable_function_name(int enable) {
     g_debug_config.function_name_enabled = enable;
 }
@@ -314,15 +327,24 @@ void debug_disable_file_output(void) {
     }
 }
 
-/* Reopen log file (append mode) for SIGHUP. Complete operation with full error logging. */
+/* Переоткрыть лог в append-режиме; при ошибке открытия сохранить прежний поток. */
 int debug_reopen_log(void) {
     if (!g_debug_config.output_file) {
         DEBUG_WARN(DEBUG_CATEGORY_CONFIG, "No log path for reopen");
         return -1;
     }
     const char* path = g_debug_config.output_file;
-    debug_disable_file_output();
-    debug_enable_file_output(path, 0);  // append
+    FILE* new_file = fopen(path, "a");
+    if (!new_file) {
+        DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Cannot reopen log '%s': %s", path, strerror(errno));
+        return -1;
+    }
+    FILE* old_file = g_debug_config.file_output;
+    g_debug_config.file_output = new_file;
+    if (old_file && fclose(old_file) != 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Cannot close previous log '%s': %s", path, strerror(errno));
+        return -1;
+    }
     DEBUG_INFO(DEBUG_CATEGORY_CONFIG, "Log reopened: %s", path);
     return 0;
 }
@@ -382,13 +404,15 @@ void debug_output(debug_level_t level, debug_category_t category_idx,
     va_start(args, format);
     
     /* Add timestamp with microseconds: hh:mm:ss-xxx.yyy */
-    struct timeval tv;
-    utun_gettimeofday(&tv, NULL);
-    time_t tv_sec = (time_t)tv.tv_sec;
-    struct tm* tm_info = localtime(&tv_sec);
-    char time_str[32];
-    strftime(time_str, sizeof(time_str), "%H:%M:%S", tm_info);
-    BUF_ADVANCE(snprintf(buffer + offset, remaining, "[%s-%03ld.%03ld] ", time_str, tv.tv_usec / 1000, tv.tv_usec % 1000));
+    if (g_debug_config.timestamp_enabled) {
+        struct timeval tv;
+        utun_gettimeofday(&tv, NULL);
+        time_t tv_sec = (time_t)tv.tv_sec;
+        struct tm* tm_info = localtime(&tv_sec);
+        char time_str[32];
+        strftime(time_str, sizeof(time_str), "%H:%M:%S", tm_info);
+        BUF_ADVANCE(snprintf(buffer + offset, remaining, "[%s-%03ld.%03ld] ", time_str, tv.tv_usec / 1000, tv.tv_usec % 1000));
+    }
     
     /* Add thread marker if set */
     if (g_debug_config.thread_marker > 0) {
@@ -451,7 +475,7 @@ void debug_set_log_hook(debug_log_hook_fn hook) {
     g_log_hook = hook;
 }
 
-/* Parse debug configuration from string (e.g., "ll_queue:debug,uasync:info,memory:warn,etcp:error") */
+/* Настройка отдельных категорий: "sys=debug,etcp=error"; разделитель ':' также допустим. */
 int debug_parse_config(const char* config_string) {
     if (!config_string || !*config_string) {
         return 0;
@@ -459,12 +483,10 @@ int debug_parse_config(const char* config_string) {
 
     char* str = u_strdup(config_string);
     if (!str) {
+        DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Failed to allocate debug configuration copy");
         return -1;
     }
 
-    debug_category_t categories = 0;
-    debug_level_t level = DEBUG_LEVEL_NONE;
-
     char* token = strtok(str, ",");
     while (token) {
         /* Trim leading spaces */
@@ -472,15 +494,16 @@ int debug_parse_config(const char* config_string) {
             token++;
         }
 
-        char* colon = strchr(token, ':');
-        if (!colon) {
+        char* separator = strpbrk(token, "=:");
+        if (!separator) {
+            DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Missing '=' or ':' in debug setting '%s'", token);
             u_free(str);
             return -1;
         }
 
-        *colon = '\0';
+        *separator = '\0';
         char* category_name = token;
-        char* level_name = colon + 1;
+        char* level_name = separator + 1;
 
         /* Trim leading spaces in level_name */
         while (isspace(*level_name)) {
@@ -488,22 +511,16 @@ int debug_parse_config(const char* config_string) {
         }
 
         debug_category_t cat = get_category_by_name(category_name);
-        if (cat == DEBUG_CATEGORY_NONE) {
-            DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Unknown debug category '%s'", category_name);
+        if (cat <= DEBUG_CATEGORY_NONE || cat >= DEBUG_CATEGORY_COUNT) {
+            DEBUG_ERROR(DEBUG_CATEGORY_CONFIG, "Unknown or unsupported debug category '%s' (expected an individual category)", category_name);
             u_free(str);
             return -1;
         }
 
         debug_level_t lev = debug_level_from_name(level_name);
 
-        /* Set per-category level */
-        int idx = 0;
-        while (!(cat & (1ULL << idx)) && idx < DEBUG_CATEGORY_COUNT) {
-            idx++;
-        }
-        if (idx < DEBUG_CATEGORY_COUNT) {
-            g_debug_config.category_levels[idx] = lev;
-        }
+        debug_set_category_level(cat, lev);
+        DEBUG_DEBUG(DEBUG_CATEGORY_CONFIG, "Applied debug setting: %s=%s (category=%d, level=%d)", category_name, level_name, cat, lev);
 
         token = strtok(NULL, ",");
     }

lib/debug_config.h

@@ -1,6 +1,12 @@
 /**
- * Runtime debug configuration system
- * Provides flexible control over debug output without recompilation
+ * Управление диагностикой: debug_config_init → уровни категорий и настройки вывода → DEBUG_*.
+ * NONE наследует общий уровень, DISABLED отключает категорию. Имена настроек — category=level.
+ * Открытый файл имеет приоритет над консолью; hook получает сообщения независимо от выбора выхода.
+ * Уровни: disabled, none, error, warn, info, debug, trace; отдельный уровень категории заменяет общий, не max().
+ * Пример: debug_config_init(); debug_set_level(DEBUG_LEVEL_INFO); debug_parse_config("etcp=trace,config=info").
+ * DEBUG_* фильтруют до форматирования; прямой debug_output фильтр не проверяет.
+ * Строка с префиксами ограничена буфером 4096 байт и обрезается; каждый вывод fflush.
+ * Модуль и смена глобальных настроек/файлов не синхронизированы; параллельный доступ согласует владелец.
  */
 
 #ifndef DEBUG_CONFIG_H
@@ -41,7 +47,7 @@ typedef int debug_category_t;
 #define DEBUG_CATEGORY_NONE        0
 #define DEBUG_CATEGORY_SYS         1  // System: u_async, ll_queue, memory, timing
 // #define DEBUG_CATEGORY_LL_QUEUE  2  (merged into SYS)
-#define DEBUG_CATEGORY_CONNECTION  3  // Connection: links, keepalive, status events
+#define DEBUG_CATEGORY_CONNECTION  3  // Connection: connect/reconnect/disconnect events only
 #define DEBUG_CATEGORY_ETCP        4  // ETCP: protocol, BBR, normalizer
 #define DEBUG_CATEGORY_CRYPTO      5  // crypto operations
 // #define DEBUG_CATEGORY_MEMORY    6  (merged into SYS)
@@ -67,19 +73,28 @@ typedef int debug_category_t;
 #define DEBUG_CATEGORY_CHAT_SYNC    26  // Message DB sync (INIT_SYNC, PUSH, chain hash, recalc)
 #define DEBUG_CATEGORY_MEMBER_SYNC 27  // Member + address + merkle sync
 #define DEBUG_CATEGORY_PROXY      28  // Proxy modules (SOCKS5, TCP, UDP, ICMP)
-#define DEBUG_CATEGORY_COUNT      29  // Total number of categories
+#define DEBUG_CATEGORY_VIDEO      29  // Video module (probe/transcode)
+#define DEBUG_CATEGORY_REALITY    30  // REALITY TLS camouflage
+#define DEBUG_CATEGORY_DM         31  // DM — direct p2p chat between two users
+#define DEBUG_CATEGORY_CALL       32  // Call — P2P audio call (signaling + media)
+#define DEBUG_CATEGORY_RADIO      33  // Radio — PTT walkie-talkie multicast (voice)
+#define DEBUG_CATEGORY_VAD        34  // VAD — Silero voice activity detector (ONNX Runtime)
+#define DEBUG_CATEGORY_AEC        35  // AEC — acoustic echo cancellation (SpeexDSP)
+#define DEBUG_CATEGORY_STREAM     36  // Подписанные потоки, FEC, буферы и выбор поставщиков
+#define DEBUG_CATEGORY_DISCOVERY   37  // LAN UDP: discovery and delivery
+#define DEBUG_CATEGORY_COUNT      38  // Total number of categories
 #define DEBUG_CATEGORY_ALL         (-1) // special value for all categories
 
 /* Debug configuration structure */
 typedef struct {
     debug_level_t level;                   // Global debug level (default: ERROR)
-    debug_level_t category_levels[DEBUG_CATEGORY_COUNT];  // Per-category levels (0 = disabled)
+    debug_level_t category_levels[DEBUG_CATEGORY_COUNT];  // Уровень категории: NONE наследует общий, DISABLED выключает
     int timestamp_enabled;                 // Include timestamps in output
     int function_name_enabled;             // Include function names
     int file_line_enabled;                 // Include file:line info
-    const char* output_file;               // NULL = stdout, otherwise file path
+    const char* output_file;               // Заимствованный путь для reopen; строка должна жить, пока поле её хранит
     
-    // Dual output support
+    // Выход: файл, иначе консоль при console_enabled != 0
     FILE* file_output;                     // File handle for log file (NULL if not open)
     int console_enabled;                   // Enable console output
     int thread_marker;                     // Thread identification (0=none, e.g. 2 for uasync)
@@ -88,38 +103,47 @@ typedef struct {
 /* Global debug configuration */
 extern debug_config_t g_debug_config;
 
-/* Initialize debug system with default settings */
+/* До использования: ERROR, категории NONE, консоль stdout, timestamp/function/file:line включены.
+ * Повторный init сбрасывает поля, но не закрывает уже открытый файл; перед ним закрыть файл отдельно. */
 void debug_config_init(void);
 
 /* Set debug level */
-// итоговый level = max (global level - здесь задается, category level)
+// Общий уровень применяется к категориям с уровнем NONE.
 void debug_set_level(debug_level_t level);
 
-/* Set debug level for specific category (0 = disabled, otherwise uses that level) */
+/* Уровень категории заменяет общий; NONE наследует его, DISABLED подавляет вывод. */
 void debug_set_category_level(debug_category_t category, debug_level_t level);
 
-/* Enable/disable specific categories */
+/* enable фиксирует текущий общий уровень; disable возвращает к наследованию (NONE).
+ * Для полного выключения использовать debug_set_category_level(cat, DEBUG_LEVEL_DISABLED). */
 void debug_enable_category(debug_category_t category);
 void debug_disable_category(debug_category_t category);
 void debug_set_categories(debug_category_t categories);
 
-/* Set masks directly */
+/* Установка уровня одной категории (аргумент categories — индекс, не битовая маска). */
 void debug_set_masks(debug_category_t categories, debug_level_t level);
 
-/* Configure output options */
+/* Configure output options */
+/* Ненулевое enable включает временную метку, 0 отключает. */
 void debug_enable_timestamp(int enable);
 void debug_enable_function_name(int enable);
 void debug_enable_file_line(int enable);
-void debug_set_output_file(const char* file_path);
+/* Открыть ненулевой file_path в append-режиме, только если файл ещё не открыт; путь заимствован. */
+void debug_set_output_file(const char* file_path);
 
-/* Dual output configuration */
+/* Заменить файл: truncate != 0 → обрезать, иначе append. NULL ничего не меняет.
+ * Путь заимствован; успешное открытие также выключает console_enabled. */
 void debug_enable_file_output(const char* file_path, int truncate);
+/* Закрыть файл; прежнее значение console_enabled не восстанавливается. */
 void debug_disable_file_output(void);
+/* Переоткрыть текущий путь в append-режиме: 0 — успех, -1 — ошибка с диагностикой.
+ * При ошибке открытия сохраняет прежний поток; console_enabled не меняет. */
 int debug_reopen_log(void);
+/* Вывод в консоль разрешён только при отсутствии открытого файла. */
 void debug_enable_console(int enable);
 
 
-// IP address to string (static buffer, single-threaded)
+// IP/sockaddr в строку: результат возвращается по значению, освобождать не требуется.
 typedef struct {
     char str[54];  // INET6_ADDRSTRLEN(45) + 6chars (:port) + \0
 } ip_str_t;
@@ -127,7 +151,7 @@ typedef struct {
 ip_str_t ip_to_str(const void *addr, int family);// big endian addr
 ip_str_t sockaddr_storage_to_str(const struct sockaddr_storage *addr);// автоопределение v4 или v6
 
-// hex dump в лог
+// Hex dump: первые min(len, 128) байт; при len > 128 добавляет "...". Применяется фильтр уровня/категории.
 void log_dump(int level, int category, const char* prefix, const uint8_t* data, size_t len);
 
 /* Check if debug output should be shown for given level and category */
@@ -136,13 +160,13 @@ int debug_should_output(debug_level_t level, debug_category_t category_idx);
 /* Get current debug level */
 debug_level_t debug_get_level(void);
 
-/* Get category name by index */
+/* Заимствованное имя категории; для неизвестного индекса возвращает "UNKNOWN". */
 const char* debug_get_category_name(debug_category_t category_idx);
 
-/* Get category by name string */
+/* Поиск без учёта регистра: индекс, ALL для "all", NONE при NULL/неизвестном имени. */
 debug_category_t get_category_by_name(const char* name);
 
-/* Get level by name string with error reporting */
+/* Поиск без учёта регистра: NULL → NONE; неизвестное имя логируется и даёт INFO (fallback). */
 debug_level_t debug_level_from_name(const char* name);
 
 /* Set category level using text names (main API) */
@@ -154,16 +178,20 @@ int debug_apply_category_config(const char* category_name, const char* level_nam
 /* Apply global debug level from text name */
 void debug_apply_global_level(const char* level_name);
 
-/* Format and output debug message (internal use by macros) */
+/* Форматирует сообщение printf-формата с необязательными метками; фильтрацию выполняет вызывающий.
+ * Время календарное, локальное, hh:mm:ss-миллисекунды.микросекунды; положительный thread_marker выводится отдельно. */
 void debug_output(debug_level_t level, debug_category_t category_idx, 
                  const char* function, const char* file, int line,
                  const char* format, ...);
 
-/* Log hook — if set, called with every debug message (for JNI/bridge integration) */
+/* Hook вызывается синхронно для форматированного сообщения до записи в выход; NULL снимает hook.
+ * category/message заимствованы на время вызова, message указывает на стековый буфер; для хранения скопировать. */
 typedef void (*debug_log_hook_fn)(int level, const char* category, const char* message);
 void debug_set_log_hook(debug_log_hook_fn hook);
 
-/* Parse debug configuration from string (e.g. "etcp=trace,config=info") */
+/* Настройка отдельных категорий: "etcp=trace,config=info" (также ':' вместо '=').
+ * NULL/пустая строка ничего не меняет. Возвращает 0 при успехе, -1 при ошибке;
+ * настройки до ошибочного элемента остаются применёнными. */
 int debug_parse_config(const char* config_string);
 
 /* Convenience macros for debug output */
@@ -192,8 +220,8 @@ int debug_parse_config(const char* config_string);
         debug_output(DEBUG_LEVEL_TRACE, category, __FUNCTION__, __FILE__, __LINE__, fmt, ##__VA_ARGS__); \
     } } while(0)
 
-/* Backward compatibility - default to ERROR level if not specified */
-#define DEBUG_OUTPUT(fmt, ...) DEBUG_ERROR(DEBUG_CATEGORY_ALL, fmt, ##__VA_ARGS__)
+/* Сообщение без явной категории: ERROR в категории GENERAL, с обычной фильтрацией. */
+#define DEBUG_OUTPUT(fmt, ...) DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, fmt, ##__VA_ARGS__)
 
 #ifdef __cplusplus
 }

lib/debug_config_doc.md

@@ -1,112 +0,0 @@
-# debug_config — Runtime-система отладочного логирования
-
-## 1. Назначение
-
-Модуль обеспечивает гибкое управление отладочным выводом без перекомпиляции. Позволяет:
-- Задавать **глобальный уровень** логирования (error/warn/info/debug/trace).
-- **Покатегорийно** включать/выключать или переопределять уровень (26 категорий: etcp, crypto, tun, routing, bgp, bbr, …).
-- Вести **двойной вывод**: в консоль (stdout) и/или в файл.
-- Настраивать формат сообщений (временные метки с микросекундами, имя функции, файл:строка).
-- Парсить конфигурационную строку вида `"etcp=trace,config=info"` из конфиг-файла.
-
-Логика вывода: итоговый уровень = **max(глобальный уровень, уровень категории)**. Сообщение печатается, если его уровень ≤ итогового.
-
-## 2. Как пользоваться
-
-### 2.1. Инициализация
-
-```c
-#include "debug_config.h"
-
-debug_config_init();                     // уровень по умолчанию: ERROR, консоль включена
-debug_set_level(DEBUG_LEVEL_INFO);       // поднять глобальный уровень до INFO
-debug_enable_file_output("/tmp/utun.log", 1);  // писать в файл (truncate=1)
-debug_apply_category_config("etcp", "trace");  // для ETCP-категории — всё
-```
-
-### 2.2. Макросы логирования
-
-```c
-DEBUG_ERROR(DEBUG_CATEGORY_CRYPTO, "Decrypt failed: len=%d", len);
-DEBUG_WARN(DEBUG_CATEGORY_ETCP, "Retransmit timeout, seq=%u", seq);
-DEBUG_INFO(DEBUG_CATEGORY_CONNECTION, "Socket created on port %d", port);
-DEBUG_DEBUG(DEBUG_CATEGORY_ROUTING, "Route added: %s -> %s", dst, gw);
-DEBUG_TRACE(DEBUG_CATEGORY_TUN, "Packet recv: %zu bytes", n);
-```
-
-Макросы делают проверку `debug_should_output()` **перед** вызовом `debug_output()`, поэтому дорогой `vsnprintf` не вызывается, если вывод не нужен.
-
-### 2.3. Конфигурационная строка
-
-Формат: `"категория=уровень,категория=уровень,..."`. Парсится вызовом `debug_parse_config()`. Пример из конфиг-файла:
-
-```ini
-debug = etcp=trace,config=info,crypto=error
-```
-
-Категории: `none, uasync, ll_queue, connection, etcp, crypto, memory, timing, config, tun, routing, timers, normalizer, bgp, socket, control, dump, traffic, debug, general, nat, keepalive, etcp_route, bbr, etcp_dump, connectivity, all`.
-
-Уровни: `disabled, none, error, warn, info, debug, trace`.
-
-**Важно:** старый формат `ll_queue:debug` (двоеточие) тоже работает через `debug_parse_config`, но в конфиге рекомендуется `=`.
-
-### 2.4. Двойной вывод (консоль + файл)
-
-- По умолчанию вывод в **stdout**.
-- `debug_enable_file_output(path, truncate)` — перенаправляет вывод в файл, консоль отключается.
-- `debug_disable_file_output()` — закрывает файл.
-- `debug_reopen_log()` — переоткрывает лог-файл (используется по SIGHUP для ротации).
-- `debug_enable_console(1/0)` — ручное управление консольным выводом.
-
-### 2.5. Вспомогательные утилиты
-
-```c
-log_dump(DEBUG_LEVEL_TRACE, DEBUG_CATEGORY_DUMP, "payload", data, len); // hex-дамп (до 128 байт)
-
-ip_str_t s = sockaddr_storage_to_str(&addr);   // "192.168.1.1:8080" или "[::1]:443"
-ip_str_t s = ip_to_str(&addr, AF_INET);        // "192.168.1.1" (без порта)
-```
-
-### 2.6. Нюансы
-
-- **Потокобезопасность:** модуль не потокобезопасен. Несколько потоков, одновременно вызывающих макросы, могут перемешать вывод (но не упадут). Файловый вывод использует `fflush()` после каждой строки.
-- **Буфер:** размер строки лога ограничен 4096 байт (`BUFFER_SIZE`), длинные сообщения обрезаются.
-- **`debug_set_output_file`** против `debug_enable_file_output`: первая вызывается один раз (кто первый — того и тапки), вторая позволяет переоткрыть файл.
-- **Флаг `-f` (foreground):** в foreground-режиме вывод идёт в stdout, в daemon-режиме — в файл.
-
-## 3. API
-
-| Функция/макрос | Назначение |
-|---|---|
-| `debug_config_init()` | Инициализация: глобальный уровень ERROR, консоль включена, метки времени/функций/файлов — да |
-| `debug_set_level(level)` | Задать глобальный уровень (ERROR..TRACE) |
-| `debug_set_category_level(cat, level)` | Задать уровень конкретной категории (0 = использовать глобальный) |
-| `debug_set_category_level_by_name("etcp", "trace")` | То же, но именами строк |
-| `debug_apply_category_config("etcp", "trace")` | Установить уровень категории с логированием результата |
-| `debug_apply_global_level("info")` | Установить глобальный уровень по имени строки |
-| `debug_parse_config("etcp=trace,config=info")` | Разобрать конфигурационную строку |
-| `debug_should_output(level, cat)` | Проверить, нужно ли выводить сообщение данного уровня/категории |
-| `debug_output(level, cat, func, file, line, fmt, ...)` | Форматировать и вывести сообщение (вызывается макросами) |
-| `debug_enable_file_output(path, truncate)` | Включить вывод в файл (консоль отключается) |
-| `debug_disable_file_output()` | Закрыть файл вывода |
-| `debug_reopen_log()` | Переоткрыть лог-файл (для SIGHUP/ротации) |
-| `debug_enable_console(1/0)` | Включить/выключить консольный вывод |
-| `debug_get_level()` | Получить текущий глобальный уровень |
-| `get_category_by_name("etcp")` | Получить ID категории по имени строки |
-| `debug_level_from_name("trace")` | Получить уровень по имени строки |
-| `debug_get_category_name(cat)` | Получить имя категории по ID |
-| `log_dump(level, cat, prefix, data, len)` | Hex-дамп данных (первые 128 байт) в лог |
-| `ip_to_str(addr, family)` | IP-адрес → строка (без порта). Статический буфер |
-| `sockaddr_storage_to_str(addr)` | sockaddr_storage → "ip:port" (IPv6 в скобках). Статический буфер |
-| `DEBUG_ERROR/WARN/INFO/DEBUG/TRACE(cat, fmt, ...)` | Макросы логирования с проверкой `debug_should_output()` |
-| `DEBUG_OUTPUT(fmt, ...)` | Устаревший макрос совместимости (ERROR, категория ALL) |
-
-**Глобальная переменная:** `g_debug_config` (тип `debug_config_t`) — хранит всё состояние системы логирования.
-
-**Структура `debug_config_t`:**
-- `level` — глобальный уровень (по умолчанию ERROR)
-- `category_levels[26]` — уровни по категориям (NONE = использовать глобальный, DISABLED = никогда не выводить)
-- `timestamp_enabled` / `function_name_enabled` / `file_line_enabled` — формат вывода
-- `file_output` — FILE* файла (NULL если вывод в консоль)
-- `console_enabled` — вывод в stdout
-- `thread_marker` — числовой маркер потока (0 = нет)

lib/dns.c

@@ -3403,27 +3403,33 @@ size_t dns_txt_print(void *dst_, size_t lim, struct dns_txt *txt) {
 } /* dns_txt_print() */
 
 
+typedef int    (*dns_parse_fn)(union dns_any *, struct dns_rr *, struct dns_packet *);
+typedef int    (*dns_push_fn)(struct dns_packet *, union dns_any *);
+typedef int    (*dns_cmp_fn)(const union dns_any *, const union dns_any *);
+typedef size_t (*dns_print_fn)(void *, size_t, union dns_any *);
+typedef size_t (*dns_cname_fn)(void *, size_t, union dns_any *);
+
 static const struct {
 	enum dns_type type;
 	const char *name;
-	int (*parse)();
-	int (*push)();
-	int (*cmp)();
-	size_t (*print)();
-	size_t (*cname)();
+	dns_parse_fn parse;
+	dns_push_fn push;
+	dns_cmp_fn cmp;
+	dns_print_fn print;
+	dns_cname_fn cname;
 } dns_rrtypes[]	= {
-	{ DNS_T_A,      "A",      &dns_a_parse,      &dns_a_push,      &dns_a_cmp,      &dns_a_print,      0                },
-	{ DNS_T_AAAA,   "AAAA",   &dns_aaaa_parse,   &dns_aaaa_push,   &dns_aaaa_cmp,   &dns_aaaa_print,   0                },
-	{ DNS_T_MX,     "MX",     &dns_mx_parse,     &dns_mx_push,     &dns_mx_cmp,     &dns_mx_print,     &dns_mx_cname    },
-	{ DNS_T_NS,     "NS",     &dns_ns_parse,     &dns_ns_push,     &dns_ns_cmp,     &dns_ns_print,     &dns_ns_cname    },
-	{ DNS_T_CNAME,  "CNAME",  &dns_cname_parse,  &dns_cname_push,  &dns_cname_cmp,  &dns_cname_print,  &dns_cname_cname },
-	{ DNS_T_SOA,    "SOA",    &dns_soa_parse,    &dns_soa_push,    &dns_soa_cmp,    &dns_soa_print,    0                },
-	{ DNS_T_SRV,    "SRV",    &dns_srv_parse,    &dns_srv_push,    &dns_srv_cmp,    &dns_srv_print,    &dns_srv_cname   },
-	{ DNS_T_OPT,    "OPT",    &dns_opt_parse,    &dns_opt_push,    &dns_opt_cmp,    &dns_opt_print,    0                },
-	{ DNS_T_PTR,    "PTR",    &dns_ptr_parse,    &dns_ptr_push,    &dns_ptr_cmp,    &dns_ptr_print,    &dns_ptr_cname   },
-	{ DNS_T_TXT,    "TXT",    &dns_txt_parse,    &dns_txt_push,    &dns_txt_cmp,    &dns_txt_print,    0                },
-	{ DNS_T_SPF,    "SPF",    &dns_txt_parse,    &dns_txt_push,    &dns_txt_cmp,    &dns_txt_print,    0                },
-	{ DNS_T_SSHFP,  "SSHFP",  &dns_sshfp_parse,  &dns_sshfp_push,  &dns_sshfp_cmp,  &dns_sshfp_print,  0                },
+	{ DNS_T_A,      "A",      (dns_parse_fn)&dns_a_parse,      (dns_push_fn)&dns_a_push,      (dns_cmp_fn)&dns_a_cmp,      (dns_print_fn)&dns_a_print,      0                    },
+	{ DNS_T_AAAA,   "AAAA",   (dns_parse_fn)&dns_aaaa_parse,   (dns_push_fn)&dns_aaaa_push,   (dns_cmp_fn)&dns_aaaa_cmp,   (dns_print_fn)&dns_aaaa_print,   0                    },
+	{ DNS_T_MX,     "MX",     (dns_parse_fn)&dns_mx_parse,     (dns_push_fn)&dns_mx_push,     (dns_cmp_fn)&dns_mx_cmp,     (dns_print_fn)&dns_mx_print,     (dns_cname_fn)&dns_mx_cname    },
+	{ DNS_T_NS,     "NS",     (dns_parse_fn)&dns_ns_parse,     (dns_push_fn)&dns_ns_push,     (dns_cmp_fn)&dns_ns_cmp,     (dns_print_fn)&dns_ns_print,     (dns_cname_fn)&dns_ns_cname    },
+	{ DNS_T_CNAME,  "CNAME",  (dns_parse_fn)&dns_cname_parse,  (dns_push_fn)&dns_cname_push,  (dns_cmp_fn)&dns_cname_cmp,  (dns_print_fn)&dns_cname_print,  (dns_cname_fn)&dns_cname_cname },
+	{ DNS_T_SOA,    "SOA",    (dns_parse_fn)&dns_soa_parse,    (dns_push_fn)&dns_soa_push,    (dns_cmp_fn)&dns_soa_cmp,    (dns_print_fn)&dns_soa_print,    0                    },
+	{ DNS_T_SRV,    "SRV",    (dns_parse_fn)&dns_srv_parse,    (dns_push_fn)&dns_srv_push,    (dns_cmp_fn)&dns_srv_cmp,    (dns_print_fn)&dns_srv_print,    (dns_cname_fn)&dns_srv_cname   },
+	{ DNS_T_OPT,    "OPT",    (dns_parse_fn)&dns_opt_parse,    (dns_push_fn)&dns_opt_push,    (dns_cmp_fn)&dns_opt_cmp,    (dns_print_fn)&dns_opt_print,    0                    },
+	{ DNS_T_PTR,    "PTR",    (dns_parse_fn)&dns_ptr_parse,    (dns_push_fn)&dns_ptr_push,    (dns_cmp_fn)&dns_ptr_cmp,    (dns_print_fn)&dns_ptr_print,    (dns_cname_fn)&dns_ptr_cname   },
+	{ DNS_T_TXT,    "TXT",    (dns_parse_fn)&dns_txt_parse,    (dns_push_fn)&dns_txt_push,    (dns_cmp_fn)&dns_txt_cmp,    (dns_print_fn)&dns_txt_print,    0                    },
+	{ DNS_T_SPF,    "SPF",    (dns_parse_fn)&dns_txt_parse,    (dns_push_fn)&dns_txt_push,    (dns_cmp_fn)&dns_txt_cmp,    (dns_print_fn)&dns_txt_print,    0                    },
+	{ DNS_T_SSHFP,  "SSHFP",  (dns_parse_fn)&dns_sshfp_parse,  (dns_push_fn)&dns_sshfp_push,  (dns_cmp_fn)&dns_sshfp_cmp,  (dns_print_fn)&dns_sshfp_print,  0                    },
 }; /* dns_rrtypes[] */
 
 

lib/dns.h

@@ -508,7 +508,7 @@ struct dns_rr_i {
 
 	int follow;
 
-	int (*sort)();
+	int (*sort)(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
 	unsigned args[2];
 
 	struct {

lib/file_io.c

@@ -0,0 +1,331 @@
+#include "file_io.h"
+#include "platform_compat.h"
+#include "debug_config.h"
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <limits.h>
+
+#ifdef _WIN32
+static SRWLOCK temp_mutex = SRWLOCK_INIT;
+#define TEMP_LOCK() AcquireSRWLockExclusive(&temp_mutex)
+#define TEMP_UNLOCK() ReleaseSRWLockExclusive(&temp_mutex)
+#else
+#include <pthread.h>
+static pthread_mutex_t temp_mutex = PTHREAD_MUTEX_INITIALIZER;
+#define TEMP_LOCK() pthread_mutex_lock(&temp_mutex)
+#define TEMP_UNLOCK() pthread_mutex_unlock(&temp_mutex)
+#endif
+
+/* Реестр заимствует стабильный адрес владельца, не выделяет память и общий для workers/instances. */
+static struct file_io_temp *owned_temps;
+
+static void file_io_temp_untrack(struct file_io_temp *output) {
+    struct file_io_temp **p = &owned_temps;
+    while (*p && *p != output) p = &(*p)->next_owned;
+    if (*p) *p = output->next_owned;
+    else DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file temporary owner missing from registry path=%s", output->temporary);
+    output->next_owned = NULL;
+}
+
+#ifdef _WIN32
+/* Общие пути API — UTF-8; ANSI Win32 API не применяется. */
+int file_io_wide(const char *path, wchar_t wide[FILE_IO_PATH_MAX]) {
+    if (path && *path && strlen(path) < FILE_IO_PATH_MAX
+        && MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, path, -1, wide, FILE_IO_PATH_MAX)) return 0;
+    DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file invalid UTF-8/oversized path winerr=%lu", GetLastError());
+    return -1;
+}
+#endif
+
+int file_io_inspect(const char *path, int follow, struct file_io_info *info) {
+    if (!path || !*path || strlen(path) >= FILE_IO_PATH_MAX || !info) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file inspect invalid path/output"); return -1;
+    }
+    struct file_io_info result = {0};
+#ifdef _WIN32
+    wchar_t wide[FILE_IO_PATH_MAX];
+    if (file_io_wide(path, wide)) return -1;
+    DWORD attributes = GetFileAttributesW(wide);
+    if (attributes == INVALID_FILE_ATTRIBUTES) {
+        DWORD error = GetLastError();
+        if (error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND) return 1;
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file inspect failed path=%s winerr=%lu", path, error); return -1;
+    }
+    if (!follow && (attributes & FILE_ATTRIBUTE_REPARSE_POINT)) result.type = FILE_IO_LINK;
+    else {
+        HANDLE handle = CreateFileW(wide, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                    NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+        BY_HANDLE_FILE_INFORMATION data;
+        int valid = handle != INVALID_HANDLE_VALUE && GetFileInformationByHandle(handle, &data);
+        if (valid) {
+            result.type = GetFileType(handle) != FILE_TYPE_DISK ? FILE_IO_OTHER
+                : (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? FILE_IO_DIRECTORY : FILE_IO_REGULAR;
+            uint64_t size = ((uint64_t)data.nFileSizeHigh << 32) | data.nFileSizeLow;
+            valid = size <= INT64_MAX;
+            result.size = (int64_t)size;
+            result.identity[0] = data.dwVolumeSerialNumber;
+            result.identity[1] = ((uint64_t)data.nFileIndexHigh << 32) | data.nFileIndexLow;
+        }
+        DWORD error = GetLastError();
+        if (handle != INVALID_HANDLE_VALUE) CloseHandle(handle);
+        if (!valid) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file handle inspect failed path=%s winerr=%lu", path, error); return -1; }
+    }
+#else
+    struct stat data;
+    if ((follow ? stat(path, &data) : lstat(path, &data))) {
+        if (errno == ENOENT) return 1;
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file inspect failed path=%s errno=%d", path, errno); return -1;
+    }
+    result.type = S_ISREG(data.st_mode) ? FILE_IO_REGULAR : S_ISDIR(data.st_mode) ? FILE_IO_DIRECTORY
+        : S_ISLNK(data.st_mode) ? FILE_IO_LINK : FILE_IO_OTHER;
+    if (data.st_size < 0 || (uint64_t)data.st_size > INT64_MAX) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file size out of range path=%s", path); return -1;
+    }
+    result.size = (int64_t)data.st_size;
+    result.identity[0] = data.st_dev; result.identity[1] = data.st_ino;
+#endif
+    *info = result;
+    return 0;
+}
+
+FILE *file_io_open_read(const char *path) {
+    struct file_io_info info;
+    if (file_io_inspect(path, 1, &info) || info.type != FILE_IO_REGULAR) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file source is not regular/readable path=%s", path ? path : "(null)"); return NULL;
+    }
+#ifdef _WIN32
+    wchar_t wide[FILE_IO_PATH_MAX];
+    if (file_io_wide(path, wide)) return NULL;
+    FILE *file = _wfopen(wide, L"rb");
+#else
+    FILE *file = fopen(path, "rb");
+#endif
+    if (!file) DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file open read failed path=%s errno=%d", path, errno);
+    return file;
+}
+
+FILE *file_io_open_update(const char *path) {
+    struct file_io_info info;
+    if (file_io_inspect(path, 0, &info) || info.type != FILE_IO_REGULAR) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file update requires regular file path=%s", path ? path : "(null)"); return NULL;
+    }
+#ifdef _WIN32
+    wchar_t wide[FILE_IO_PATH_MAX];
+    if (file_io_wide(path, wide)) return NULL;
+    FILE *file = _wfopen(wide, L"r+b");
+#else
+    FILE *file = fopen(path, "r+b");
+#endif
+    if (!file) DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file update open failed path=%s errno=%d", path, errno);
+    return file;
+}
+
+int file_io_paths(const char *source, const char *destination) {
+    struct file_io_info input, output;
+    if (file_io_inspect(source, 1, &input) || input.type != FILE_IO_REGULAR) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file invalid source path=%s", source ? source : "(null)"); return -1;
+    }
+    int status = file_io_inspect(destination, 0, &output);
+    if (status == 1) return 0;
+    if (status < 0) return -1;
+    if (output.type != FILE_IO_REGULAR) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file destination is not regular path=%s type=%d", destination, output.type); return -1;
+    }
+    return !memcmp(input.identity, output.identity, sizeof(input.identity));
+}
+
+/* Синхронизировать именно открытый файл; повторного открытия имени нет. */
+static int file_io_sync_descriptor(FILE *file, const char *path) {
+#ifdef _WIN32
+    int result = _commit(_fileno(file));
+#else
+    int result = fsync(fileno(file));
+#endif
+    if (result) {
+        int error = errno ? errno : EIO;
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file sync failed path=%s errno=%d", path, error);
+        errno = error;
+    }
+    return result ? -1 : 0;
+}
+
+int file_io_sync_file(const char *path) {
+    FILE *file = file_io_open_update(path);
+    if (!file) return -1;
+    int result = file_io_sync_descriptor(file, path);
+    if (fclose(file)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file sync close failed path=%s errno=%d", path, errno); result = -1;
+    }
+    return result;
+}
+
+int file_io_sync_directory(const char *path) {
+    if (!path || !*path || strlen(path) >= FILE_IO_PATH_MAX) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file directory sync invalid path"); return -1;
+    }
+#ifndef _WIN32
+    char parent[FILE_IO_PATH_MAX];
+    memcpy(parent, path, strlen(path) + 1);
+    char *slash = strrchr(parent, '/');
+    if (!slash) memcpy(parent, ".", 2);
+    else if (slash == parent) slash[1] = 0;
+    else *slash = 0;
+    int fd = open(parent, O_RDONLY | O_DIRECTORY);
+    if (fd < 0) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file directory open failed path=%s errno=%d", parent, errno); return -1; }
+    int error = fsync(fd) ? (errno ? errno : EIO) : 0;
+    if (close(fd) && !error) error = errno ? errno : EIO;
+    if (error) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file directory sync/close failed path=%s errno=%d", parent, error); return -1; }
+#endif
+    return 0;
+}
+
+/* Только rename; владелец temp снимает регистрацию до длительного directory sync. */
+static int file_io_rename(const char *source, const char *destination, unsigned flags) {
+#ifdef _WIN32
+    wchar_t from[FILE_IO_PATH_MAX], to[FILE_IO_PATH_MAX];
+    if (file_io_wide(source, from) || file_io_wide(destination, to)) return -1;
+    DWORD options = MOVEFILE_REPLACE_EXISTING | ((flags & FILE_IO_DURABLE) ? MOVEFILE_WRITE_THROUGH : 0);
+    if (!MoveFileExW(from, to, options)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file rename failed source=%s destination=%s winerr=%lu", source, destination, GetLastError());
+        return -1;
+    }
+#else
+    (void)flags;
+    if (rename(source, destination)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file rename failed source=%s destination=%s errno=%d", source, destination, errno); return -1;
+    }
+#endif
+    return 0;
+}
+
+int file_io_publish(const char *source, const char *destination) {
+    if (file_io_paths(source, destination)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file publish invalid source/destination"); return -1;
+    }
+    if (file_io_rename(source, destination, FILE_IO_DURABLE)) return -1;
+    if (file_io_sync_directory(destination)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file installed but directory durability unconfirmed destination=%s", destination); return -1;
+    }
+    DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "file durably installed destination=%s", destination);
+    return 0;
+}
+
+int file_io_temp_open(struct file_io_temp *output, const char *destination, unsigned flags) {
+    if (!output || output->file || output->temporary[0] || !destination || !*destination
+        || (flags & ~FILE_IO_DURABLE) || strlen(destination) + 38 >= FILE_IO_PATH_MAX) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file temporary invalid owner/path"); return -1;
+    }
+    output->flags = flags;
+    for (unsigned attempt = 0; attempt < 8; attempt++) {
+        uint8_t random[16]; char suffix[33];
+        if (random_bytes(random, sizeof(random))) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file temporary RNG failed"); return -1; }
+        for (unsigned i = 0; i < sizeof(random); i++) snprintf(suffix + i * 2, 3, "%02x", random[i]);
+        char temporary[FILE_IO_PATH_MAX];
+        snprintf(temporary, sizeof(temporary), "%s.tmp.%s", destination, suffix);
+#ifdef _WIN32
+        wchar_t wide[FILE_IO_PATH_MAX];
+        if (file_io_wide(temporary, wide)) return -1;
+        TEMP_LOCK();
+        int fd = _wopen(wide, _O_CREAT | _O_EXCL | _O_RDWR | _O_BINARY, _S_IREAD | _S_IWRITE);
+#else
+        TEMP_LOCK();
+        int fd = open(temporary, O_CREAT | O_EXCL | O_RDWR, 0600);
+#endif
+        if (fd < 0) {
+            int error = errno; TEMP_UNLOCK();
+            if (error == EEXIST) continue;
+            DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file temporary open failed destination=%s errno=%d", destination, error); return -1;
+        }
+        memcpy(output->temporary, temporary, strlen(temporary) + 1);
+        output->next_owned = owned_temps; owned_temps = output;
+        TEMP_UNLOCK(); /* Файл виден очистке только вместе с зарегистрированным владельцем. */
+#ifdef _WIN32
+        output->file = _fdopen(fd, "wb+");
+        if (!output->file) _close(fd);
+#else
+        output->file = fdopen(fd, "wb+");
+        if (!output->file) close(fd);
+#endif
+        if (!output->file) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file fdopen failed path=%s errno=%d", output->temporary, errno); return -1; }
+        DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "file temporary opened path=%s durable=%u", output->temporary, flags & FILE_IO_DURABLE);
+        return 0;
+    }
+    DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file temporary collision limit destination=%s", destination); return -1;
+}
+
+int file_io_temp_finish(struct file_io_temp *output) {
+    if (!output || !output->file) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file finish without open file"); return -1; }
+    int error = fflush(output->file) ? (errno ? errno : EIO) : 0;
+    if (!error && (output->flags & FILE_IO_DURABLE) && file_io_sync_descriptor(output->file, output->temporary))
+        error = errno ? errno : EIO;
+    if (fclose(output->file) && !error) error = errno ? errno : EIO;
+    output->file = NULL;
+    if (error) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file flush/sync/close failed path=%s errno=%d", output->temporary, error); return -1; }
+    DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "file temporary finished path=%s durable=%u", output->temporary, output->flags & FILE_IO_DURABLE);
+    return 0;
+}
+
+void file_io_temp_discard(struct file_io_temp *output) {
+    if (!output) return;
+    if (output->file) {
+        if (fclose(output->file)) DEBUG_WARN(DEBUG_CATEGORY_SYS, "file cleanup close failed errno=%d", errno);
+        output->file = NULL;
+    }
+    if (!output->temporary[0]) return;
+#ifdef _WIN32
+    wchar_t wide[FILE_IO_PATH_MAX];
+    int valid = file_io_wide(output->temporary, wide) == 0;
+    TEMP_LOCK();
+    int error = valid ? _wremove(wide) : -1;
+#else
+    TEMP_LOCK();
+    int error = remove(output->temporary);
+#endif
+    if (error && errno != ENOENT) DEBUG_WARN(DEBUG_CATEGORY_SYS, "file cleanup remove failed path=%s errno=%d", output->temporary, errno);
+    file_io_temp_untrack(output);
+    output->temporary[0] = 0;
+    TEMP_UNLOCK();
+}
+
+int file_io_temp_publish(struct file_io_temp *output, const char *source, const char *destination) {
+    if (!output || output->file || !output->temporary[0] || file_io_paths(source, destination)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file publish invalid state/paths"); return -1;
+    }
+    TEMP_LOCK();
+    if (file_io_rename(output->temporary, destination, output->flags)) { TEMP_UNLOCK(); return -1; }
+    file_io_temp_untrack(output);
+    output->temporary[0] = 0;
+    TEMP_UNLOCK();
+    if ((output->flags & FILE_IO_DURABLE) && file_io_sync_directory(destination)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file temporary installed but directory durability unconfirmed destination=%s", destination); return -1;
+    }
+    DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "file published destination=%s durable=%u", destination, output->flags & FILE_IO_DURABLE);
+    return 0;
+}
+
+int file_io_remove_orphan(const char *path) {
+    if (!path || !*path) { DEBUG_ERROR(DEBUG_CATEGORY_SYS, "file orphan removal without path"); return -1; }
+#ifdef _WIN32
+    wchar_t wide[FILE_IO_PATH_MAX];
+    if (file_io_wide(path, wide)) return -1;
+#endif
+    TEMP_LOCK();
+    for (struct file_io_temp *owner = owned_temps; owner; owner = owner->next_owned) {
+        if (!strcmp(owner->temporary, path)) {
+            TEMP_UNLOCK();
+            DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "file orphan cleanup keeps active temporary path=%s", path);
+            return 0;
+        }
+    }
+#ifdef _WIN32
+    int result = _wremove(wide);
+#else
+    int result = remove(path);
+#endif
+    int error = errno; TEMP_UNLOCK();
+    if (!result) return 1;
+    if (error == ENOENT) return 0;
+    DEBUG_WARN(DEBUG_CATEGORY_SYS, "file orphan removal failed path=%s errno=%d", path, error);
+    return -1;
+}

lib/file_io.h

@@ -0,0 +1,63 @@
+/* file_io — синхронные файловые операции: UTF-8 пути, идентичность и публикация через соседний temp.
+ * inspect различает найденный/отсутствующий файл и ошибку; paths сравнивает идентичность файлов.
+ * Temp обнулить → open → писать в file → finish → publish; discard обязателен также при ошибке.
+ * Активный temp автоматически защищён от remove_orphan во всех потоках до publish/discard, включая время после finish.
+ * Пока temp активен, структуру нельзя копировать/перемещать; с одним temp работает один владелец.
+ * Исходник и каталоги должны оставаться стабильными на время операции. Это не защита от подмены родительских каталогов.
+ * FILE_IO_DURABLE сохраняет данные при finish и имя при publish. POSIX temp имеет права 0600.
+ * После успешного rename temp отсоединён даже при ошибке синхронизации каталога: отката публикации нет. */
+#ifndef FILE_IO_H
+#define FILE_IO_H
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#define FILE_IO_PATH_MAX 4096
+#define FILE_IO_DURABLE 1u
+enum file_io_type { FILE_IO_REGULAR = 1, FILE_IO_DIRECTORY, FILE_IO_LINK, FILE_IO_OTHER };
+struct file_io_info {
+    int type;                    // обычный файл, каталог, ссылка/reparse point или другой объект
+    int64_t size;                // размер в байтах, без сужения до int
+    uint64_t identity[3];        // идентификатор файла внутри файловой системы, сравнивать весь массив
+};
+struct file_io_temp {
+    char temporary[FILE_IO_PATH_MAX]; // только собственный temp; пусто после discard/publish
+    FILE *file;                      // открытый wb+; NULL после finish
+    struct file_io_temp *next_owned;  // внутренний реестр живых temp; изменяет только file_io под блокировкой
+    unsigned flags;                  // режим, заданный open: 0 либо FILE_IO_DURABLE на весь срок операции
+};
+
+// path — UTF-8; follow!=0 разрешает конечную ссылку. info обязателен, заполняется только при успехе.
+int file_io_inspect(const char *path, int follow, struct file_io_info *info);
+#ifdef _WIN32
+// Преобразовать непустой UTF-8 путь в wide[FILE_IO_PATH_MAX]; 0/-1.
+int file_io_wide(const char *path, wchar_t wide[FILE_IO_PATH_MAX]);
+#endif
+// Открыть обычный файл для чтения; путь UTF-8. NULL при ошибке, fclose принадлежит вызывающему.
+FILE *file_io_open_read(const char *path);
+// Открыть существующий regular-файл для чтения/записи без усечения; конечные ссылки запрещены. UTF-8, NULL при ошибке.
+FILE *file_io_open_update(const char *path);
+// Источник должен быть regular; назначение отсутствует или regular без конечной ссылки. 1 — один файл, 0 — разные, -1 — ошибка.
+int file_io_paths(const char *source, const char *destination);
+// Сохранить существующий закрытый regular-файл без конечной ссылки; UTF-8, 0/-1.
+int file_io_sync_file(const char *path);
+// Сохранить каталог, содержащий path; без разделителя используется '.', для '/file' — '/'. UTF-8, 0/-1.
+int file_io_sync_directory(const char *path);
+// Переместить отдельный готовый файл с durable заменой destination; caller владеет source. 0/-1.
+// Ошибка после rename не откатывает замену; сохраняется каталог назначения. Файлы/каталоги не подменяются извне.
+int file_io_publish(const char *source, const char *destination);
+// Создать эксклюзивный temp рядом с destination; структура заранее обнулена, даже после ошибки вызвать discard.
+// flags=0 — flush/close и atomic rename; FILE_IO_DURABLE — также sync файла и каталога назначения.
+int file_io_temp_open(struct file_io_temp *output, const char *destination, unsigned flags);
+// Проверить flush/[sync]/close, обнулить file при любом результате; temp остаётся собственностью output.
+int file_io_temp_finish(struct file_io_temp *output);
+// Закрыть/удалить собственный temp; повторный вызов допустим. Ошибки очистки логируются.
+void file_io_temp_discard(struct file_io_temp *output);
+// Повторно проверить paths и заменить destination закрытым соседним temp; одинаковые файлы отклоняются. 0/-1.
+// При ошибке до rename temporary сохраняется; после rename он пуст, в том числе при отказе directory sync.
+int file_io_temp_publish(struct file_io_temp *output, const char *source, const char *destination);
+/* Удалить уже признанный сиротой файл, атомарно проверив владение file_io_temp во всех потоках.
+ * 1 — удалён, 0 — активный temp или уже отсутствует, -1 — ошибка (логируется).
+ * path должен иметь то же нормализованное написание, что и путь при temp_open; рабочий каталог не меняется. */
+int file_io_remove_orphan(const char *path);
+#endif

lib/getmyip.c

@@ -23,24 +23,24 @@ int get_outgoing_local_ip(const struct sockaddr_storage *local_addr,
                           struct sockaddr_storage *result)
 {
     if (!local_addr || !remote_addr || !result) {
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: NULL argument");
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: NULL argument");
         return -1;
     }
 
     int family = local_addr->ss_family;
     if (family != AF_INET && family != AF_INET6) {
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: unsupported family %d", family);
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: unsupported family %d", family);
         return -1;
     }
 
     if (remote_addr->ss_family != family) {
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: family mismatch");
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: family mismatch");
         return -1;
     }
 
     socket_t sock = socket_create_udp(family);
     if (sock == SOCKET_INVALID) {
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: socket_create_udp failed");
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: socket_create_udp failed");
         return -1;
     }
 
@@ -56,7 +56,7 @@ int get_outgoing_local_ip(const struct sockaddr_storage *local_addr,
     socklen_t bind_len = (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
     if (bind(sock, (struct sockaddr *)&bind_addr, bind_len) != 0) {
         int err = socket_get_error();
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: bind failed: %s", socket_strerror(err));
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: bind failed: %s", socket_strerror(err));
         socket_close_wrapper(sock);
         return -1;
     }
@@ -65,7 +65,7 @@ int get_outgoing_local_ip(const struct sockaddr_storage *local_addr,
     socklen_t remote_len = (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
     if (connect(sock, (struct sockaddr *)remote_addr, remote_len) != 0) {
         int err = socket_get_error();
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: connect failed: %s", socket_strerror(err));
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: connect failed: %s", socket_strerror(err));
         socket_close_wrapper(sock);
         return -1;
     }
@@ -75,7 +75,7 @@ int get_outgoing_local_ip(const struct sockaddr_storage *local_addr,
     socklen_t local_len = sizeof(local);
     if (getsockname(sock, (struct sockaddr *)&local, &local_len) != 0) {
         int err = socket_get_error();
-        DEBUG_ERROR(DEBUG_CATEGORY_CONNECTION, "get_outgoing_local_ip: getsockname failed: %s", socket_strerror(err));
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "get_outgoing_local_ip: getsockname failed: %s", socket_strerror(err));
         socket_close_wrapper(sock);
         return -1;
     }

lib/getmyip.h

@@ -3,6 +3,8 @@
  *
  * Определяет локальный IP, который ОС выберет для отправки
  * на заданный удаленный адрес через заданный локальный адрес.
+ * Передать local/remote одного семейства AF_INET или AF_INET6 и буфер result.
+ * Создаёт и закрывает временный UDP-сокет; предназначен для выбора маршрута, не для обработки каждого пакета.
  */
 
 #ifndef GETMYIP_H
@@ -26,13 +28,13 @@ extern "C" {
  * Определяет локальный IP-адрес, который ОС выберет для отправки
  * на заданный удаленный адрес через заданный локальный адрес.
  *
- * Создает временный UDP-сокет, выполняет bind на local_addr,
+ * Создает временный UDP-сокет, выполняет bind на копию local_addr с портом 0,
  * connect к remote_addr и получает выбранный локальный IP через getsockname.
  *
- * @param local_addr  Локальный адрес (0.0.0.0 / :: для автоопределения)
- * @param remote_addr Удаленный адрес (для определения маршрута)
+ * @param local_addr  Локальный адрес (0.0.0.0 / :: для автоопределения); входной порт игнорируется
+ * @param remote_addr Удаленный адрес того же семейства (для определения маршрута)
  * @param result      Заполняемый локальный IP (порт = 0)
- * @return 0 при успехе, -1 при ошибке
+ * @return 0 при успехе, -1 при NULL, неподдерживаемом/разном семействе или ошибке socket/bind/connect/getsockname
  */
 int get_outgoing_local_ip(const struct sockaddr_storage *local_addr,
                           const struct sockaddr_storage *remote_addr,

lib/getmyip_doc.md

@@ -1,34 +0,0 @@
-# Get My IP (getmyip.h)
-
-## 1. Назначение
-Определение локального IP-адреса, который ОС выберет для исходящего UDP-соединения на заданный удалённый хост. Используется в `etcp_connections.c` при установке соединения: зная remote-адрес, модуль узнаёт, какой source IP ядро назначит пакетам (нужно для проверки NAT и привязки сокета к правильному интерфейсу).
-
-## 2. Как пользоваться
-Передать локальный адрес-подсказку (или `0.0.0.0` для автоопределения) и удалённый адрес. Функция создаст временный UDP-сокет, сделает bind+connect, считает выбранный IP через `getsockname` и вернёт его в `result` (порт = 0, только IP).
-
-```c
-struct sockaddr_storage local_hint;  // AF_INET6, sin6_addr = in6addr_any
-struct sockaddr_storage remote;      // AF_INET6, адрес сервера
-struct sockaddr_storage chosen_ip;
-
-// ... заполнить local_hint и remote ...
-
-if (get_outgoing_local_ip(&local_hint, &remote, &chosen_ip) == 0) {
-    // chosen_ip.ss_family == AF_INET6, sin6_addr содержит выбранный source IP
-    // chosen_ip.sin6_port == 0
-}
-```
-
-**Нюансы:**
-- Функция временно создаёт и закрывает UDP-сокет — нельзя вызывать в hot path
-- `local_addr` и `remote_addr` должны быть одного семейства (оба AF_INET или оба AF_INET6)
-- Порт в `local_addr` заменяется на 0 (чтобы не конфликтовать с основными сокетами)
-- Порт в `result` всегда 0 — только IP
-
-## 3. API
-
-### Функция
-- **`get_outgoing_local_ip(local_addr, remote_addr, result)`** — создаёт временный UDP-сокет, привязывает к `local_addr` (с портом 0), делает `connect` к `remote_addr` для вычисления маршрута ядром, получает выбранный source IP через `getsockname`. Возвращает 0 при успехе, -1 при ошибке (NULL-аргументы, несовпадение семейств, ошибки сокета).
-
-### Зависимости
-- `socket_compat.h` — кроссплатформенные обёртки: `socket_create_udp`, `SOCKET_INVALID`, `socket_close_wrapper`, `socket_get_error`, `socket_strerror`

lib/json_flat.c

@@ -1,4 +1,6 @@
 #include "json_flat.h"
+#include "mem.h"
+#include "debug_config.h"
 #include <string.h>
 
 #define SKIP_WS(p, end) while ((p) < (end) && (*(p) == ' ' || *(p) == '\t' || *(p) == '\n' || *(p) == '\r')) (p)++
@@ -19,6 +21,8 @@ static int json_read_string(const char** pp, const char* end, char* out, size_t
                 case 'n': ch = '\n'; break;
                 case 'r': ch = '\r'; break;
                 case 't': ch = '\t'; break;
+                case 'b': ch = '\b'; break;
+                case 'f': ch = '\f'; break;
                 default: return -1;
             }
         }
@@ -33,20 +37,22 @@ static int json_read_string(const char** pp, const char* end, char* out, size_t
     return 0;
 }
 
-static int json_parse_pair(const char** pp, const char* end,
+static int json_parse_pair(const char** pp, const char* end, char* scratch, size_t capacity,
                             json_flat_cb cb, void* arg) {
     const char* p = *pp;
     SKIP_WS(p, end); CHECK(p, end);
     if (*p == '}') { *pp = p; return 0; }
 
-    char key[128], val[256];
-    if (json_read_string(&p, end, key, sizeof(key)) != 0) return -1;
+    char* key = scratch;
+    if (json_read_string(&p, end, key, capacity) != 0) return -1;
+    size_t key_size = strlen(key) + 1;
+    char* val = scratch + key_size;
     SKIP_WS(p, end); CHECK(p, end);
     if (*p != ':') return -1; p++;
     SKIP_WS(p, end); CHECK(p, end);
-    if (json_read_string(&p, end, val, sizeof(val)) != 0) return -1;
+    if (json_read_string(&p, end, val, capacity - key_size) != 0) return -1;
 
-    if (cb && cb(key, val, arg) != 0) { *pp = p; return 1; }
+    if (cb) { int rc = cb(key, val, arg); if (rc != 0) { *pp = p; return rc < 0 ? -1 : 1; } }
 
     SKIP_WS(p, end); CHECK(p, end);
     if (*p == ',') p++;
@@ -61,13 +67,23 @@ int json_flat_parse(const char* json, json_flat_cb cb, void* arg) {
     SKIP_WS(p, end); CHECK(p, end);
     if (*p != '{') return -1; p++;
 
+    /* Decoded key + value + two NULs fit within the encoded object size. */
+    size_t capacity = strlen(json) + 1;
+    if (capacity > UINT32_MAX) { DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "json_flat: input too large"); return -1; }
+    char local[384];
+    char* scratch = capacity <= sizeof(local) ? local : u_malloc(capacity);
+    if (!scratch) { DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "json_flat: allocation failed bytes=%zu", capacity); return -1; }
+    int result = 0;
     for (;;) {
-        int rc = json_parse_pair(&p, end, cb, arg);
-        if (rc < 0) return -1;
-        if (rc > 0) return 0; /* callback stopped */
-        SKIP_WS(p, end); CHECK(p, end);
-        if (*p == '}') return 0;
+        int rc = json_parse_pair(&p, end, scratch, capacity, cb, arg);
+        if (rc < 0) { result = -1; break; }
+        if (rc > 0) break;
+        SKIP_WS(p, end);
+        if (p >= end) { result = -1; break; }
+        if (*p == '}') break;
     }
+    if (scratch != local) u_free(scratch);
+    return result;
 }
 
 struct get_ctx { const char* key; char* out; size_t sz; int found; };
@@ -81,6 +97,7 @@ static int get_cb(const char* k, const char* v, void* arg) {
 }
 
 int json_flat_get(const char* json, const char* key, char* value_out, size_t value_sz) {
+    if (!key || (value_out && !value_sz)) return -1;
     struct get_ctx g = { key, value_out, value_sz, 0 };
     if (json_flat_parse(json, get_cb, &g) != 0) return -1;
     return g.found ? 0 : -1;

lib/json_flat.h

@@ -2,7 +2,12 @@
  * @file json_flat.h
  * @brief Парсер плоского JSON без вложенности: {"key":"value",...}
  *
- * Только строковые значения. Без malloc, без зависимостей.
+ * Только строковые значения и обычные escapes; \uXXXX не поддерживается.
+ * Callback получает полные key/value, действительные только до его возврата.
+ * parse возвращает 0 при успехе/остановке callback, -1 при ошибке; остановка не проверяет остаток ввода.
+ * Синтаксис проверяется нестрого: допускаются пропущенные и завершающие запятые;
+ * хвост после закрывающей } игнорируется даже без остановки callback.
+ * get ищет первый ключ и копирует значение с NUL, при малом буфере обрезает; 0 найден, -1 ошибка/нет ключа.
  */
 
 #ifndef JSON_FLAT_H
@@ -15,6 +20,7 @@ extern "C" {
 #endif
 
 typedef int (*json_flat_cb)(const char* key, const char* value, void* arg);
+/* Callback: 0 = continue, >0 = stop successfully, <0 = error. */
 
 int json_flat_parse(const char* json, json_flat_cb cb, void* arg);
 int json_flat_get(const char* json, const char* key, char* value_out, size_t value_sz);

lib/libopus/COPYING

@@ -0,0 +1,44 @@
+Copyright 2001-2023 Xiph.Org, Skype Limited, Octasic,
+                    Jean-Marc Valin, Timothy B. Terriberry,
+                    CSIRO, Gregory Maxwell, Mark Borgerding,
+                    Erik de Castro Lopo, Mozilla, Amazon
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor the
+names of specific contributors, may be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Opus is subject to the royalty-free patent licenses which are
+specified at:
+
+Xiph.Org Foundation:
+https://datatracker.ietf.org/ipr/1524/
+
+Microsoft Corporation:
+https://datatracker.ietf.org/ipr/1914/
+
+Broadcom Corporation:
+https://datatracker.ietf.org/ipr/1526/

lib/libopus/Makefile.am

@@ -1,5 +1,7 @@
 noinst_LIBRARIES = libopus_internal.a
 
+EXTRA_DIST = COPYING
+
 # Override global CFLAGS to disable ASAN (makes .a incompatible with PIE linking)
 CFLAGS = -g -Og -fno-omit-frame-pointer -fno-pie -fPIC
 

lib/ll_queue.c

@@ -52,15 +52,23 @@ static void on_get_trampoline(void* arg);
 static void empty_trampoline(void* arg) {
     struct ll_queue* q = (struct ll_queue*)arg;
     q->empty_call_soon_id = NULL;
+    if (q->count != 0) return;
     queue_callback_fn cb = q->empty_callback;
     void* cb_arg = q->empty_callback_arg;
     q->empty_callback = NULL;
     q->empty_callback_arg = NULL;
-    if (q->count == 0 && cb) cb(q, cb_arg);
+    if (cb) cb(q, cb_arg);
 }
 
 static void on_get_trampoline(void* arg) {
     struct ll_queue* q = (struct ll_queue*)arg;
+    q->on_get_call_soon_id = NULL;
+    if (!q->on_get_pending || !q->on_get) return;
+    q->on_get_pending--;
+    if (q->on_get_pending) {
+        q->on_get_call_soon_id = uasync_call_soon(q->ua, q, on_get_trampoline);
+        if (!q->on_get_call_soon_id) DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] on_get scheduling failed: pending=%zu", q->name, q->on_get_pending);
+    }
     if (q->on_get) q->on_get(q, q->on_get_arg);
 }
 
@@ -121,15 +129,8 @@ struct ll_entry* ll_alloc_lldgram(uint16_t len) {
     return entry;
 }
 
-void queue_free(struct ll_queue* q) {
-    if (!q) return;
-    
-    DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "queue_free: freeing queue %p, head=%p, tail=%p, count=%d", 
-                q, q->head, q->tail, q->count);
-    
-    // ВАЖНО: Не освобождаем элементы в очереди - они должны быть извлечены отдельно
-    // Это упрощает архитектуру и предотвращает double-u_free
-    
+static void queue_cancel_notifications(struct ll_queue* q) {
+    while (q->deferred_waiters) queue_waiter_cancel(q, q->deferred_waiters);
     // Освободить список waiters (сбросить handle->internal, отменить отложенные вызовы)
     struct queue_waiter* w = q->waiter_head;
     while (w) {
@@ -141,11 +142,6 @@ void queue_free(struct ll_queue* q) {
     q->waiter_head = NULL;
     q->waiter_tail = NULL;
     
-    // Освободить хеш-таблицу
-    if (q->hash_table) {
-        u_free(q->hash_table);
-    }
-    
     // Отменить отложенное возобновление
     if (q->resume_timeout_id) {
         uasync_call_soon_cancel(q->ua, q->resume_timeout_id);
@@ -159,6 +155,35 @@ void queue_free(struct ll_queue* q) {
     q->empty_callback_arg = NULL;
     q->on_get = NULL;
     q->on_get_arg = NULL;
+    if (q->on_get_call_soon_id) uasync_call_soon_cancel(q->ua, q->on_get_call_soon_id);
+    q->on_get_call_soon_id = NULL; q->on_get_pending = 0;
+    q->callback_suspended = 1;
+}
+
+void queue_clear(struct ll_queue* q) {
+    if (!q) return;
+#ifdef QUEUE_THREAD_CHECK
+    queue_check_thread(q);
+#endif
+    DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "[%s] discard queue: packets=%d bytes=%zu", q->name, q->count, q->total_bytes);
+    queue_cancel_notifications(q);
+    struct ll_entry* entry = q->head;
+    q->head = q->tail = NULL; q->count = 0; q->total_bytes = 0;
+    if (q->hash_table) memset(q->hash_table, 0, q->hash_size * sizeof(*q->hash_table));
+    while (entry) {
+        struct ll_entry* next = entry->next;
+        entry->owner = NULL; entry->next = entry->prev = entry->hash_next = NULL;
+        queue_dgram_free(entry); queue_entry_free(entry); entry = next;
+    }
+}
+
+void queue_free(struct ll_queue* q) {
+    if (!q) return;
+    DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "queue_free: freeing queue %p, head=%p, count=%d", (void*)q, (void*)q->head, q->count);
+    queue_cancel_notifications(q);
+    if (q->hash_table) u_free(q->hash_table);
+    if (q->head) DEBUG_WARN(DEBUG_CATEGORY_SYS, "[%s] freeing nonempty queue: count=%d; entries remain caller-owned", q->name, q->count);
+    for (struct ll_entry* e = q->head; e; e = e->next) e->owner = NULL;
     
     u_free(q);
 }
@@ -194,6 +219,19 @@ void queue_resume_callback(struct ll_queue* q) {
     }
 }
 
+// Общий запуск коллбэка автозабора: immediate (default) или deferred через uasync_call_soon.
+// Deferred-режим очищает стек производителя перед обработкой первого элемента.
+static void queue_trigger_callback(struct ll_queue* q) {
+    if (!q->head || q->callback_suspended || !q->callback) return;
+
+    if (q->callback_defer) {
+        if (!q->resume_timeout_id)
+            q->resume_timeout_id = uasync_call_soon(q->ua, q, queue_resume_timeout_cb);
+    } else {
+        q->callback(q, q->callback_arg);
+    }
+}
+
 void queue_set_size_limit(struct ll_queue* q, int lim) {
     if (!q) return;
     q->size_limit = lim;
@@ -303,22 +341,42 @@ static uint32_t make_hash(const void* data, uint16_t len) {// алгоритм F
     return hash;
 }
 
-static void waiter_defer_cb(void* arg) {
-    struct queue_waiter_handle* h = (struct queue_waiter_handle*)arg;
-    h->call_soon_id = NULL;
-    if (h->defer_cb) h->defer_cb(h->defer_q, h->defer_arg);
-    else DEBUG_ERROR(DEBUG_CATEGORY_SYS, "waiter_defer_cb: NULL callback (stale?) q=%p", (void*)h->defer_q);
+static void unlink_deferred_waiter(struct ll_queue* q, struct queue_waiter_handle* h) {
+    struct queue_waiter_handle** p = &q->deferred_waiters;
+    while (*p && *p != h) p = &(*p)->defer_next;
+    if (*p) *p = h->defer_next;
+    else DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] deferred waiter not found: handle=%p", q->name, h);
+    h->defer_next = NULL; h->defer_q = NULL;
 }
 
-static inline void queue_waiter_call(struct ll_queue* q, queue_threshold_callback_fn cb, void* arg,
+static void waiter_defer_cb(void* arg) {
+    struct queue_waiter_handle* h = (struct queue_waiter_handle*)arg;
+    struct ll_queue* q = h->defer_q;
+    queue_threshold_callback_fn cb = h->defer_cb;
+    void* cb_arg = h->defer_arg;
+    h->call_soon_id = NULL;
+    unlink_deferred_waiter(q, h);
+    h->defer_cb = NULL; h->defer_arg = NULL;
+    if (cb) cb(q, cb_arg);
+    else DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] deferred waiter has no callback", q->name);
+}
+
+static inline int queue_waiter_call(struct ll_queue* q, queue_threshold_callback_fn cb, void* arg,
                                struct queue_waiter_handle* h) {
     if (q->waiter_defer) {
-        if (h->call_soon_id) { DEBUG_WARN(DEBUG_CATEGORY_SYS, "queue_waiter_call: overwriting existing call_soon_id=%p", h->call_soon_id); uasync_call_soon_cancel(q->ua, h->call_soon_id); }
+        if (h->call_soon_id) queue_waiter_cancel(h->defer_q, h);
         h->defer_q = q; h->defer_cb = cb; h->defer_arg = arg;
         h->call_soon_id = uasync_call_soon(q->ua, h, waiter_defer_cb);
+        if (h->call_soon_id) { h->defer_next = q->deferred_waiters; q->deferred_waiters = h; }
+        else {
+            DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] deferred waiter scheduling failed: handle=%p", q->name, h);
+            h->defer_q = NULL; h->defer_cb = NULL; h->defer_arg = NULL;
+            return -1;
+        }
     } else {
         cb(q, arg);
     }
+    return 0;
 }
 
 // Проверить и запустить первый ожидающий коллбэк (FIFO / round-robin)
@@ -338,13 +396,18 @@ static void check_waiters(struct ll_queue* q) {
 
     queue_threshold_callback_fn cb = waiter->callback;
     void* arg = waiter->callback_arg;
-    u_free(waiter);
-
     if (cb) {
         DEBUG_DEBUG(DEBUG_CATEGORY_SYS, "check_waiters: waking head waiter, count=%d<=%d, bytes=%zu<=%zu",
                     q->count, q->threshold_max_packets, q->total_bytes, q->threshold_max_bytes);
-        queue_waiter_call(q, cb, arg, h);
+        if (queue_waiter_call(q, cb, arg, h) < 0) {
+            // Отказ планирования не теряет ожидание: следующий get/remove повторит попытку.
+            waiter->next = q->waiter_head; q->waiter_head = waiter;
+            if (!q->waiter_tail) q->waiter_tail = waiter;
+            h->internal = waiter;
+            return;
+        }
     }
+    u_free(waiter);
 }
 
 int queue_data_put(struct ll_queue* q, struct ll_entry* entry) {
@@ -353,7 +416,7 @@ int queue_data_put(struct ll_queue* q, struct ll_entry* entry) {
     queue_check_thread(q);
 #endif
 
-    if (entry->prev || entry->next || q->head == entry || q->tail == entry) {
+    if (entry->owner || entry->prev || entry->next || q->head == entry || q->tail == entry) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] double put detected! entry=%p prev=%p next=%p len=%u",
                     q->name, (void*)entry, (void*)entry->prev, (void*)entry->next, entry->len);
         abort();
@@ -367,6 +430,7 @@ int queue_data_put(struct ll_queue* q, struct ll_entry* entry) {
     }
 
     if (q->size_limit >= 0 && q->count >= q->size_limit) {
+        DEBUG_WARN(DEBUG_CATEGORY_SYS, "[%s] queue full: count=%d limit=%d", q->name, q->count, q->size_limit);
         queue_dgram_free(entry);
         queue_entry_free(entry);
         return -1;
@@ -378,19 +442,18 @@ int queue_data_put(struct ll_queue* q, struct ll_entry* entry) {
     if (q->tail) q->tail->next = entry; else q->head = entry;
     q->tail = entry;
 
+    entry->owner = q;
     q->count++;
     entry->int_len = entry->len;
     q->total_bytes += entry->int_len;
 
     // НЕ вызываем add_to_hash
 
-    if (q->count == 1 && !q->callback_suspended && q->callback) {
-        q->callback(q, q->callback_arg);
-    }
-
 #ifdef QUEUE_DEBUG
     queue_check_consistency(q);
 #endif
+    // Пользовательский callback может освободить очередь.
+    if (q->count == 1) queue_trigger_callback(q);
     return 0;
 }
 
@@ -400,7 +463,7 @@ int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry) {
     queue_check_thread(q);
 #endif
 
-    if (entry->prev || entry->next || q->head == entry || q->tail == entry) {
+    if (entry->owner || entry->prev || entry->next || q->head == entry || q->tail == entry) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] double put_with_index detected! entry=%p prev=%p next=%p",
                     q->name, (void*)entry, (void*)entry->prev, (void*)entry->next);
         abort();
@@ -416,6 +479,7 @@ int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry) {
     entry->index_hash = make_hash(entry->data + q->index_offset, q->index_size);
 
     if (q->size_limit >= 0 && q->count >= q->size_limit) {
+        DEBUG_WARN(DEBUG_CATEGORY_SYS, "[%s] queue full: count=%d limit=%d", q->name, q->count, q->size_limit);
         queue_dgram_free(entry);
         queue_entry_free(entry);
         return -1;
@@ -427,19 +491,18 @@ int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry) {
     if (q->tail) q->tail->next = entry; else q->head = entry;
     q->tail = entry;
 
+    entry->owner = q;
     q->count++;
     entry->int_len = entry->len;
     q->total_bytes += entry->int_len;
 
     add_to_hash(q, entry);
 
-    if (q->count == 1 && !q->callback_suspended && q->callback) {
-        q->callback(q, q->callback_arg);
-    }
-
 #ifdef QUEUE_DEBUG
     queue_check_consistency(q);
 #endif
+    // Пользовательский callback может освободить очередь.
+    if (q->count == 1) queue_trigger_callback(q);
     return 0;
 }
 
@@ -449,7 +512,7 @@ int queue_data_put_first(struct ll_queue* q, struct ll_entry* entry) {
     queue_check_thread(q);
 #endif
 
-    if (entry->prev || entry->next || q->head == entry || q->tail == entry) {
+    if (entry->owner || entry->prev || entry->next || q->head == entry || q->tail == entry) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] double put_first detected! entry=%p prev=%p next=%p",
                     q->name, (void*)entry, (void*)entry->prev, (void*)entry->next);
         abort();
@@ -462,22 +525,25 @@ int queue_data_put_first(struct ll_queue* q, struct ll_entry* entry) {
         return -1;
     }
 
+    if (q->size_limit >= 0 && q->count >= q->size_limit) {
+        DEBUG_WARN(DEBUG_CATEGORY_SYS, "[%s] queue full: count=%d limit=%d", q->name, q->count, q->size_limit);
+        queue_dgram_free(entry); queue_entry_free(entry); return -1;
+    }
     entry->next = q->head;
     entry->prev = NULL;
     if (q->head) q->head->prev = entry; else q->tail = entry;
     q->head = entry;
 
+    entry->owner = q;
     q->count++;
     entry->int_len = entry->len;
     q->total_bytes += entry->int_len;
 
-    if (q->count == 1 && !q->callback_suspended && q->callback) {
-        q->callback(q, q->callback_arg);
-    }
-
 #ifdef QUEUE_DEBUG
     queue_check_consistency(q);
 #endif
+    // Пользовательский callback может освободить очередь.
+    if (q->count == 1) queue_trigger_callback(q);
     return 0;
 }
 
@@ -488,7 +554,7 @@ int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry)
     queue_check_thread(q);
 #endif
 
-    if (entry->prev || entry->next || q->head == entry || q->tail == entry) {
+    if (entry->owner || entry->prev || entry->next || q->head == entry || q->tail == entry) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] double put_first_with_index detected! entry=%p prev=%p next=%p",
                     q->name, (void*)entry, (void*)entry->prev, (void*)entry->next);
         abort();
@@ -504,6 +570,7 @@ int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry)
     entry->index_hash = make_hash(entry->data + q->index_offset, q->index_size);
 
     if (q->size_limit >= 0 && q->count >= q->size_limit) {
+        DEBUG_WARN(DEBUG_CATEGORY_SYS, "[%s] queue full: count=%d limit=%d", q->name, q->count, q->size_limit);
         queue_dgram_free(entry);
         queue_entry_free(entry);
         return -1;
@@ -514,19 +581,18 @@ int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry)
     if (q->head) q->head->prev = entry; else q->tail = entry;
     q->head = entry;
 
+    entry->owner = q;
     q->count++;
     entry->int_len = entry->len;
     q->total_bytes += entry->int_len;
 
     add_to_hash(q, entry);
 
-    if (q->count == 1 && !q->callback_suspended && q->callback) {
-        q->callback(q, q->callback_arg);
-    }
-
 #ifdef QUEUE_DEBUG
     queue_check_consistency(q);
 #endif
+    // Пользовательский callback может освободить очередь.
+    if (q->count == 1) queue_trigger_callback(q);
     return 0;
 }
 
@@ -549,6 +615,7 @@ struct ll_entry* queue_data_get(struct ll_queue* q) {
     
     entry->next = NULL;
     entry->prev = NULL;
+    entry->owner = NULL;
     
     remove_from_hash(q, entry);
     
@@ -557,18 +624,21 @@ struct ll_entry* queue_data_get(struct ll_queue* q) {
     // Приостановить коллбэки для предотвращения рекурсии
     q->callback_suspended = 1;
     
-    // Проверить ожидающие коллбэки
-    check_waiters(q);
-    
     if (q->count == 0 && q->empty_callback && !q->empty_call_soon_id)
         q->empty_call_soon_id = uasync_call_soon(q->ua, q, (timeout_callback_t)empty_trampoline);
     
-    if (q->on_get)
-        uasync_call_soon(q->ua, q, (timeout_callback_t)on_get_trampoline);
+    if (q->on_get) {
+        q->on_get_pending++;
+        if (!q->on_get_call_soon_id) {
+            q->on_get_call_soon_id = uasync_call_soon(q->ua, q, on_get_trampoline);
+            if (!q->on_get_call_soon_id) DEBUG_ERROR(DEBUG_CATEGORY_SYS, "[%s] on_get scheduling failed: pending=%zu", q->name, q->on_get_pending);
+        }
+    }
     
 #ifdef QUEUE_DEBUG
     queue_check_consistency(q);// !!!! for debug
 #endif
+    check_waiters(q);
     return entry;
 }
 
@@ -647,6 +717,11 @@ void queue_set_waiter_defer(struct ll_queue* q, int enable) {
     q->waiter_defer = enable;
 }
 
+void queue_set_callback_defer(struct ll_queue* q, int enable) {
+    if (!q) return;
+    q->callback_defer = enable;
+}
+
 void queue_set_empty_callback(struct ll_queue* q, queue_callback_fn cbk_fn, void* arg) {
     if (!q) return;
     void* old = q->empty_call_soon_id;
@@ -662,18 +737,24 @@ void queue_set_on_get(struct ll_queue* q, queue_callback_fn cbk_fn, void* arg) {
     if (!q) return;
     q->on_get = cbk_fn;
     q->on_get_arg = arg;
+    if (!cbk_fn) {
+        if (q->on_get_call_soon_id) uasync_call_soon_cancel(q->ua, q->on_get_call_soon_id);
+        q->on_get_call_soon_id = NULL; q->on_get_pending = 0;
+    }
 }
 
 int queue_waiter_wait(struct ll_queue* q, struct queue_waiter_handle* h,
                       queue_threshold_callback_fn callback, void* arg) {
-    if (!q || !h) return -1;
+    if (!q || !h || !callback) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "queue_waiter_wait: invalid arguments q=%p handle=%p callback=%p", q, h, (void*)callback);
+        return -1;
+    }
 
-    if (h->internal) queue_waiter_cancel(q, h);
+    if (h->internal || h->call_soon_id) queue_waiter_cancel(h->call_soon_id ? h->defer_q : q, h);
 
     if (q->count <= q->threshold_max_packets
         && (q->threshold_max_bytes == 0 || q->total_bytes <= q->threshold_max_bytes)) {
-        queue_waiter_call(q, callback, arg, h);
-        return 1;
+        return queue_waiter_call(q, callback, arg, h) < 0 ? -1 : 1;
     }
 
     struct queue_waiter* waiter = u_malloc(sizeof(struct queue_waiter));
@@ -694,9 +775,18 @@ int queue_waiter_wait(struct ll_queue* q, struct queue_waiter_handle* h,
 }
 
 void queue_waiter_cancel(struct ll_queue* q, struct queue_waiter_handle* h) {
-    if (!q || !h || !h->internal) return;
-    if (h->call_soon_id) { uasync_call_soon_cancel(q->ua, h->call_soon_id); h->call_soon_id = NULL; }
-    
+    if (!q || !h) return;
+    /* Отложенный вызов (waiter_defer) может висеть и при internal==NULL:
+     * queue_waiter_wait по ветке «очередь свободна» планирует call_soon_id,
+     * не регистрируя waiter. Ранний выход по !internal оставлял бы висячий
+     * callback с arg=handle, который после teardown разыменовывал бы freed-память. */
+    if (h->call_soon_id) {
+        struct ll_queue* deferred_q = h->defer_q;
+        uasync_call_soon_cancel(deferred_q->ua, h->call_soon_id); h->call_soon_id = NULL;
+        unlink_deferred_waiter(deferred_q, h); h->defer_cb = NULL; h->defer_arg = NULL;
+    }
+    if (!h->internal) return;
+
     struct queue_waiter* waiter = h->internal;
     struct queue_waiter* prev = NULL;
     struct queue_waiter* curr = q->waiter_head;
@@ -754,6 +844,10 @@ struct ll_entry* queue_find_next_by_index(struct ll_queue* q, const void* index_
 
 int queue_remove_data(struct ll_queue* q, struct ll_entry* entry) {
     if (!q || !entry) return -1;
+    if (entry->owner != q) {
+        DEBUG_WARN(DEBUG_CATEGORY_SYS, "[%s] cannot remove foreign entry=%p owner=%p", q->name, entry, entry->owner);
+        return -1;
+    }
     
 #ifdef QUEUE_THREAD_CHECK
     queue_check_thread(q);
@@ -777,6 +871,7 @@ int queue_remove_data(struct ll_queue* q, struct ll_entry* entry) {
     
     entry->next = NULL;
     entry->prev = NULL;
+    entry->owner = NULL;
     
     remove_from_hash(q, entry);
     
@@ -784,6 +879,8 @@ int queue_remove_data(struct ll_queue* q, struct ll_entry* entry) {
 #ifdef QUEUE_DEBUG
     queue_check_consistency(q);// !!!! for debug
 #endif    
+    if (q->count == 0 && q->empty_callback && !q->empty_call_soon_id)
+        q->empty_call_soon_id = uasync_call_soon(q->ua, q, empty_trampoline);
     check_waiters(q);
     return 0;
 }

lib/ll_queue.h

@@ -1,6 +1,10 @@
 #ifndef LL_QUEUE_H
 #define LL_QUEUE_H
 
+/* Очередь одного uasync-потока; наличие pthread-заголовков не делает её межпоточной.
+ * put может синхронно вызвать consumer/waiter. Держать владельцев живыми до завершения callbacks,
+ * waiter handle обнулять целиком и отменять до освобождения; entry и dgram освобождаются отдельно. */
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -37,8 +41,8 @@ extern "C" {
  * @note Важные правила использования автозабора (queue_set_callback):
  *       1. Коллбэк получает управление только если в очереди есть элементы И !callback_suspended
  *       2. Внутри коллбэка ОБЯЗАТЕЛЬНО: queue_data_get() → обработать элемент → queue_resume_callback()
- *       3. Без вызова queue_resume_callback очередь навсегда застрянет
- *       4. Не извлекайте элементы вручную вне коллбэка — это нарушит логику
+ *       3. Без queue_resume_callback автозабор остаётся приостановленным
+ *       4. Ручное извлечение допустимо; для продолжения автозабора после него тоже нужен resume
  *       5. queue_data_get() автоматически suspend'ит коллбэки для предотвращения рекурсии
  *
  * @note Память:
@@ -57,10 +61,11 @@ struct queue_waiter_handle;
  * @brief Элемент очереди (переменного размера).
  *
  * Память выделяется одним блоком: [struct ll_entry + data[size]].
- * Поле dgram — отдельный блок (malloc / пул / внешняя память).
+ * Поле dgram — отдельный блок (u_malloc / пул / внешняя память со своим dgram_free_fn).
  */
 struct ll_entry {
     char* name;
+    struct ll_queue* owner;               // Владелец элемента; NULL после извлечения
     struct ll_entry* next;                // Следующий элемент в очереди
     struct ll_entry* prev;                // Предыдущий элемент в очереди
     uint16_t size;                        // Размер пользовательского буфера data[] (байт)
@@ -70,9 +75,9 @@ struct ll_entry {
     uint8_t* dgram;                       // Указатель на данные пакета
     void (*dgram_free_fn)(uint8_t* data); // Кастомная функция освобождения dgram
     struct memory_pool* dgram_pool;       // Пул для dgram (если используется)
-    uint32_t index_hash;                  // Хеш по первым 4 байтам индекса
+    uint32_t index_hash;                  // FNV-1a (32 бита) по всем index_size байтам data[] от index_offset
     struct ll_entry* hash_next;           // Следующий в хеш-цепочке
-    struct memory_pool* pool;             // Пул, из которого выделен сам entry (NULL = malloc)
+    struct memory_pool* pool;             // Пул, из которого выделен сам entry (NULL = u_malloc)
     uint8_t data[0];                      // Гибкий массив пользовательских данных (размер = size)
 };
 
@@ -123,6 +128,7 @@ struct queue_waiter_handle {
     queue_threshold_callback_fn defer_cb;
     void*                defer_arg;
     void*                call_soon_id;       ///< хендл отложенного вызова (для отмены)
+    struct queue_waiter_handle* defer_next;   ///< список отложенных уведомлений очереди
 };
 
 /**
@@ -146,9 +152,11 @@ struct ll_queue {
 
     struct queue_waiter* waiter_head; // Голова списка ожидающих
     struct queue_waiter* waiter_tail; // Хвост списка ожидающих
+    struct queue_waiter_handle* deferred_waiters; // Уже запланированные уведомления
     int threshold_max_packets;        // Общий порог: макс. кол-во элементов (по умолчанию 0)
     size_t threshold_max_bytes;       // Общий порог: макс. объём данных (0 = не проверять)
     int waiter_defer;                 // 0=immediate callback, 1=defer via uasync_call_soon
+    int callback_defer;               // 0=immediate callback из put (default), 1=defer via uasync_call_soon (очистка стека)
 
     queue_callback_fn empty_callback;     // одноразовый коллбэк при опустошении очереди
     void*             empty_callback_arg;
@@ -156,6 +164,8 @@ struct ll_queue {
 
     queue_callback_fn on_get;             // коллбэк после каждого queue_data_get (deferred)
     void*             on_get_arg;
+    void*             on_get_call_soon_id;
+    size_t            on_get_pending;
 
     struct ll_entry** hash_table;   // Хеш-таблица для поиска по id (если hash_size > 0)
     size_t hash_size;               // Размер хеш-таблицы
@@ -171,7 +181,7 @@ struct ll_queue {
 #endif
 };
 
-/* ==================== Создание / уничтожение ==================== */
+// ==================== Создание / уничтожение ====================
 
 /**
  * @brief Создаёт новую пустую очередь.
@@ -179,8 +189,8 @@ struct ll_queue {
  * @param hash_size размер хеш-таблицы (0 = поиск по id отключён)
  * @param index_offset смещение ключа индекса в data[] каждого entry (0 если hash_size=0)
  * @param index_size размер ключа индекса (0 если hash_size=0)
- * @param name имя очереди для отладки
- * @return указатель на очередь или NULL при ошибке выделения памяти
+ * @param name заимствованное имя для отладки, должно жить до queue_free
+ * @return указатель на очередь или NULL при NULL ua / ошибке выделения памяти
  */
 struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, uint16_t index_offset, uint16_t index_size, char* name);
 
@@ -190,42 +200,55 @@ struct ll_queue* queue_new(struct UASYNC* ua, size_t hash_size, uint16_t index_o
  *
  * @warning НЕ ОСВОБОЖДАЕТ элементы в очереди!
  *          Их нужно извлечь через queue_data_get() и освободить через queue_entry_free().
+ * Перед дренажем снять callback и отменить ожидания владельцев, затем для каждого entry освободить dgram и entry.
+ * queue_free отменяет свои отложенные уведомления и waiters; user_arg не освобождает. NULL допустим.
  */
 void queue_free(struct ll_queue* q);
 
-/* ==================== Конфигурация ==================== */
+/* Аварийный сброс: освободить все entry/dgram, отменить waiters и отложенные уведомления без их вызова.
+ * Не выделяет память (кроме действий пользовательского dgram_free_fn). Очередь/индекс/обычный callback/пороги сохраняются.
+ * empty/on_get обработчики снимаются, callback приостановлен; владельцы заново ставят ожидания после восстановления.
+ * Вызывать в потоке ua; NULL допустим. Для продолжения автозабора нужен queue_resume_callback(). */
+void queue_clear(struct ll_queue* q);
+
+// ==================== Конфигурация ====================
 
 /**
  * @brief Устанавливает максимальное количество элементов в очереди.
  * @param q очередь
- * @param lim лимит (-1 = без ограничения)
+ * @param lim лимит (любое отрицательное значение = без ограничения)
  *
  * При превышении лимита новые элементы автоматически освобождаются.
  */
 void queue_set_size_limit(struct ll_queue* q, int lim);
 
-/* ==================== Автозабор элементов ==================== */
+// ==================== Автозабор элементов ====================
 
 /**
  * @brief Устанавливает коллбэк для автоматического извлечения элементов.
  * @param q очередь
- * @param cbk_fn функция-коллбэк
+ * @param cbk_fn функция-коллбэк (NULL отключает автозабор)
  * @param arg пользовательский аргумент
  *
- * Коллбэк вызывается автоматически при наличии элементов и разрешённом состоянии.
+ * Только заменяет функцию и аргумент: не запускает обработку, не снимает callback_suspended
+ * и не отменяет уже запланированный resume. Отложенный resume использует новые функцию и аргумент.
+ * Для запуска автозабора из уже заполненной очереди вызовите queue_resume_callback().
  */
 void queue_set_callback(struct ll_queue* q, queue_callback_fn cbk_fn, void* arg);
 
 /**
- * @brief Возобновляет работу коллбэка после обработки элемента в следующем event loop.
+ * @brief Разрешает автозабор и планирует отложенный вызов коллбэка.
  * @param q очередь
  *
- * @warning ОБЯЗАТЕЛЬНО вызывать после завершения обработки элемента в коллбэке.
- *          Иначе автозабор элементов навсегда остановится.
+ * Сразу снимает callback_suspended. Если есть элементы и callback, планирует uasync_call_soon,
+ * если resume ещё не запланирован. При исполнении повторно проверяет наличие элементов,
+ * callback и отсутствие приостановки. Последующий put в пустую очередь может вызвать callback
+ * синхронно, если callback_defer == 0.
+ * @note Вызывать после завершения обработки извлечённого элемента для продолжения автозабора.
  */
 void queue_resume_callback(struct ll_queue* q);
 
-/* ==================== Пороговое ожидание (backpressure) ==================== */
+// ==================== Пороговое ожидание (backpressure) ====================
 
 /**
  * @brief Устанавливает общий порог освобождения очереди.
@@ -234,87 +257,128 @@ void queue_resume_callback(struct ll_queue* q);
  * @param max_bytes максимальный объём данных (0 = не проверять)
  *
  * Порог — общий на всю очередь. Все waiters в связном списке используют этот порог.
- * При достижении порога вызывается следующий waiter из списка (FIFO / round-robin).
+ * После успешного get/remove при выполнении порога вызывается один следующий waiter из FIFO-списка.
+ * Сам setter старые ожидания не проверяет. Байт-порог использует int_len, зафиксированный при put.
  * По умолчанию: max_packets=0, max_bytes=0 (пустая очередь).
  */
 void queue_set_threshold(struct ll_queue* q, int max_packets, size_t max_bytes);
 
+// enable=0 — синхронный waiter (по умолчанию), !=0 — через uasync_call_soon.
+// Deferred-уведомление не резервирует место и повторно порог не проверяет: очередь к исполнению может заполниться.
+// Повторную регистрацию producer из его callback при свободной очереди откладывать, чтобы избежать рекурсии.
 void queue_set_waiter_defer(struct ll_queue* q, int enable);
 
+/**
+ * @brief Управляет способом вызова коллбэка автозабора при добавлении элемента.
+ * @param q очередь
+ * @param enable 0 — первый запуск коллбэка из queue_data_put* вызывается синхронно (по умолчанию);
+ *               1 — первый запуск откладывается через uasync_call_soon (очищает стек вызывающего).
+ *
+ * @note Влияет только на первый запуск из put. Повторные запуски (queue_resume_callback)
+ *       всегда идут через uasync_call_soon.
+ */
+void queue_set_callback_defer(struct ll_queue* q, int enable);
+
 /**
  * @brief Устанавливает одноразовый коллбэк при опустошении очереди (count==0).
  * @param q очередь
  * @param cbk_fn коллбэк (NULL для отмены)
  * @param arg пользовательский аргумент
  *
- * Коллбэк вызывается асинхронно (через uasync_call_soon) когда count становится 0.
- * После вызова сбрасывается — для повторного использования нужно вызвать снова.
+ * Заменяет регистрацию и отменяет её прежний отложенный вызов. При count == 0 сразу планирует
+ * uasync_call_soon; иначе вызов планируется при опустошении через queue_data_get/queue_remove_data.
+ * При исполнении снова проверяет count: если очередь заполнилась, регистрация сохраняется
+ * до следующего опустошения. Функция и аргумент сбрасываются ДО вызова callback,
+ * поэтому внутри него можно зарегистрировать новое уведомление.
  */
 void queue_set_empty_callback(struct ll_queue* q, queue_callback_fn cbk_fn, void* arg);
 
 /**
- * @brief Устанавливает коллбэк вызываемый после каждого queue_data_get (deferred через call_soon).
+ * @brief Устанавливает коллбэк после каждого успешного queue_data_get (deferred через call_soon).
  * @param q очередь
  * @param cbk_fn коллбэк (NULL для отмены)
  * @param arg пользовательский аргумент
+ *
+ * Уведомления подсчитываются, не сливаются в одно; remove их не создаёт.
+ * NULL отменяет отложенный вызов и обнуляет накопленные уведомления. Замена использует новые функцию/arg.
  */
 void queue_set_on_get(struct ll_queue* q, queue_callback_fn cbk_fn, void* arg);
 
 /**
  * @brief Регистрирует ожидание освобождения очереди до общего порога.
  * @param q очередь
- * @param h указатель на handle (создаётся как `struct queue_waiter_handle h = {0}` или `h.internal = NULL`)
+ * @param h handle, полностью обнулённый перед первым использованием: `struct queue_waiter_handle h = {0}`
  * @param callback функция, вызываемая при достижении порога
  * @param arg аргумент коллбэка
- * @return 1 — условие уже выполнено (callback вызван немедленно), 0 — зарегистрирован в списке, -1 — ошибка
+ * @return 1 — условие выполнено (callback вызван или отложен), 0 — ожидает порог, -1 — ошибка
  *
- * Если handle уже ожидает (h->internal != NULL) — старый waiter отменяется и создаётся новый.
+ * При корректных аргументах повторная регистрация в той же очереди отменяет прежнее ожидание.
+ * Если h->internal != NULL, перед переносом в другую очередь обязательно вызовите
+ * queue_waiter_cancel(old_q, h): очередь старого ожидания в handle не хранится.
+ * Уже отложенный callback (h->call_soon_id != NULL) отменяется по сохранённому h->defer_q,
+ * поэтому в этом состоянии handle можно передать другой очереди без отдельной отмены.
+ * При queue_free отменяются также уже запланированные уведомления.
  */
 int queue_waiter_wait(struct ll_queue* q, struct queue_waiter_handle* h,
                       queue_threshold_callback_fn callback, void* arg);
 
 /**
  * @brief Отменяет ожидание (удаляет из списка, если зарегистрирован).
- * @param q очередь
+ * @param q очередь исходного ожидания (для h->internal); не NULL
  * @param h указатель на handle
  *
- * Безопасно вызывать в любом состоянии: если waiter не зарегистрирован — ничего не делает.
+ * Отложенный callback отменяется через сохранённую h->defer_q. Если ожидания и отложенного
+ * callback нет — ничего не делает. При h->internal != NULL передавать другую очередь нельзя.
  */
 void queue_waiter_cancel(struct ll_queue* q, struct queue_waiter_handle* h);
 
-/* ==================== Работа с данными ==================== */
+// ==================== Работа с данными ====================
+
+/**
+ * Общие правила владения для всех четырёх queue_data_put*:
+ * - При q == NULL или entry == NULL возвращается -1 без освобождения памяти.
+ * - Элемент должен быть извлечён из прежней очереди: owner, prev и next должны быть NULL.
+ *   Повторная вставка связанного элемента приводит к abort().
+ * - При остальных отказах (лимит, неверный вид put или границы индекса) освобождаются
+ *   сначала dgram через queue_dgram_free(), затем entry через queue_entry_free().
+ * - При успехе владение передаётся очереди/потребителю. Put может синхронно вызвать callback,
+ *   который обработает и освободит entry и даже очередь до возврата из put.
+ *   Использовать эти указатели после put можно только при гарантированном времени жизни.
+ */
 
 /**
  * @brief Добавляет элемент в конец очереди (FIFO).
- * @param q очередь
- * @param entry элемент
- * @param id идентификатор для поиска
- * @return 0 — успех, -1 — превышен лимит (элемент освобождён)
+ * @param q очередь без хеш-таблицы (hash_size == 0)
+ * @param entry элемент; правила передачи владения см. выше
+ * @return 0 — добавлен, -1 — NULL-аргумент, переполнение или hash_size > 0
  */
 int queue_data_put(struct ll_queue* q, struct ll_entry* entry);
 
 /**
  * @brief Добавляет элемент в начало очереди (LIFO, высокий приоритет).
- * @param q очередь
- * @param entry элемент
- * @param id идентификатор
- * @return 0 — успех, -1 — превышен лимит (элемент освобождён)
+ * @param q очередь без хеш-таблицы (hash_size == 0)
+ * @param entry элемент; правила передачи владения см. выше
+ * @return 0 — добавлен, -1 — NULL-аргумент, переполнение или hash_size > 0
  */
 int queue_data_put_first(struct ll_queue* q, struct ll_entry* entry);
 
 /**
  * @brief Добавляет элемент в конец очереди с хеш-индексом (использует index_offset/index_size из очереди).
- * @param q очередь
- * @param entry элемент
- * @return 0 — успех, -1 — ошибка
+ * @param q очередь с настроенной хеш-таблицей (hash_size > 0, index_size > 0)
+ * @param entry элемент; ключ занимает index_size байт в data[] от index_offset и должен помещаться в entry->size
+ * @return 0 — добавлен, -1 — NULL-аргумент, переполнение или неверные границы/нулевой размер индекса
+ * @note Владение см. выше. При hash_size == 0 реализация может вернуть 0, добавив элемент без индексации;
+ *       наличие хеш-таблицы — предусловие, а не гарантированная проверка с возвратом -1.
  */
 int queue_data_put_with_index(struct ll_queue* q, struct ll_entry* entry);
 
 /**
  * @brief Добавляет элемент в начало очереди с хеш-индексом (использует index_offset/index_size из очереди).
- * @param q очередь
- * @param entry элемент
- * @return 0 — успех, -1 — ошибка
+ * @param q очередь с настроенной хеш-таблицей (hash_size > 0, index_size > 0)
+ * @param entry элемент; ключ занимает index_size байт в data[] от index_offset и должен помещаться в entry->size
+ * @return 0 — добавлен, -1 — NULL-аргумент, переполнение или неверные границы/нулевой размер индекса
+ * @note Владение см. выше. При hash_size == 0 реализация может вернуть 0, добавив элемент без индексации;
+ *       наличие хеш-таблицы — предусловие, а не гарантированная проверка с возвратом -1.
  */
 int queue_data_put_first_with_index(struct ll_queue* q, struct ll_entry* entry);
 
@@ -336,35 +400,35 @@ struct ll_entry* queue_data_get(struct ll_queue* q);
  */
 int queue_entry_count(struct ll_queue* q);
 
-/* ==================== Управление памятью элементов ==================== */
+// ==================== Управление памятью элементов ====================
 
 // проверить правильность очереди (корректность цепочки, счетчики элементов и байтов)
 int queue_check_consistency(struct ll_queue* q);
 
 /**
- * @brief Выделяет элемент с отдельным буфером dgram (malloc).
+ * @brief Выделяет элемент с отдельным буфером dgram через u_malloc (entry->len=0, memlen=len).
  * @param len требуемый размер dgram
  * @return элемент или NULL при ошибке
  */
 struct ll_entry* ll_alloc_lldgram(uint16_t len);
 
 /**
- * @brief Создаёт элемент с пользовательским буфером data[] (malloc одним блоком).
- * @param data_size размер data[]
+ * @brief Создаёт обнулённый элемент с пользовательским буфером data[] (u_malloc одним блоком).
+ * @param data_size размер data[], должен помещаться в uint16_t
  * @return элемент или NULL при ошибке
  */
 struct ll_entry* queue_entry_new(size_t data_size);
 
 /**
  * @brief Создаёт элемент из пула памяти.
- * @param pool пул
- * @return элемент или NULL, если пул пуст
+ * @param pool пул с object_size >= sizeof(struct ll_entry); разность размеров должна помещаться в uint16_t
+ * @return элемент или NULL при ошибке выделения; пустой кеш пула пополняется автоматически
  */
 struct ll_entry* queue_entry_new_from_pool(struct memory_pool* pool);
 
 /**
- * @brief Освобождает структуру элемента (возвращает в пул или free).
- * @param entry элемент
+ * @brief Освобождает структуру элемента (возвращает в пул или u_free).
+ * @param entry извлечённый из очереди элемент; NULL допустим
  *
  * @note НЕ освобождает dgram! Используйте queue_dgram_free() отдельно.
  */
@@ -373,10 +437,14 @@ void queue_entry_free(struct ll_entry* entry);
 /**
  * @brief Освобождает буфер dgram элемента.
  * @param entry элемент
+ *
+ * При dgram != NULL вызывает dgram_free_fn, если она задана; иначе возвращает буфер в dgram_pool,
+ * если задан пул; иначе вызывает u_free. Затем сбрасывает dgram и len. Сам entry не освобождает.
+ * Внешнему буферу нужен подходящий dgram_free_fn.
  */
 void queue_dgram_free(struct ll_entry* entry);
 
-/* ==================== Поиск и удаление ==================== */
+// ==================== Поиск и удаление ====================
 
 /**
  * @brief Находит элемент по ключу индекса (требуется hash_size > 0 при создании).
@@ -406,12 +474,12 @@ struct ll_entry* queue_find_next_by_index(struct ll_queue* q,
  */
 int queue_remove_data(struct ll_queue* q, struct ll_entry* entry);
 
-/* ==================== Утилиты ==================== */
+// ==================== Утилиты ====================
 
 /**
  * @brief Возвращает суммарный объём данных в очереди.
  * @param q очередь
- * @return количество байт
+ * @return сумма int_len (снимки len при put); изменение len связанного entry счётчик не пересчитывает
  */
 static inline size_t queue_total_bytes(struct ll_queue* q) {
     return q->total_bytes;

lib/ll_queue_doc.md

@@ -1,234 +0,0 @@
-# ll_queue — Двусвязная FIFO-очередь с автозабором и backpressure
-
-## 1. Назначение
-
-Двусвязная очередь элементов (FIFO) с автоматическим вызовом callback при появлении данных, пороговым ожиданием освобождения (backpressure), хеш-индексом для поиска и поддержкой пулов памяти. Используется как основной механизм передачи данных между компонентами внутри одного потока uasyc: TUN ↔ ETCP ↔ routing ↔ normalizer и т.д.
-
-Работает **строго в одном потоке** (один uasyc). Для многопоточного доступа не предназначена.
-
-## 2. Как пользоваться
-
-### 2.1. Создание очереди
-
-```c
-// Без хеша (простая очередь)
-struct ll_queue* q = queue_new(ua, 0, 0, 0, "my_queue");
-
-// С хешем — для быстрого поиска по ключу внутри data[]
-// hash_size=256, ключ лежит в data[] по смещению 0, размер ключа 4 байта
-struct ll_queue* q = queue_new(ua, 256, 0, 4, "my_hash_queue");
-```
-
-### 2.2. Создание элемента
-
-Три способа, по убыванию производительности:
-
-```c
-// 1. Из memory pool (самый быстрый)
-struct ll_entry* e = queue_entry_new_from_pool(instance->pkt_pool);
-
-// 2. Через malloc (data[] фиксированного размера одним блоком)
-struct ll_entry* e = queue_entry_new(sizeof(struct my_data));
-
-// 3. Элемент + отдельный буфер dgram (для переменного размера данных)
-struct ll_entry* e = ll_alloc_lldgram(dgram_len);
-memcpy(e->dgram, src_data, dgram_len);
-e->len = dgram_len;
-```
-
-### 2.3. Запись в очередь (backpressure)
-
-**Главное правило: не забиваем очередь!** Добавляем следующий элемент только когда очередь опустела до заданного порога. Для этого используется Пороговое ожидание:
-
-```c
-// 1. Настроить порог (например: ждать пока count<=0, т.е. очередь совсем пуста)
-queue_set_threshold(q, 0, 0);
-
-// 2. В структуре-производителе завести handle:
-struct queue_waiter_handle my_waiter = {0};
-
-// 3. При готовности отправить — зарегистрировать ожидание:
-static void my_send_cb(struct ll_queue* q, void* arg) {
-    struct my_producer* p = (struct my_producer*)arg;
-    struct ll_entry* e = ... // создать элемент
-    e->len = data_len;
-    queue_data_put_with_index(q, e);
-    // Снова зарегистрироваться на следующую порцию
-    queue_waiter_wait(q, &p->waiter, my_send_cb, p);
-}
-
-// Первичная регистрация:
-queue_waiter_wait(q, &my_waiter, my_send_cb, producer);
-
-// 4. При деинициализации — отменить ожидание:
-queue_waiter_cancel(q, &my_waiter);
-```
-
-### 2.4. Чтение из очереди (callback)
-
-```c
-// Установить callback — будет вызываться при появлении элементов
-queue_set_callback(q, my_callback, my_data);
-
-static void my_callback(struct ll_queue* q, void* arg) {
-    // 1. ИЗВЛЕЧЬ элемент
-    struct ll_entry* e = queue_data_get(q);
-    if (!e) { queue_resume_callback(q); return; }
-
-    // 2. ОБРАБОТАТЬ
-    if (e->dgram && e->len > 0) {
-        do_something(e->dgram, e->len);
-        queue_dgram_free(e); // сначала освободить dgram
-    }
-    queue_entry_free(e);     // потом освободить сам entry
-
-    // 3. ОБЯЗАТЕЛЬНО возобновить callback
-    queue_resume_callback(q);
-}
-```
-
-**Критически важно:** `queue_data_get()` автоматически приостанавливает callback-и (`callback_suspended = 1`). Без вызова `queue_resume_callback()` очередь **навсегда застрянет** — callback больше никогда не вызовется.
-
-Во **всех ветках** (включая ранние return по ошибке) должен быть `queue_resume_callback(q)`:
-
-```c
-// ПРАВИЛЬНО:
-if (!e) { queue_resume_callback(q); return; }
-if (!e->dgram) { queue_dgram_free(e); queue_entry_free(e); queue_resume_callback(q); return; }
-
-// НЕПРАВИЛЬНО — очередь зависнет:
-if (!e) return;
-```
-
-### 2.5. Поиск по индексу
-
-```c
-// Создать очередь с хешем (ключ 4 байта по смещению 0):
-struct ll_queue* q = queue_new(ua, 256, 0, 4, "indexed_q");
-
-// Добавлять элементы через _with_index (хеш вычисляется автоматически):
-queue_data_put_with_index(q, entry);
-
-// Искать:
-uint32_t key = 42;
-struct ll_entry* found = queue_find_data_by_index(q, &key);
-
-// Если несколько элементов с одним ключом — продолжать поиск:
-struct ll_entry* next = queue_find_next_by_index(q, &key, found);
-```
-
-### 2.6. Освобождение ресурсов
-
-```c
-// 1. Снять callback
-queue_set_callback(q, NULL, NULL);
-
-// 2. Отменить всех waiter-ов
-queue_waiter_cancel(q, &my_waiter);
-
-// 3. Извлечь и освободить ВСЕ оставшиеся элементы
-struct ll_entry* e;
-while ((e = queue_data_get(q)) != NULL) {
-    queue_dgram_free(e);
-    queue_entry_free(e);
-}
-// После извлечения всех элементов resume не нужен — callback уже снят.
-
-// 4. Освободить очередь
-queue_free(q);
-```
-
-**Важно:** `queue_free()` **не освобождает элементы**. Их нужно извлечь через `queue_data_get()` и освободить вручную.
-
-### 2.7. Приоритетная вставка (LIFO)
-
-```c
-// Вставить в начало очереди (высокий приоритет):
-queue_data_put_first(q, entry);
-queue_data_put_first_with_index(q, entry);
-```
-
-### 2.8. Удаление из середины
-
-```c
-queue_remove_data(q, entry);    // удаляет из очереди, НЕ освобождает память
-queue_dgram_free(entry);        // освободить dgram отдельно
-queue_entry_free(entry);        // освободить entry отдельно
-```
-
-После `queue_remove_data()` элемент больше не принадлежит очереди — вызывающий сам отвечает за его освобождение.
-
-### 2.9. Callback при опустошении
-
-```c
-static void on_empty(struct ll_queue* q, void* arg) {
-    // Очередь стала пустой (count==0)
-    // Вызывается однократно, после вызова сбрасывается
-}
-
-queue_set_empty_callback(q, on_empty, my_data);
-```
-
-## 3. API
-
-### Создание / уничтожение
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_new(ua, hash_size, index_offset, index_size, name)` | Создать очередь. `hash_size=0` — без хеша. `ua` обязателен (для uasync_call_soon). |
-| `queue_free(q)` | Освободить очередь (НЕ элементы — их надо извлечь и освободить отдельно). |
-
-### Создание / освобождение элементов
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_entry_new(data_size)` | Выделить entry с data[] через malloc. |
-| `queue_entry_new_from_pool(pool)` | Выделить entry из memory pool. |
-| `ll_alloc_lldgram(len)` | Выделить entry + отдельный буфер dgram (malloc). |
-| `queue_entry_free(entry)` | Освободить entry (возврат в pool или free). НЕ освобождает dgram! |
-| `queue_dgram_free(entry)` | Освободить dgram (через dgram_free_fn, pool или free). |
-
-### Чтение (callback)
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_set_callback(q, cbk_fn, arg)` | Установить callback автозабора. Вызывается при наличии элементов. |
-| `queue_data_get(q)` | Извлечь элемент из головы. Приостанавливает callback до `queue_resume_callback()`. |
-| `queue_resume_callback(q)` | **Обязательно** вызвать после обработки элемента. Планирует отложенный вызов callback через uasync_call_soon. |
-
-### Запись
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_data_put(q, entry)` | Добавить в конец (FIFO). Для очередей БЕЗ хеша. |
-| `queue_data_put_with_index(q, entry)` | Добавить в конец с хеш-индексом. |
-| `queue_data_put_first(q, entry)` | Добавить в начало (LIFO, высокий приоритет). |
-| `queue_data_put_first_with_index(q, entry)` | Добавить в начало с хеш-индексом. |
-
-### Backpressure
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_set_threshold(q, max_packets, max_bytes)` | Задать общий порог. Когда `count <= max_packets` И `total_bytes <= max_bytes`, waiter-ы пробуждаются (FIFO). |
-| `queue_waiter_wait(q, h, callback, arg)` | Зарегистрировать ожидание. Возвращает 1 (уже выполнено), 0 (в очереди), -1 (ошибка). |
-| `queue_waiter_cancel(q, h)` | Отменить ожидание. Безопасно вызывать в любом состоянии. |
-| `queue_set_waiter_defer(q, enable)` | Отложенный вызов waiter-ов (через uasync_call_soon). |
-| `queue_set_empty_callback(q, cbk_fn, arg)` | Одноразовый callback при count==0. |
-| `queue_set_on_get(q, cbk_fn, arg)` | Callback после каждого queue_data_get (deferred). |
-
-### Поиск / удаление
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_find_data_by_index(q, index_key)` | Найти по ключу (требуется hash_size>0). Размер ключа = q->index_size. |
-| `queue_find_next_by_index(q, index_key, prev_entry)` | Следующий элемент с тем же ключом. |
-| `queue_remove_data(q, entry)` | Удалить из очереди (память НЕ освобождает). |
-
-### Утилиты
-
-| Функция | Назначение |
-|---------|-----------|
-| `queue_entry_count(q)` | Текущее количество элементов. |
-| `queue_total_bytes(q)` | Суммарный объём данных (сумма len). |
-| `queue_set_size_limit(q, lim)` | Ограничение на количество элементов (при превышении новые удаляются). |
-| `queue_check_consistency(q)` | Проверка целостности (счётчики, циклы, prev/next). Только для отладки. |

lib/mem.c

@@ -13,11 +13,15 @@
 #define CANARY 0xDEADBEEF
 #define PADDING_FILL 0xAA
 #define METADATA_SIZE 128
+#define ALLOCATION_OVERHEAD (12 + (size_t)2 * BOUNDARY_CHECK_SIZE + METADATA_SIZE)
 #define POINTER_SIZE sizeof(void*)
 #define LOCATION_MAX (METADATA_SIZE - POINTER_SIZE * 2)
 #define PREV_OFFSET LOCATION_MAX
 #define NEXT_OFFSET (LOCATION_MAX + POINTER_SIZE)
 
+// Порог детекта аномально больших аллокаций (гигантские mmap-резервации, напр. VSZ ~4G)
+#define LARGE_ALLOC_LOG_THRESHOLD (8u * 1024u * 1024u)  // 8 МБ
+
 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
 #include <execinfo.h>
 #include <pthread.h>
@@ -86,7 +90,7 @@ void u_check(void* ptr, const char* text, const char* location) {
     uint8_t* prefix_start = base + METADATA_SIZE;
     uint32_t* pre_canary = (uint32_t*)(prefix_start + BOUNDARY_CHECK_SIZE);
     uint32_t size = *(uint32_t*)(prefix_start + BOUNDARY_CHECK_SIZE + 4);
-    uint32_t total = size + 12 + 2 * BOUNDARY_CHECK_SIZE + METADATA_SIZE;
+    size_t total = (size_t)size + ALLOCATION_OVERHEAD;
     uint8_t* user = (uint8_t*)ptr;
     bool error = false;
     for (size_t i = 0; i < BOUNDARY_CHECK_SIZE; i++) {
@@ -106,14 +110,15 @@ void u_check(void* ptr, const char* text, const char* location) {
             error = true;
         }
     }
-    uint32_t* post_canary = (uint32_t*)(user + size);
-    if (*post_canary != CANARY) {
-        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "%s: %s: overflow canary corrupted at %p (expected 0x%X, got 0x%X)", location, text, ptr, CANARY, *post_canary);
+    uint32_t post_canary;
+    memcpy(&post_canary, user + size, sizeof(post_canary));
+    if (post_canary != CANARY) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "%s: %s: overflow canary corrupted at %p (expected 0x%X, got 0x%X)", location, text, ptr, CANARY, post_canary);
         error = true;
     }
     if (error) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "%s: %s: Allocated at: %s", location, text, alloc_loc);
-        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "%s: %s: Memory block size (user): %u bytes, total allocated: %u bytes", location, text, size, total);
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "%s: %s: Memory block size (user): %u bytes, total allocated: %zu bytes", location, text, size, total);
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "%s: %s: Full memory dump at base %p:", location, text, base);
         hex_dump(base, total);
         exit(EXIT_FAILURE);
@@ -121,9 +126,21 @@ void u_check(void* ptr, const char* text, const char* location) {
 }
 
 void* u_malloc_impl(uint32_t size, const char* location) {
-    uint32_t total = size + 12 + 2 * BOUNDARY_CHECK_SIZE + METADATA_SIZE;
+    size_t total = size;
+    if (total > SIZE_MAX - ALLOCATION_OVERHEAD) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "MALLOC OVERFLOW: %u user bytes + %zu overhead bytes at %s", size, ALLOCATION_OVERHEAD, location);
+        return NULL;
+    }
+    if (size >= LARGE_ALLOC_LOG_THRESHOLD) {
+        DEBUG_WARN(DEBUG_CATEGORY_SYS, "LARGE ALLOC: %u bytes (%.1f MB) at %s",
+                   size, (double)size / (1024.0 * 1024.0), location);
+    }
+    total += ALLOCATION_OVERHEAD;
     uint8_t* base = (uint8_t*)malloc(total);
-    if (!base && size > 0) return NULL;
+    if (!base) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "MALLOC FAILED: %u user bytes, %zu total bytes at %s", size, total, location);
+        return NULL;
+    }
     memset(base, PADDING_FILL, total);
     // Set metadata
     size_t loc_len = strlen(location);
@@ -134,7 +151,8 @@ void* u_malloc_impl(uint32_t size, const char* location) {
     uint8_t* prefix_start = base + METADATA_SIZE;
     *(uint32_t*)(prefix_start + BOUNDARY_CHECK_SIZE) = CANARY;
     *(uint32_t*)(prefix_start + BOUNDARY_CHECK_SIZE + 4) = size;
-    *(uint32_t*)(prefix_start + BOUNDARY_CHECK_SIZE + 8 + size) = CANARY;
+    const uint32_t post_canary = CANARY; /* размер пользователя не обязан быть кратен выравниванию uint32_t */
+    memcpy(prefix_start + BOUNDARY_CHECK_SIZE + 8 + size, &post_canary, sizeof(post_canary));
     // Add to list (thread-safe)
     LOCK();
     void** prev_ptr = (void**)(base + PREV_OFFSET);
@@ -151,6 +169,10 @@ void* u_malloc_impl(uint32_t size, const char* location) {
 }
 
 void* u_calloc_impl(uint32_t nmemb, uint32_t size, const char* location) {
+    if (nmemb != 0 && size > UINT32_MAX / nmemb) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "CALLOC OVERFLOW: %u * %u (wraps uint32) at %s", nmemb, size, location);
+        return NULL;
+    }
     uint32_t total_size = nmemb * size;
     void* ptr = u_malloc_impl(total_size, location);
     if (ptr) memset(ptr, 0, total_size);
@@ -196,7 +218,7 @@ void u_free_impl(void* ptr, const char* location) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "Base:              %p", (void*)base);
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "Allocated at:      %s", alloc_loc);
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "User size:         %u bytes", size);
-        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "Total allocated:   %u bytes", size + 12 + 2 * BOUNDARY_CHECK_SIZE + METADATA_SIZE);
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "Total allocated:   %zu bytes", (size_t)size + ALLOCATION_OVERHEAD);
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "Active allocs:     %zu", active_count);
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "--- Metadata dump at %p (%u bytes) ---", (void*)base, (unsigned)(METADATA_SIZE + BOUNDARY_CHECK_SIZE + 8));
         hex_dump(base, METADATA_SIZE + BOUNDARY_CHECK_SIZE + 8);
@@ -218,7 +240,7 @@ void u_free_impl(void* ptr, const char* location) {
     allocated_count--;
     frees_count++;
     UNLOCK();
-    uint32_t total = size + 12 + 2 * BOUNDARY_CHECK_SIZE + METADATA_SIZE;
+    size_t total = (size_t)size + ALLOCATION_OVERHEAD;
     memset(base, 0, total);
     free(base);
 }

lib/mem.h

@@ -1,6 +1,12 @@
 /**
- * Memory management layer
- * Provides wrappers for malloc/realloc/calloc/free with error handling
+ * mem — выделение памяти с защитными полями, местом аллокации и учётом живых блоков.
+ * Использовать u_malloc/u_calloc/u_realloc/u_strdup и парный u_free; обычный free к этим блокам неприменим.
+ * Макросы передают LOCATION автоматически. OOM возвращает NULL; обнаруженное повреждение завершает процесс.
+ * realloc живого блока при ошибке сохраняет его, при size=0 освобождает; NULL обрабатывается как malloc.
+ * Размеры аргументов _impl — uint32_t; до вызова проверить, что исходные size_t помещаются в этот диапазон.
+ * Список аллокаций защищён мьютексом; доступ к одному блоку и чтение счётчика согласует вызывающий.
+ * Защитные поля проверяются для живых блоков; обращение к уже освобождённому/чужому указателю недопустимо.
+ * Отчёт u_report_unfreed_blocks вызывать после остановки потоков, меняющих список аллокаций.
  */
 #ifndef MEM_H
 #define MEM_H
@@ -12,18 +18,30 @@ extern "C" {
 #define XSTR(s) STR(s)
 #define STR(s) #s
 #define LOCATION __FILE__ ":" XSTR(__LINE__)
+// Проверяет canary/padding живого блока; text/location — строки диагностики. NULL ptr допустим.
+// Обнаруженное повреждение логируется в SYS и завершает процесс через exit(EXIT_FAILURE).
 void u_check(void* ptr, const char* text, const char* location);
 #define u_malloc(size) u_malloc_impl(size, LOCATION)
 #define u_calloc(nmemb, size) u_calloc_impl(nmemb, size, LOCATION)
 #define u_realloc(ptr, size) u_realloc_impl(ptr, size, LOCATION)
 #define u_free(ptr) u_free_impl(ptr, LOCATION)
 #define u_strdup(s) u_strdup_impl(s, LOCATION)
+// Выделяет size байт с метаданными; NULL при OOM/переполнении полного размера. size=0 тоже создаёт учтённый блок.
+// location — обязательная строка места вызова, копируется в метаданные; payload не обнуляется.
 void* u_malloc_impl(uint32_t size, const char* location);
+// Выделяет и обнуляет nmemb*size байт; NULL при произведении > UINT32_MAX или ошибке malloc.
 void* u_calloc_impl(uint32_t nmemb, uint32_t size, const char* location);
+// NULL ptr → malloc(size), включая size=0. Для живого ptr: size=0 → free и NULL;
+// иначе новый блок с min(старый размер, size) байтами данных. При OOM возвращает NULL, старый блок сохранён.
+// Результат сохранять временно: tmp = u_realloc(ptr, size); if (tmp) ptr = tmp; (при size > 0).
 void* u_realloc_impl(void* ptr, uint32_t size, const char* location);
+// Проверяет и освобождает живой блок из этих обёрток; NULL допустим. Обычный free к нему неприменим.
 void u_free_impl(void* ptr, const char* location);
+// Копирует ASCIIZ-строку (strlen(s)+1 должно помещаться в uint32_t); NULL при NULL s/OOM. Освобождать u_free.
 char* u_strdup_impl(const char* s, const char* location);
+// После остановки изменяющих список потоков: статистика и дампы живых блоков; сами блоки не освобождает.
 void u_report_unfreed_blocks(void);
+// Число живых блоков, чтение без блокировки; параллельные аллокации/освобождения нужно исключить извне.
 size_t u_get_allocated_count(void);
 #ifdef __cplusplus
 }

lib/mem_doc.md

@@ -1,48 +0,0 @@
-# mem (Memory Wrappers с отслеживанием утечек)
-
-## 1. Назначение
-
-Обёртки над стандартными `malloc`/`calloc`/`realloc`/`free`/`strdup` с детекцией:
-- **Buffer overflow/underflow** — каждый блок окружён канарейками (`0xDEADBEEF`) и padding-областями, которые проверяются при `u_free` и `u_realloc`. При повреждении — подробный дамп блока и аварийное завершение.
-- **Double free** — двусвязный список всех живых аллокаций; повторное освобождение детектируется по отсутствию блока в списке.
-- **Утечки памяти** — `u_report_unfreed_blocks()` при завершении выводит все незакрытые блоки с местом аллокации (`файл:строка`), размером и hex-дампом данных.
-
-Функции потокобезопасны (мьютекс/критическая секция).
-
-## 2. Как пользоваться
-
-```c
-#include "mem.h"
-
-// Вместо malloc/calloc/realloc/free/strdup используй соответствующие макросы:
-void* buf = u_malloc(data_size);
-char* str = u_strdup("hello");
-buf = u_realloc(buf, new_size);
-u_free(buf);
-u_free(str);
-
-// В конце main (перед return) — отчёт о незакрытых блоках:
-u_report_unfreed_blocks();
-
-// Текущее число живых аллокаций (для диагностики):
-size_t count = u_get_allocated_count();
-```
-
-**Важно:**
-- Макросы (`u_malloc`, `u_calloc`, `u_free`, и т.д.) автоматически подставляют `__FILE__:__LINE__` через `LOCATION` — это нужно для диагностики утечек и повреждений. Напрямую вызывай `_impl`-функции только если нужно явно передать location.
-- `u_realloc(NULL, size)` эквивалентен `u_malloc(size)`, `u_realloc(ptr, 0)` эквивалентен `u_free(ptr)`.
-- Потокобезопасность гарантирована, но аллокации с метаданными заметно дороже обычного `malloc` — используй `memory_pool` для hot-path объектов.
-- При обнаружении повреждения (overflow/underflow/double-free) программа завершается через `exit(EXIT_FAILURE)` после вывода отладочной информации.
-
-## 3. API
-
-| Функция/макрос | Описание |
-|---|---|
-| `u_malloc(size)` | Аналог `malloc` с boundary check и трекингом |
-| `u_calloc(nmemb, size)` | Аналог `calloc` (выделяет + обнуляет) |
-| `u_realloc(ptr, size)` | Аналог `realloc`, с проверкой целостности старого блока |
-| `u_free(ptr)` | Освобождение с проверкой canary, double-free и удалением из списка |
-| `u_strdup(s)` | Аналог `strdup` через u_malloc |
-| `u_report_unfreed_blocks()` | Выводит все незакрытые блоки с дампом; вызывается при shutdown |
-| `u_get_allocated_count()` | Возвращает количество живых аллокаций |
-| `u_check(ptr, text, location)` | Ручная проверка целостности блока (canary + padding) |

lib/memory_pool.c

@@ -5,47 +5,59 @@
 #include "memory_pool.h"
 #include "mem.h"
 
-// Layout: [user_data: object_size] [canary: 4 bytes] [alloc_loc: pointer] [counter: 1 byte]
+// Layout: [user_data] [canary: 4] [alloc_loc: pointer] [free_loc: pointer] [counter: 1]
 #define POOL_CANARY_OFF   (pool->object_size)
 #define POOL_LOC_OFF      (pool->object_size + 4)
-#define POOL_COUNTER_OFF  (pool->object_size + 4 + sizeof(const char*))
-#define POOL_ALLOC_SIZE   (pool->object_size + 4 + sizeof(const char*) + 1)
+#define POOL_FREE_LOC_OFF (pool->object_size + 4 + sizeof(const char*))
+#define POOL_COUNTER_OFF  (pool->object_size + 4 + 2 * sizeof(const char*))
+#define POOL_ALLOC_SIZE   (pool->object_size + 4 + 2 * sizeof(const char*) + 1)
 #define POOL_CANARY_VAL   0xDEADBEAF
 
 static void pool_init_tags(struct memory_pool* pool, void* obj, const char* location)
 {
-    uint32_t* canary  = (uint32_t*)((uint8_t*)obj + POOL_CANARY_OFF);
-    const char** loc  = (const char**)((uint8_t*)obj + POOL_LOC_OFF);
+    const uint32_t canary = POOL_CANARY_VAL;
     uint8_t*  counter = (uint8_t*)obj + POOL_COUNTER_OFF;
-    *canary  = POOL_CANARY_VAL;
-    *loc     = location;
+    /* Метаданные следуют за payload произвольного размера и могут быть невыровненными. */
+    memcpy((uint8_t*)obj + POOL_CANARY_OFF, &canary, sizeof(canary));
+    memcpy((uint8_t*)obj + POOL_LOC_OFF, &location, sizeof(location));
+    const char* free_loc = NULL;
+    memcpy((uint8_t*)obj + POOL_FREE_LOC_OFF, &free_loc, sizeof(free_loc));
     *counter = 1;
 }
 
 static void pool_check_and_clear_tags(struct memory_pool* pool, void* obj, const char* location)
 {
-    uint32_t*    canary  = (uint32_t*)((uint8_t*)obj + POOL_CANARY_OFF);
-    const char** loc     = (const char**)((uint8_t*)obj + POOL_LOC_OFF);
+    uint32_t canary;
+    const char *loc, *free_loc;
+    memcpy(&canary, (uint8_t*)obj + POOL_CANARY_OFF, sizeof(canary));
+    memcpy(&loc, (uint8_t*)obj + POOL_LOC_OFF, sizeof(loc));
+    memcpy(&free_loc, (uint8_t*)obj + POOL_FREE_LOC_OFF, sizeof(free_loc));
     uint8_t*     counter = (uint8_t*)obj + POOL_COUNTER_OFF;
 
-    if (*canary != POOL_CANARY_VAL) {
+    if (canary != POOL_CANARY_VAL) {
         DEBUG_ERROR(DEBUG_CATEGORY_SYS, "pool_free BUFFER OVERFLOW pool=%p name=%s sz=%zu allocs=%zu reuse=%zu free=%d",
                     pool, pool->name ? pool->name : "?", pool->object_size, pool->allocations, pool->reuse_count, pool->free_count);
-        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "  obj=%p alloc=%s free=%s canary=0x%08x expected=0x%08x",
-                    obj, *loc ? *loc : "(null)", location, *canary, POOL_CANARY_VAL);
+        /* Повреждённый хвост может содержать битые указатели; их нельзя читать как строки. */
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "  obj=%p alloc_loc_ptr=%p free_loc_ptr=%p free_attempt=%s canary=0x%08x expected=0x%08x",
+                    obj, (void*)loc, (void*)free_loc, location, canary, POOL_CANARY_VAL);
         if (pool->object_size)
             log_dump(DEBUG_LEVEL_ERROR, DEBUG_CATEGORY_SYS, "  user_data", obj, pool->object_size);
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "pool_free: corruption logged, stopping thread permanently obj=%p", obj);
         volatile int _halt = 1;
         while (_halt) {}
     }
     if (*counter == 0) {
-        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "pool_free DOUBLE FREE pool=%p name=%s sz=%zu allocs=%zu reuse=%zu alloc=%s free=%s",
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "pool_free DOUBLE FREE pool=%p name=%s sz=%zu allocs=%zu reuse=%zu obj=%p",
                     pool, pool->name ? pool->name : "?", pool->object_size, pool->allocations, pool->reuse_count,
-                    *loc ? *loc : "(null)", location);
+                    obj);
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "  alloc=%s first_free=%s repeated_free=%s",
+                    loc ? loc : "(null)", free_loc ? free_loc : "(null)", location);
+        DEBUG_ERROR(DEBUG_CATEGORY_SYS, "pool_free: corruption logged, stopping thread permanently obj=%p", obj);
         volatile int _halt = 1;
         while (_halt) {}
     }
     *counter = 0;
+    memcpy((uint8_t*)obj + POOL_FREE_LOC_OFF, &location, sizeof(location));
 }
 
 static size_t g_total_free = 0;

lib/memory_pool.h

@@ -1,4 +1,13 @@
-// memory_pool.h
+/* memory_pool — повторное использование блоков фиксированного размера в одном потоке.
+ * init создаёт пустой пул; alloc выделяет блок по требованию или берёт свободный и обнуляет payload.
+ * free проверяет защитный хвост и возвращает не более MEMORY_POOL_MAX_FREE блоков в кеш.
+ * object_size должен вмещать void*: свободный блок хранит next в начале payload.
+ * Перед destroy вернуть все выданные блоки: destroy освобождает только кеш и сам пул.
+ * name заимствован до destroy; блок возвращать только своему пулу, внутренней синхронизации нет. */
+/* Хвост блока хранит canary, места alloc/free и метку занятости. Повреждение или повторный возврат
+ * кешированного блока логируется в SYS и навсегда останавливает текущий поток циклом диагностики.
+ * Пример для очередей: init(sizeof(struct ll_entry) + inline_size, name), затем queue_entry_new_from_pool.
+ * Объекты, уже переданные в u_free при переполнении кеша, больше нельзя проверять или возвращать. */
 #ifndef MEMORY_POOL_H
 #define MEMORY_POOL_H
 
@@ -20,26 +29,31 @@ struct memory_pool {
     void* free_head;            // Голова linked list свободных блоков (next хранится в начале каждого блока)
     int free_count;             // Количество свободных блоков
     size_t object_size;         // Размер объектов в пуле (пользовательские данные)
-    size_t allocations;         // Общее количество аллокаций (включая новые malloc)
+    size_t allocations;         // Попытки выделить новый блок, включая неудачные; выдачи из кеша не учитываются
     size_t reuse_count;         // Количество повторных использований из пула
-    uint8_t alloc_tag_counter;  // монотонный счётчик для детекции double-free (1 байт)
+    uint8_t alloc_tag_counter;  // Не используется; init устанавливает 1. Double-free проверяется по метке в хвосте блока
     const char* name;           // Имя пула для диагностики (напр. "data_pool", "pkt_pool")
 };
 
-// сам пул:
-// если используем с элементами ll_queue то не забываем что к object_size надо прибавить sizeof(struct ll_entry)
+// Создаёт пустой пул: object_size >= sizeof(void*), name живёт до destroy; NULL при OOM.
+// Для ll_queue размер включает sizeof(struct ll_entry) и пользовательский data[].
 struct memory_pool* memory_pool_init(size_t object_size, const char* name);
+// Освобождает кеш и пул, но не выданные объекты; NULL допустим. Все владельцы должны предварительно вернуть блоки.
 void memory_pool_destroy(struct memory_pool* pool);
 
-// элементы пула:
+// Выдаёт обнулённый payload из кеша или нового блока; NULL при NULL pool/OOM. location — место вызова в хвосте.
 void* memory_pool_alloc_impl(struct memory_pool* pool, const char* location);
+// Возвращает свой живой obj в кеш или u_free, если кеш заполнен; NULL pool/obj ничего не делает.
 void memory_pool_free_impl(struct memory_pool* pool, void* obj, const char* location);
+// Копирует счётчики попыток новых аллокаций и выдач из кеша; любой выход может быть NULL, NULL pool ничего не меняет.
 void memory_pool_get_stats(struct memory_pool* pool, size_t* allocations, size_t* reuse_count);
+// Общее число кешированных блоков всех пулов; глобальный счётчик не синхронизирован.
 size_t memory_pool_get_total_free_blocks(void);
 
 #define memory_pool_alloc(pool) memory_pool_alloc_impl(pool, PLOCATION)
 #define memory_pool_free(pool, obj) memory_pool_free_impl(pool, obj, PLOCATION)
 
+/* Проверяет присутствие в кеше свободных блоков; не определяет состояние уже освобождённого через u_free блока. */
 int memory_pool_is_freed(struct memory_pool* pool, void* obj);
 
 

lib/memory_pool_doc.md

@@ -1,57 +0,0 @@
-# memory_pool (Object Pool Allocator)
-
-## 1. Назначение
-
-Быстрый аллокатор объектов фиксированного размера. Вместо постоянных `malloc`/`free` хранит до 64 освобождённых объектов в linked list для повторного использования. Применяется для hot-path объектов, которые часто создаются и уничтожаются: пакеты, фрагменты, ACK-пакеты, структуры маршрутизации, TCP-сегменты lwIP и т.д.
-
-Встроенная защита:
-- **Buffer overflow** — канарейка `0xDEADBEAF` после пользовательских данных проверяется при освобождении. При повреждении — бесконечный цикл (hang) для отладки.
-- **Double free** — однобайтный счётчик в метаданных; повторное освобождение детектируется и вызывает hang.
-- Вся диагностика пишется через `DEBUG_ERROR(DEBUG_CATEGORY_MEMORY, ...)`.
-
-Не потокобезопасен — каждый пул используется из одного потока (обычно в рамках одного u_async event loop).
-
-## 2. Как пользоваться
-
-```c
-#include "memory_pool.h"
-
-// 1. Создать пул (обычно в init-функции инстанса):
-struct memory_pool* pkt_pool = memory_pool_init(sizeof(struct ETCP_DGRAM), "pkt_pool");
-
-// 2. Выделить объект (если есть свободный — вернёт из пула, иначе u_calloc):
-struct ETCP_DGRAM* dgram = memory_pool_alloc(pkt_pool);
-
-// 3. Освободить объект (возвращается в пул, если там меньше 64 блоков):
-memory_pool_free(pkt_pool, dgram);
-
-// 4. Получить статистику:
-size_t allocs, reuse;
-memory_pool_get_stats(pkt_pool, &allocs, &reuse);
-// reuse много → эффективно; reuse мало → пул слишком мал для нагрузки
-
-// 5. Проверить, в пуле ли объект (0 — не в пуле, 1 — в пуле):
-if (memory_pool_is_freed(pkt_pool, obj)) { /* уже освобождён */ }
-
-// 6. Уничтожить пул (при shutdown):
-memory_pool_destroy(pkt_pool);
-// реально освобождает все кэшированные блоки через u_free() и сам пул.
-```
-
-**Важно:**
-- Если объекты пула используются как элементы `ll_queue`, в `object_size` нужно закладывать `sizeof(struct ll_entry)`. Например: `memory_pool_init(sizeof(struct ll_entry) + sizeof(struct dummynet_pkt), "pkt_pool")`.
-- `memory_pool_alloc` обнуляет объект перед возвратом (защита от утечки старых данных).
-- При заполнении пула (64 свободных блока) лишние `memory_pool_free` реально вызывают `u_free` — блок не кэшируется.
-- `memory_pool_destroy` проходит по всем свободным блокам и вызывает `u_free` для каждого, затем освобождает сам `struct memory_pool`.
-
-## 3. API
-
-| Функция/макрос | Описание |
-|---|---|
-| `memory_pool_init(object_size, name)` | Создаёт пул для объектов заданного размера. `name` — для диагностики. |
-| `memory_pool_alloc(pool)` | Выделяет объект: из кэша (если есть) или через `u_calloc`. Обнуляет перед возвратом. |
-| `memory_pool_free(pool, obj)` | Возвращает объект в пул (до 64) или вызывает `u_free`. Проверяет canary и double-free. |
-| `memory_pool_destroy(pool)` | Уничтожает пул: освобождает все кэшированные блоки и сам пул. |
-| `memory_pool_get_stats(pool, &allocs, &reuse)` | Статистика: общее число аллокаций и число повторных использований из кэша. |
-| `memory_pool_get_total_free_blocks()` | Глобальный счётчик свободных блоков во всех пулах (для диагностики). |
-| `memory_pool_is_freed(pool, obj)` | Проверяет, находится ли объект в свободном списке пула (уже освобождён). |

lib/miniaudio.h

@@ -6780,7 +6780,9 @@ typedef enum
     ma_device_notification_type_rerouted,
     ma_device_notification_type_interruption_began,
     ma_device_notification_type_interruption_ended,
-    ma_device_notification_type_unlocked
+    ma_device_notification_type_unlocked,
+    ma_device_notification_type_capture_overrun,   /* uTun: подтверждённый backend разрыв входного PCM. */
+    ma_device_notification_type_playback_underrun  /* uTun: backend исчерпал буфер воспроизведения. */
 } ma_device_notification_type;
 
 typedef struct
@@ -7543,11 +7545,13 @@ struct ma_context
             ma_proc pa_context_disconnect;
             ma_proc pa_context_set_state_callback;
             ma_proc pa_context_get_state;
+            ma_proc pa_context_errno;
             ma_proc pa_context_get_sink_info_list;
             ma_proc pa_context_get_source_info_list;
             ma_proc pa_context_get_sink_info_by_name;
             ma_proc pa_context_get_source_info_by_name;
             ma_proc pa_operation_unref;
+            ma_proc pa_operation_cancel;
             ma_proc pa_operation_get_state;
             ma_proc pa_channel_map_init_extend;
             ma_proc pa_channel_map_valid;
@@ -7563,6 +7567,7 @@ struct ma_context
             ma_proc pa_stream_get_buffer_attr;
             ma_proc pa_stream_set_buffer_attr;
             ma_proc pa_stream_get_device_name;
+            ma_proc pa_stream_get_latency;
             ma_proc pa_stream_set_write_callback;
             ma_proc pa_stream_set_read_callback;
             ma_proc pa_stream_set_suspended_callback;
@@ -7574,6 +7579,7 @@ struct ma_context
             ma_proc pa_stream_cork;
             ma_proc pa_stream_trigger;
             ma_proc pa_stream_begin_write;
+            ma_proc pa_stream_cancel_write;
             ma_proc pa_stream_write;
             ma_proc pa_stream_peek;
             ma_proc pa_stream_drop;
@@ -11553,6 +11559,17 @@ IMPLEMENTATION
 #ifndef miniaudio_c
 #define miniaudio_c
 
+/* uTun: необязательные наблюдатели, без изменения ABI и поведения аудиотракта. */
+#ifndef MA_DIAGNOSTIC_EVENT
+#define MA_DIAGNOSTIC_EVENT(device, kind, stage, value, detail) ((void)0)
+#endif
+#ifndef MA_DIAGNOSTIC_DEVICE_INIT
+#define MA_DIAGNOSTIC_DEVICE_INIT(device) ((void)0)
+#endif
+#ifndef MA_DIAGNOSTIC_LOG
+#define MA_DIAGNOSTIC_LOG(log, level, message) ((void)0)
+#endif
+
 #include <assert.h>
 #include <limits.h>         /* For INT_MAX */
 #include <math.h>           /* sin(), etc. */
@@ -13752,6 +13769,7 @@ MA_API ma_result ma_log_post(ma_log* pLog, ma_uint32 level, const char* pMessage
         return MA_INVALID_ARGS;
     }
 
+    MA_DIAGNOSTIC_LOG(pLog, level, pMessage);
     ma_log_lock(pLog);
     {
         ma_uint32 iLog;
@@ -20200,6 +20218,14 @@ static void ma_device__on_notification(ma_device_notification notification)
 {
     MA_ASSERT(notification.pDevice != NULL);
 
+    if (notification.type == ma_device_notification_type_capture_overrun) {
+        MA_DIAGNOSTIC_EVENT(notification.pDevice, AUDIO_DIAG_BACKEND_OVERFLOW, AUDIO_DIAG_READ, 1, 0);
+    } else if (notification.type == ma_device_notification_type_playback_underrun) {
+        MA_DIAGNOSTIC_EVENT(notification.pDevice, AUDIO_DIAG_BACKEND_UNDERRUN, AUDIO_DIAG_WRITE, 1, 0);
+    } else {
+        MA_DIAGNOSTIC_EVENT(notification.pDevice, AUDIO_DIAG_NOTIFY, -1, notification.type, ma_device_get_state(notification.pDevice));
+    }
+
     if (notification.pDevice->onNotification != NULL) {
         notification.pDevice->onNotification(&notification);
     }
@@ -20360,6 +20386,7 @@ static void ma_device__handle_data_callback(ma_device* pDevice, void* pFramesOut
 {
     float masterVolumeFactor;
 
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_CALLBACK, frameCount, (pFramesIn != NULL) | ((pFramesOut != NULL) << 1));
     ma_device_get_master_volume(pDevice, &masterVolumeFactor);  /* Use ma_device_get_master_volume() to ensure the volume is loaded atomically. */
 
     if (pDevice->onData) {
@@ -20407,6 +20434,7 @@ static void ma_device__handle_data_callback(ma_device* pDevice, void* pFramesOut
             ma_silence_pcm_frames(pFramesOut, frameCount, pDevice->playback.format, pDevice->playback.channels);
         }
     }
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_CALLBACK, frameCount, 0);
 }
 
 
@@ -20590,6 +20618,7 @@ static ma_result ma_device__handle_duplex_callback_capture(ma_device* pDevice, m
 
         if (framesToProcessInClientFormat == 0) {
             if (ma_pcm_rb_pointer_distance(pRB) == (ma_int32)ma_pcm_rb_get_subbuffer_size(pRB)) {
+                MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_CAPTURE_DROP, AUDIO_DIAG_READ, framesToProcessInDeviceFormat, ma_pcm_rb_available_read(pRB));
                 break;  /* Overrun. Not enough room in the ring buffer for input frame. Excess frames are dropped. */
             }
         }
@@ -20625,6 +20654,7 @@ static ma_result ma_device__handle_duplex_callback_playback(ma_device* pDevice,
     ma_result result;
     ma_uint8 silentInputFrames[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
     ma_uint32 totalFramesReadOut = 0;
+    ma_silence_pcm_frames(pFramesInInternalFormat, frameCount, pDevice->playback.internalFormat, pDevice->playback.internalChannels);
 
     MA_ASSERT(pDevice != NULL);
     MA_ASSERT(frameCount > 0);
@@ -20636,6 +20666,7 @@ static ma_result ma_device__handle_duplex_callback_playback(ma_device* pDevice,
     Sitting in the ring buffer should be captured data from the capture callback in external format. If there's not enough data in there for
     the whole frameCount frames we just use silence instead for the input data.
     */
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_DUPLEX, frameCount, ma_pcm_rb_available_read(pRB));
     MA_ZERO_MEMORY(silentInputFrames, sizeof(silentInputFrames));
 
     while (totalFramesReadOut < frameCount && ma_device_is_started(pDevice)) {
@@ -20646,8 +20677,12 @@ static ma_result ma_device__handle_duplex_callback_playback(ma_device* pDevice,
         if (pDevice->playback.inputCacheRemaining > 0) {
             ma_uint64 framesConvertedIn  = pDevice->playback.inputCacheRemaining;
             ma_uint64 framesConvertedOut = (frameCount - totalFramesReadOut);
-            ma_data_converter_process_pcm_frames(&pDevice->playback.converter, ma_offset_pcm_frames_ptr(pDevice->playback.pInputCache, pDevice->playback.inputCacheConsumed, pDevice->playback.format, pDevice->playback.channels), &framesConvertedIn, pFramesInInternalFormat, &framesConvertedOut);
+            result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, ma_offset_pcm_frames_ptr(pDevice->playback.pInputCache, pDevice->playback.inputCacheConsumed, pDevice->playback.format, pDevice->playback.channels), &framesConvertedIn, pFramesInInternalFormat, &framesConvertedOut);
 
+            if (result != MA_SUCCESS || (framesConvertedIn == 0 && framesConvertedOut == 0)) {
+                MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_DUPLEX, 1, result);
+                break;
+            }
             pDevice->playback.inputCacheConsumed  += framesConvertedIn;
             pDevice->playback.inputCacheRemaining -= framesConvertedIn;
 
@@ -20662,30 +20697,34 @@ static ma_result ma_device__handle_duplex_callback_playback(ma_device* pDevice,
 
             inputFrameCount = (ma_uint32)pDevice->playback.inputCacheCap;
             result = ma_pcm_rb_acquire_read(pRB, &inputFrameCount, &pInputFrames);
-            if (result == MA_SUCCESS) {
-                if (inputFrameCount > 0) {
-                    ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, pInputFrames, inputFrameCount);
-                } else {
-                    if (ma_pcm_rb_pointer_distance(pRB) == 0) {
-                        break;  /* Underrun. */
-                    }
+            if (result != MA_SUCCESS) {
+                MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_DUPLEX, 1, result);
+                break;
+            }
+            if (inputFrameCount > 0) {
+                ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, pInputFrames, inputFrameCount);
+                result = ma_pcm_rb_commit_read(pRB, inputFrameCount);
+                if (result != MA_SUCCESS) {
+                    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_DUPLEX, 1, result);
+                    break;
                 }
             } else {
-                /* No capture data available. Feed in silence. */
-                inputFrameCount = (ma_uint32)ma_min(pDevice->playback.inputCacheCap, sizeof(silentInputFrames) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels));
+                /* Отсутствие микрофонных кадров не останавливает рендер; синтетический ввод не сдвигает capture-ring. */
+                inputFrameCount = (ma_uint32)ma_min(pDevice->playback.inputCacheCap,
+                    sizeof(silentInputFrames) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels));
                 ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, silentInputFrames, inputFrameCount);
             }
 
             pDevice->playback.inputCacheConsumed  = 0;
             pDevice->playback.inputCacheRemaining = inputFrameCount;
 
-            result = ma_pcm_rb_commit_read(pRB, inputFrameCount);
-            if (result != MA_SUCCESS) {
-                return result;  /* Should never happen. */
-            }
         }
     }
 
+    if (totalFramesReadOut < frameCount) {
+        MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_UNFILLED, AUDIO_DIAG_DUPLEX, frameCount - totalFramesReadOut, ma_pcm_rb_available_read(pRB));
+    }
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_DUPLEX, totalFramesReadOut, ma_pcm_rb_available_read(pRB));
     return MA_SUCCESS;
 }
 
@@ -24793,6 +24832,7 @@ static ma_result ma_device_read__wasapi(ma_device* pDevice, void* pFrames, ma_ui
 
                 /* Overrun detection. */
                 if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_capture_overrun));
                     /* Glitched. Probably due to an overrun. */
 
                     /*
@@ -24923,6 +24963,7 @@ static ma_result ma_device_write__wasapi(ma_device* pDevice, const void* pFrames
 {
     ma_result result = MA_SUCCESS;
     ma_uint32 totalFramesProcessed = 0;
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_WRITE, frameCount, pDevice->wasapi.mappedBufferPlaybackLen);
 
     /* Keep writing to the device until it's stopped or we've consumed all of our input. */
     while (ma_device_get_state(pDevice) == ma_device_state_started && totalFramesProcessed < frameCount) {
@@ -25009,6 +25050,7 @@ static ma_result ma_device_write__wasapi(ma_device* pDevice, const void* pFrames
         *pFramesWritten = totalFramesProcessed;
     }
 
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_WRITE, totalFramesProcessed, result);
     return result;
 }
 
@@ -29869,6 +29911,7 @@ static ma_result ma_device_read__alsa(ma_device* pDevice, void* pFramesOut, ma_u
                 continue;   /* Try again. */
             } else if (resultALSA == -EPIPE) {
                 ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EPIPE (read)\n");
+                ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_capture_overrun));
 
                 /* Overrun. Recover and try again. If this fails we need to return an error. */
                 resultALSA = ((ma_snd_pcm_recover_proc)pDevice->pContext->alsa.snd_pcm_recover)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, resultALSA, MA_TRUE);
@@ -29924,6 +29967,7 @@ static ma_result ma_device_write__alsa(ma_device* pDevice, const void* pFrames,
                 continue;   /* Try again. */
             } else if (resultALSA == -EPIPE) {
                 ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EPIPE (write)\n");
+                ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_playback_underrun));
 
                 /* Underrun. Recover and try again. If this fails we need to return an error. */
                 resultALSA = ((ma_snd_pcm_recover_proc)pDevice->pContext->alsa.snd_pcm_recover)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, resultALSA, MA_TRUE);    /* MA_TRUE=silent (don't print anything on error). */
@@ -30908,11 +30952,13 @@ typedef int                      (* ma_pa_context_connect_proc)                (
 typedef void                     (* ma_pa_context_disconnect_proc)             (ma_pa_context* c);
 typedef void                     (* ma_pa_context_set_state_callback_proc)     (ma_pa_context* c, ma_pa_context_notify_cb_t cb, void* userdata);
 typedef ma_pa_context_state_t    (* ma_pa_context_get_state_proc)              (const ma_pa_context* c);
+typedef int                      (* ma_pa_context_errno_proc)                  (const ma_pa_context* c);
 typedef ma_pa_operation*         (* ma_pa_context_get_sink_info_list_proc)     (ma_pa_context* c, ma_pa_sink_info_cb_t cb, void* userdata);
 typedef ma_pa_operation*         (* ma_pa_context_get_source_info_list_proc)   (ma_pa_context* c, ma_pa_source_info_cb_t cb, void* userdata);
 typedef ma_pa_operation*         (* ma_pa_context_get_sink_info_by_name_proc)  (ma_pa_context* c, const char* name, ma_pa_sink_info_cb_t cb, void* userdata);
 typedef ma_pa_operation*         (* ma_pa_context_get_source_info_by_name_proc)(ma_pa_context* c, const char* name, ma_pa_source_info_cb_t cb, void* userdata);
 typedef void                     (* ma_pa_operation_unref_proc)                (ma_pa_operation* o);
+typedef void                     (* ma_pa_operation_cancel_proc)                (ma_pa_operation* o);
 typedef ma_pa_operation_state_t  (* ma_pa_operation_get_state_proc)            (const ma_pa_operation* o);
 typedef ma_pa_channel_map*       (* ma_pa_channel_map_init_extend_proc)        (ma_pa_channel_map* m, unsigned channels, ma_pa_channel_map_def_t def);
 typedef int                      (* ma_pa_channel_map_valid_proc)              (const ma_pa_channel_map* m);
@@ -30927,6 +30973,7 @@ typedef const ma_pa_sample_spec* (* ma_pa_stream_get_sample_spec_proc)         (
 typedef const ma_pa_channel_map* (* ma_pa_stream_get_channel_map_proc)         (ma_pa_stream* s);
 typedef const ma_pa_buffer_attr* (* ma_pa_stream_get_buffer_attr_proc)         (ma_pa_stream* s);
 typedef ma_pa_operation*         (* ma_pa_stream_set_buffer_attr_proc)         (ma_pa_stream* s, const ma_pa_buffer_attr* attr, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef int                     (* ma_pa_stream_get_latency_proc)(const ma_pa_stream* s, ma_uint64* usec, int* negative);
 typedef const char*              (* ma_pa_stream_get_device_name_proc)         (const ma_pa_stream* s);
 typedef void                     (* ma_pa_stream_set_write_callback_proc)      (ma_pa_stream* s, ma_pa_stream_request_cb_t cb, void* userdata);
 typedef void                     (* ma_pa_stream_set_read_callback_proc)       (ma_pa_stream* s, ma_pa_stream_request_cb_t cb, void* userdata);
@@ -30939,6 +30986,7 @@ typedef int                      (* ma_pa_stream_is_corked_proc)               (
 typedef ma_pa_operation*         (* ma_pa_stream_cork_proc)                    (ma_pa_stream* s, int b, ma_pa_stream_success_cb_t cb, void* userdata);
 typedef ma_pa_operation*         (* ma_pa_stream_trigger_proc)                 (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
 typedef int                      (* ma_pa_stream_begin_write_proc)             (ma_pa_stream* s, void** data, size_t* nbytes);
+typedef int                      (* ma_pa_stream_cancel_write_proc)            (ma_pa_stream* s);
 typedef int                      (* ma_pa_stream_write_proc)                   (ma_pa_stream* s, const void* data, size_t nbytes, ma_pa_free_cb_t free_cb, int64_t offset, ma_pa_seek_mode_t seek);
 typedef int                      (* ma_pa_stream_peek_proc)                    (ma_pa_stream* s, const void** data, size_t* nbytes);
 typedef int                      (* ma_pa_stream_drop_proc)                    (ma_pa_stream* s);
@@ -31126,23 +31174,49 @@ static ma_pa_channel_position_t ma_channel_position_to_pulse(ma_channel position
 }
 #endif
 
-static ma_result ma_wait_for_operation__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_pa_operation* pOP)
+#ifndef MA_PULSE_WAIT_TIMEOUT_MS
+#define MA_PULSE_WAIT_TIMEOUT_MS 1000
+#endif
+
+static ma_result ma_pulse_wait_step(ma_context* pContext, ma_ptr pMainLoop, ma_timer* pTimer, const char* operation)
 {
     int resultPA;
+    if (ma_timer_get_time_in_seconds(pTimer) * 1000 >= MA_PULSE_WAIT_TIMEOUT_MS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR,
+                     "[PulseAudio] %s timed out after %d ms.\n", operation, MA_PULSE_WAIT_TIMEOUT_MS);
+        return MA_TIMEOUT;
+    }
+    resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 0, NULL);
+    if (resultPA < 0) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] %s iterate failed: %d.\n", operation, resultPA);
+        return ma_result_from_pulse(resultPA);
+    }
+    if (resultPA == 0) ma_sleep(1);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wait_for_operation__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_pa_operation* pOP)
+{
+    ma_result result;
+    ma_timer timer;
     ma_pa_operation_state_t state;
 
     MA_ASSERT(pContext != NULL);
     MA_ASSERT(pOP != NULL);
 
+    ma_timer_init(&timer);
     for (;;) {
         state = ((ma_pa_operation_get_state_proc)pContext->pulse.pa_operation_get_state)(pOP);
+        if (state == MA_PA_OPERATION_DONE) return MA_SUCCESS;
         if (state != MA_PA_OPERATION_RUNNING) {
-            break;  /* Done. */
+            ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Operation cancelled.\n");
+            return MA_ERROR;
         }
 
-        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
-        if (resultPA < 0) {
-            return ma_result_from_pulse(resultPA);
+        result = ma_pulse_wait_step(pContext, pMainLoop, &timer, "wait");
+        if (result != MA_SUCCESS) {
+            ((ma_pa_operation_cancel_proc)pContext->pulse.pa_operation_cancel)(pOP);
+            return result;
         }
     }
 
@@ -31165,9 +31239,11 @@ static ma_result ma_wait_for_operation_and_unref__pulse(ma_context* pContext, ma
 
 static ma_result ma_wait_for_pa_context_to_connect__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_ptr pPulseContext)
 {
-    int resultPA;
+    ma_result result;
+    ma_timer timer;
     ma_pa_context_state_t state;
 
+    ma_timer_init(&timer);
     for (;;) {
         state = ((ma_pa_context_get_state_proc)pContext->pulse.pa_context_get_state)((ma_pa_context*)pPulseContext);
         if (state == MA_PA_CONTEXT_READY) {
@@ -31179,10 +31255,8 @@ static ma_result ma_wait_for_pa_context_to_connect__pulse(ma_context* pContext,
             return MA_ERROR;
         }
 
-        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
-        if (resultPA < 0) {
-            return ma_result_from_pulse(resultPA);
-        }
+        result = ma_pulse_wait_step(pContext, pMainLoop, &timer, "context connect");
+        if (result != MA_SUCCESS) return result;
     }
 
     /* Should never get here. */
@@ -31191,9 +31265,11 @@ static ma_result ma_wait_for_pa_context_to_connect__pulse(ma_context* pContext,
 
 static ma_result ma_wait_for_pa_stream_to_connect__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_ptr pStream)
 {
-    int resultPA;
+    ma_result result;
+    ma_timer timer;
     ma_pa_stream_state_t state;
 
+    ma_timer_init(&timer);
     for (;;) {
         state = ((ma_pa_stream_get_state_proc)pContext->pulse.pa_stream_get_state)((ma_pa_stream*)pStream);
         if (state == MA_PA_STREAM_READY) {
@@ -31205,10 +31281,8 @@ static ma_result ma_wait_for_pa_stream_to_connect__pulse(ma_context* pContext, m
             return MA_ERROR;
         }
 
-        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
-        if (resultPA < 0) {
-            return ma_result_from_pulse(resultPA);
-        }
+        result = ma_pulse_wait_step(pContext, pMainLoop, &timer, "stream connect");
+        if (result != MA_SUCCESS) return result;
     }
 
     return MA_SUCCESS;
@@ -31382,10 +31456,13 @@ static ma_result ma_context_get_default_device_index__pulse(ma_context* pContext
 
     if (deviceType == ma_device_type_playback) {
         ma_pa_sink_info sinkInfo;
+        MA_ZERO_OBJECT(&sinkInfo);
+        sinkInfo.index = (ma_uint32)-1;
         result = ma_context_get_sink_info__pulse(pContext, NULL, &sinkInfo);
         if (result != MA_SUCCESS) {
             return result;
         }
+        if (sinkInfo.index == (ma_uint32)-1) return MA_NO_DEVICE;
 
         if (pIndex != NULL) {
             *pIndex = sinkInfo.index;
@@ -31394,10 +31471,13 @@ static ma_result ma_context_get_default_device_index__pulse(ma_context* pContext
 
     if (deviceType == ma_device_type_capture) {
         ma_pa_source_info sourceInfo;
+        MA_ZERO_OBJECT(&sourceInfo);
+        sourceInfo.index = (ma_uint32)-1;
         result = ma_context_get_source_info__pulse(pContext, NULL, &sourceInfo);
         if (result != MA_SUCCESS) {
             return result;
         }
+        if (sourceInfo.index == (ma_uint32)-1) return MA_NO_DEVICE;
 
         if (pIndex != NULL) {
             *pIndex = sourceInfo.index;
@@ -31551,7 +31631,7 @@ static void ma_context_get_device_info_sink_callback__pulse(ma_pa_context* pPuls
 {
     ma_context_get_device_info_callback_data__pulse* pData = (ma_context_get_device_info_callback_data__pulse*)pUserData;
 
-    if (endOfList > 0) {
+    if (endOfList != 0 || pInfo == NULL) {
         return;
     }
 
@@ -31588,7 +31668,7 @@ static void ma_context_get_device_info_source_callback__pulse(ma_pa_context* pPu
 {
     ma_context_get_device_info_callback_data__pulse* pData = (ma_context_get_device_info_callback_data__pulse*)pUserData;
 
-    if (endOfList > 0) {
+    if (endOfList != 0 || pInfo == NULL) {
         return;
     }
 
@@ -31640,6 +31720,7 @@ static ma_result ma_context_get_device_info__pulse(ma_context* pContext, ma_devi
     }
 
     result = ma_context_get_default_device_index__pulse(pContext, deviceType, &callbackData.defaultDeviceIndex);
+    if (result != MA_SUCCESS) return result;
 
     if (deviceType == ma_device_type_playback) {
         pOP = ((ma_pa_context_get_sink_info_by_name_proc)pContext->pulse.pa_context_get_sink_info_by_name)((ma_pa_context*)(pContext->pulse.pPulseContext), pDeviceName, ma_context_get_device_info_sink_callback__pulse, &callbackData);
@@ -31648,7 +31729,8 @@ static ma_result ma_context_get_device_info__pulse(ma_context* pContext, ma_devi
     }
 
     if (pOP != NULL) {
-        ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+        result = ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+        if (result != MA_SUCCESS) goto done;
     } else {
         result = MA_ERROR;
         goto done;
@@ -31747,6 +31829,7 @@ static void ma_device_on_read__pulse(ma_pa_stream* pStream, size_t byteCount, vo
     MA_ASSERT(bpf > 0);
 
     frameCount = byteCount / bpf;
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_READ, frameCount, deviceState);
     framesProcessed = 0;
 
     while (ma_device_get_state(pDevice) == ma_device_state_started && framesProcessed < frameCount) {
@@ -31756,6 +31839,7 @@ static void ma_device_on_read__pulse(ma_pa_stream* pStream, size_t byteCount, vo
 
         int pulseResult = ((ma_pa_stream_peek_proc)pDevice->pContext->pulse.pa_stream_peek)(pStream, &pMappedPCMFrames, &bytesMapped);
         if (pulseResult < 0) {
+            MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_READ, 1, pulseResult);
             break; /* Failed to map. Abort. */
         }
 
@@ -31764,12 +31848,25 @@ static void ma_device_on_read__pulse(ma_pa_stream* pStream, size_t byteCount, vo
             if (pMappedPCMFrames != NULL) {
                 ma_device_handle_backend_data_callback(pDevice, NULL, pMappedPCMFrames, framesMapped);
             } else {
-                /* It's a hole. */
-                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[PulseAudio] ma_device_on_read__pulse: Hole.\n");
+                MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_HOLE, AUDIO_DIAG_READ, framesMapped, 0);
+                ma_uint8 silence[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                ma_uint64 remaining = framesMapped;
+                ma_uint32 capacity = sizeof(silence) / bpf;
+                ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_capture_overrun));
+                ma_silence_pcm_frames(silence, capacity, pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+                while (remaining > 0 && ma_device_get_state(pDevice) == ma_device_state_started) {
+                    ma_uint32 n = (ma_uint32)ma_min(remaining, capacity);
+#ifdef MA_AUDIO_CAPTURE_HOLE
+                    MA_AUDIO_CAPTURE_HOLE(framesMapped - remaining);
+#endif
+                    ma_device_handle_backend_data_callback(pDevice, NULL, silence, n);
+                    remaining -= n;
+                }
             }
 
             pulseResult = ((ma_pa_stream_drop_proc)pDevice->pContext->pulse.pa_stream_drop)(pStream);
             if (pulseResult < 0) {
+                MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_READ, 1, pulseResult);
                 break;  /* Failed to drop the buffer. */
             }
 
@@ -31780,6 +31877,7 @@ static void ma_device_on_read__pulse(ma_pa_stream* pStream, size_t byteCount, vo
             break;
         }
     }
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_READ, framesProcessed, 0);
 }
 
 static ma_result ma_device_write_to_stream__pulse(ma_device* pDevice, ma_pa_stream* pStream, ma_uint64* pFramesProcessed)
@@ -31798,6 +31896,7 @@ static ma_result ma_device_write_to_stream__pulse(ma_device* pDevice, ma_pa_stre
 
     deviceState = ma_device_get_state(pDevice);
 
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_MAP, 0, deviceState);
     bytesMapped = ((ma_pa_stream_writable_size_proc)pDevice->pContext->pulse.pa_stream_writable_size)(pStream);
     if (bytesMapped != (size_t)-1) {
         if (bytesMapped > 0) {
@@ -31810,15 +31909,23 @@ static ma_result ma_device_write_to_stream__pulse(ma_device* pDevice, ma_pa_stre
             }
 
             framesMapped = bytesMapped / bpf;
+            if (framesMapped == 0 || pMappedPCMFrames == NULL) {
+                ((ma_pa_stream_cancel_write_proc)pDevice->pContext->pulse.pa_stream_cancel_write)(pStream);
+                result = MA_ERROR;
+                goto done;
+            }
+            MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_MAP, framesMapped, 0);
 
             if (deviceState == ma_device_state_started || deviceState == ma_device_state_starting) {  /* Check for starting state just in case this is being used to do the initial fill. */
                 ma_device_handle_backend_data_callback(pDevice, pMappedPCMFrames, NULL, framesMapped);
             } else {
                 /* Device is not started. Write silence. */
-                ma_silence_pcm_frames(pMappedPCMFrames, framesMapped, pDevice->playback.format, pDevice->playback.channels);
+                ma_silence_pcm_frames(pMappedPCMFrames, framesMapped, pDevice->playback.internalFormat, pDevice->playback.internalChannels);
             }
 
+            MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_SUBMIT, framesMapped, 0);
             pulseResult = ((ma_pa_stream_write_proc)pDevice->pContext->pulse.pa_stream_write)(pStream, pMappedPCMFrames, bytesMapped, NULL, 0, MA_PA_SEEK_RELATIVE);
+            MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_SUBMIT, framesMapped, pulseResult);
             if (pulseResult < 0) {
                 result = ma_result_from_pulse(pulseResult);
                 goto done;  /* Failed to write data to stream. */
@@ -31835,6 +31942,10 @@ static ma_result ma_device_write_to_stream__pulse(ma_device* pDevice, ma_pa_stre
     }
 
 done:
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_MAP, framesProcessed, result);
+    if (result != MA_SUCCESS) {
+        MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_WRITE, 1, result);
+    }
     if (pFramesProcessed != NULL) {
         *pFramesProcessed = framesProcessed;
     }
@@ -31850,6 +31961,7 @@ static void ma_device_on_write__pulse(ma_pa_stream* pStream, size_t byteCount, v
     ma_uint64 framesProcessed;
     ma_uint32 deviceState;
     ma_result result;
+    ma_bool32 diagnosticNoProgress = MA_FALSE;
 
     MA_ASSERT(pDevice != NULL);
 
@@ -31866,6 +31978,7 @@ static void ma_device_on_write__pulse(ma_pa_stream* pStream, size_t byteCount, v
     MA_ASSERT(bpf > 0);
 
     frameCount = byteCount / bpf;
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_WRITE, frameCount, deviceState);
     framesProcessed = 0;
 
     while (framesProcessed < frameCount) {
@@ -31882,8 +31995,14 @@ static void ma_device_on_write__pulse(ma_pa_stream* pStream, size_t byteCount, v
             break;
         }
 
+        if (framesProcessedThisIteration == 0 && !diagnosticNoProgress) {
+            MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_NO_PROGRESS, AUDIO_DIAG_WRITE, 1, frameCount - framesProcessed);
+            diagnosticNoProgress = MA_TRUE;
+        }
+        if (framesProcessedThisIteration == 0) break;
         framesProcessed += framesProcessedThisIteration;
     }
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_WRITE, framesProcessed, 0);
 }
 
 static void ma_device_on_suspended__pulse(ma_pa_stream* pStream, void* pUserData)
@@ -31902,10 +32021,10 @@ static void ma_device_on_suspended__pulse(ma_pa_stream* pStream, void* pUserData
 
     if (suspended == 1) {
         ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. Suspended.\n");
-        ma_device__on_notification_stopped(pDevice);
+        ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_interruption_began));
     } else {
         ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. Resumed.\n");
-        ma_device__on_notification_started(pDevice);
+        ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_interruption_ended));
     }
 }
 
@@ -32044,7 +32163,7 @@ static ma_result ma_device_init__pulse(ma_device* pDevice, const ma_device_confi
         if (pDescriptorCapture->sampleRate != 0) {
             ss.rate = pDescriptorCapture->sampleRate;
         }
-        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY;
+        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY | MA_PA_STREAM_AUTO_TIMING_UPDATE | MA_PA_STREAM_INTERPOLATE_TIMING;
 
         if (ma_format_from_pulse(ss.format) == ma_format_unknown) {
             if (ma_is_little_endian()) {
@@ -32203,7 +32322,7 @@ static ma_result ma_device_init__pulse(ma_device* pDevice, const ma_device_confi
             ss.rate = pDescriptorPlayback->sampleRate;
         }
 
-        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY;
+        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY | MA_PA_STREAM_AUTO_TIMING_UPDATE | MA_PA_STREAM_INTERPOLATE_TIMING;
         if (ma_format_from_pulse(ss.format) == ma_format_unknown) {
             if (ma_is_little_endian()) {
                 ss.format = MA_PA_SAMPLE_FLOAT32LE;
@@ -32375,6 +32494,10 @@ on_error1:
         ((ma_pa_stream_unref_proc)pDevice->pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
     }
 on_error0:
+    ((ma_pa_context_disconnect_proc)pDevice->pContext->pulse.pa_context_disconnect)((ma_pa_context*)pDevice->pulse.pPulseContext);
+    ((ma_pa_context_unref_proc)pDevice->pContext->pulse.pa_context_unref)((ma_pa_context*)pDevice->pulse.pPulseContext);
+    ((ma_pa_mainloop_free_proc)pDevice->pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)pDevice->pulse.pMainLoop);
+    MA_ZERO_OBJECT(&pDevice->pulse);
     return result;
 }
 
@@ -32504,8 +32627,24 @@ static ma_result ma_device_data_loop__pulse(ma_device* pDevice)
     the callbacks deal with it.
     */
     while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        ma_pa_context_state_t contextState = ((ma_pa_context_get_state_proc)pDevice->pContext->pulse.pa_context_get_state)((ma_pa_context*)pDevice->pulse.pPulseContext);
+        ma_pa_stream_state_t captureState = pDevice->pulse.pStreamCapture ?
+            ((ma_pa_stream_get_state_proc)pDevice->pContext->pulse.pa_stream_get_state)((ma_pa_stream*)pDevice->pulse.pStreamCapture) : MA_PA_STREAM_READY;
+        ma_pa_stream_state_t playbackState = pDevice->pulse.pStreamPlayback ?
+            ((ma_pa_stream_get_state_proc)pDevice->pContext->pulse.pa_stream_get_state)((ma_pa_stream*)pDevice->pulse.pStreamPlayback) : MA_PA_STREAM_READY;
+        if (contextState == MA_PA_CONTEXT_FAILED || contextState == MA_PA_CONTEXT_TERMINATED ||
+            captureState == MA_PA_STREAM_FAILED || captureState == MA_PA_STREAM_TERMINATED ||
+            playbackState == MA_PA_STREAM_FAILED || playbackState == MA_PA_STREAM_TERMINATED) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR,
+                         "[PulseAudio] Device failed context=%d capture=%d playback=%d errno=%d.\n", contextState, captureState,
+                         playbackState, ((ma_pa_context_errno_proc)pDevice->pContext->pulse.pa_context_errno)((ma_pa_context*)pDevice->pulse.pPulseContext));
+            return MA_ERROR;
+        }
+        MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ENTER, AUDIO_DIAG_LOOP, 0, 0);
         resultPA = ((ma_pa_mainloop_iterate_proc)pDevice->pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pDevice->pulse.pMainLoop, 1, NULL);
+        MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_LEAVE, AUDIO_DIAG_LOOP, 0, resultPA);
         if (resultPA < 0) {
+            MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_ERROR, AUDIO_DIAG_LOOP, 1, resultPA);
             break;
         }
     }
@@ -32588,11 +32727,13 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     pContext->pulse.pa_context_disconnect              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_disconnect");
     pContext->pulse.pa_context_set_state_callback      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_set_state_callback");
     pContext->pulse.pa_context_get_state               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_state");
+    pContext->pulse.pa_context_errno                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_errno");
     pContext->pulse.pa_context_get_sink_info_list      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_sink_info_list");
     pContext->pulse.pa_context_get_source_info_list    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_source_info_list");
     pContext->pulse.pa_context_get_sink_info_by_name   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_sink_info_by_name");
     pContext->pulse.pa_context_get_source_info_by_name = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_source_info_by_name");
     pContext->pulse.pa_operation_unref                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_unref");
+    pContext->pulse.pa_operation_cancel                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_cancel");
     pContext->pulse.pa_operation_get_state             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_get_state");
     pContext->pulse.pa_channel_map_init_extend         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_init_extend");
     pContext->pulse.pa_channel_map_valid               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_valid");
@@ -32607,6 +32748,7 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     pContext->pulse.pa_stream_get_channel_map          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_channel_map");
     pContext->pulse.pa_stream_get_buffer_attr          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_buffer_attr");
     pContext->pulse.pa_stream_set_buffer_attr          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_buffer_attr");
+    pContext->pulse.pa_stream_get_latency              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_latency");
     pContext->pulse.pa_stream_get_device_name          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_device_name");
     pContext->pulse.pa_stream_set_write_callback       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_write_callback");
     pContext->pulse.pa_stream_set_read_callback        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_read_callback");
@@ -32619,6 +32761,7 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     pContext->pulse.pa_stream_cork                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_cork");
     pContext->pulse.pa_stream_trigger                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_trigger");
     pContext->pulse.pa_stream_begin_write              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_begin_write");
+    pContext->pulse.pa_stream_cancel_write              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_cancel_write");
     pContext->pulse.pa_stream_write                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_write");
     pContext->pulse.pa_stream_peek                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_peek");
     pContext->pulse.pa_stream_drop                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_drop");
@@ -32651,11 +32794,13 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     ma_pa_context_disconnect_proc              _pa_context_disconnect             = pa_context_disconnect;
     ma_pa_context_set_state_callback_proc      _pa_context_set_state_callback     = pa_context_set_state_callback;
     ma_pa_context_get_state_proc               _pa_context_get_state              = pa_context_get_state;
+    ma_pa_context_errno_proc                   _pa_context_errno                  = pa_context_errno;
     ma_pa_context_get_sink_info_list_proc      _pa_context_get_sink_info_list     = pa_context_get_sink_info_list;
     ma_pa_context_get_source_info_list_proc    _pa_context_get_source_info_list   = pa_context_get_source_info_list;
     ma_pa_context_get_sink_info_by_name_proc   _pa_context_get_sink_info_by_name  = pa_context_get_sink_info_by_name;
     ma_pa_context_get_source_info_by_name_proc _pa_context_get_source_info_by_name= pa_context_get_source_info_by_name;
     ma_pa_operation_unref_proc                 _pa_operation_unref                = pa_operation_unref;
+    ma_pa_operation_cancel_proc                 _pa_operation_cancel                = pa_operation_cancel;
     ma_pa_operation_get_state_proc             _pa_operation_get_state            = pa_operation_get_state;
     ma_pa_channel_map_init_extend_proc         _pa_channel_map_init_extend        = pa_channel_map_init_extend;
     ma_pa_channel_map_valid_proc               _pa_channel_map_valid              = pa_channel_map_valid;
@@ -32670,6 +32815,7 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     ma_pa_stream_get_channel_map_proc          _pa_stream_get_channel_map         = pa_stream_get_channel_map;
     ma_pa_stream_get_buffer_attr_proc          _pa_stream_get_buffer_attr         = pa_stream_get_buffer_attr;
     ma_pa_stream_set_buffer_attr_proc          _pa_stream_set_buffer_attr         = pa_stream_set_buffer_attr;
+    ma_pa_stream_get_latency_proc              _pa_stream_get_latency             = pa_stream_get_latency;
     ma_pa_stream_get_device_name_proc          _pa_stream_get_device_name         = pa_stream_get_device_name;
     ma_pa_stream_set_write_callback_proc       _pa_stream_set_write_callback      = pa_stream_set_write_callback;
     ma_pa_stream_set_read_callback_proc        _pa_stream_set_read_callback       = pa_stream_set_read_callback;
@@ -32682,6 +32828,7 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     ma_pa_stream_cork_proc                     _pa_stream_cork                    = pa_stream_cork;
     ma_pa_stream_trigger_proc                  _pa_stream_trigger                 = pa_stream_trigger;
     ma_pa_stream_begin_write_proc              _pa_stream_begin_write             = pa_stream_begin_write;
+    ma_pa_stream_cancel_write_proc              _pa_stream_cancel_write             = pa_stream_cancel_write;
     ma_pa_stream_write_proc                    _pa_stream_write                   = pa_stream_write;
     ma_pa_stream_peek_proc                     _pa_stream_peek                    = pa_stream_peek;
     ma_pa_stream_drop_proc                     _pa_stream_drop                    = pa_stream_drop;
@@ -32713,11 +32860,13 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     pContext->pulse.pa_context_disconnect              = (ma_proc)_pa_context_disconnect;
     pContext->pulse.pa_context_set_state_callback      = (ma_proc)_pa_context_set_state_callback;
     pContext->pulse.pa_context_get_state               = (ma_proc)_pa_context_get_state;
+    pContext->pulse.pa_context_errno                   = (ma_proc)_pa_context_errno;
     pContext->pulse.pa_context_get_sink_info_list      = (ma_proc)_pa_context_get_sink_info_list;
     pContext->pulse.pa_context_get_source_info_list    = (ma_proc)_pa_context_get_source_info_list;
     pContext->pulse.pa_context_get_sink_info_by_name   = (ma_proc)_pa_context_get_sink_info_by_name;
     pContext->pulse.pa_context_get_source_info_by_name = (ma_proc)_pa_context_get_source_info_by_name;
     pContext->pulse.pa_operation_unref                 = (ma_proc)_pa_operation_unref;
+    pContext->pulse.pa_operation_cancel                 = (ma_proc)_pa_operation_cancel;
     pContext->pulse.pa_operation_get_state             = (ma_proc)_pa_operation_get_state;
     pContext->pulse.pa_channel_map_init_extend         = (ma_proc)_pa_channel_map_init_extend;
     pContext->pulse.pa_channel_map_valid               = (ma_proc)_pa_channel_map_valid;
@@ -32732,6 +32881,7 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     pContext->pulse.pa_stream_get_channel_map          = (ma_proc)_pa_stream_get_channel_map;
     pContext->pulse.pa_stream_get_buffer_attr          = (ma_proc)_pa_stream_get_buffer_attr;
     pContext->pulse.pa_stream_set_buffer_attr          = (ma_proc)_pa_stream_set_buffer_attr;
+    pContext->pulse.pa_stream_get_latency              = (ma_proc)_pa_stream_get_latency;
     pContext->pulse.pa_stream_get_device_name          = (ma_proc)_pa_stream_get_device_name;
     pContext->pulse.pa_stream_set_write_callback       = (ma_proc)_pa_stream_set_write_callback;
     pContext->pulse.pa_stream_set_read_callback        = (ma_proc)_pa_stream_set_read_callback;
@@ -32744,6 +32894,7 @@ static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_c
     pContext->pulse.pa_stream_cork                     = (ma_proc)_pa_stream_cork;
     pContext->pulse.pa_stream_trigger                  = (ma_proc)_pa_stream_trigger;
     pContext->pulse.pa_stream_begin_write              = (ma_proc)_pa_stream_begin_write;
+    pContext->pulse.pa_stream_cancel_write              = (ma_proc)_pa_stream_cancel_write;
     pContext->pulse.pa_stream_write                    = (ma_proc)_pa_stream_write;
     pContext->pulse.pa_stream_peek                     = (ma_proc)_pa_stream_peek;
     pContext->pulse.pa_stream_drop                     = (ma_proc)_pa_stream_drop;
@@ -43767,6 +43918,7 @@ MA_API ma_result ma_device_init(ma_context* pContext, const ma_device_config* pC
 
     result = pContext->callbacks.onDeviceInit(pDevice, pConfig, &descriptorPlayback, &descriptorCapture);
     if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->stopEvent);
         ma_event_uninit(&pDevice->startEvent);
         ma_event_uninit(&pDevice->wakeupEvent);
         ma_mutex_uninit(&pDevice->startStopLock);
@@ -44008,6 +44160,8 @@ MA_API ma_result ma_device_init(ma_context* pContext, const ma_device_config* pC
         }
     }
 
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_OPEN, -1, pDevice->type, pDevice->sampleRate);
+    MA_DIAGNOSTIC_DEVICE_INIT(pDevice);
     MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
     return MA_SUCCESS;
 }
@@ -44175,6 +44329,7 @@ MA_API void ma_device_uninit(ma_device* pDevice)
         ma_free(pDevice->pContext, &allocationCallbacks);
     }
 
+    MA_DIAGNOSTIC_EVENT(pDevice, AUDIO_DIAG_CLOSE, -1, 0, 0);
     MA_ZERO_OBJECT(pDevice);
 }
 
@@ -44506,6 +44661,14 @@ MA_API ma_result ma_device_handle_backend_data_callback(ma_device* pDevice, void
     if (frameCount == 0) {
         return MA_INVALID_ARGS;
     }
+    if (((pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_loopback) && pInput == NULL) ||
+        (pDevice->type == ma_device_type_playback && pOutput == NULL)) {
+        return MA_INVALID_ARGS;
+    }
+
+#ifdef MA_AUDIO_TIMING_BEGIN
+    MA_AUDIO_TIMING_BEGIN(pDevice, frameCount, pInput != NULL);
+#endif
 
     if (pDevice->type == ma_device_type_duplex) {
         if (pInput != NULL) {
@@ -44517,22 +44680,17 @@ MA_API ma_result ma_device_handle_backend_data_callback(ma_device* pDevice, void
         }
     } else {
         if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_loopback) {
-            if (pInput == NULL) {
-                return MA_INVALID_ARGS;
-            }
-
             ma_device__send_frames_to_client(pDevice, frameCount, pInput);
         }
 
         if (pDevice->type == ma_device_type_playback) {
-            if (pOutput == NULL) {
-                return MA_INVALID_ARGS;
-            }
-
             ma_device__read_frames_from_client(pDevice, frameCount, pOutput);
         }
     }
 
+#ifdef MA_AUDIO_TIMING_END
+    MA_AUDIO_TIMING_END();
+#endif
     return MA_SUCCESS;
 }
 

lib/opus_codec.c

@@ -146,6 +146,23 @@ int opus_codec_encoder_signal_set(opus_codec_encoder_t* enc, int signal_type) {
     return opus_encoder_ctl(enc->opus_enc, OPUS_SET_SIGNAL(signal_type));
 }
 
+int opus_codec_encoder_application_set(opus_codec_encoder_t* enc, int application) {
+    if (!enc || !enc->opus_enc) return -1;
+    return opus_encoder_ctl(enc->opus_enc, OPUS_SET_APPLICATION(application));
+}
+
+int opus_codec_encoder_delay(opus_codec_encoder_t* enc, int* samples) {
+    if (!enc || !samples) { DEBUG_ERROR(DEBUG_CATEGORY_CALL, "Opus delay invalid arguments"); return -1; }
+    opus_int32 delay = 0;
+    int result = opus_encoder_ctl(enc->opus_enc, OPUS_GET_LOOKAHEAD(&delay));
+    if (result != OPUS_OK || delay < 0 || delay > enc->sample_rate) {
+        DEBUG_ERROR(DEBUG_CATEGORY_CALL, "Opus delay query failed result=%d samples=%d", result, (int)delay); return -1;
+    }
+    *samples = delay;
+    DEBUG_DEBUG(DEBUG_CATEGORY_CALL, "Opus capture delay samples=%d rate=%d", (int)delay, enc->sample_rate);
+    return 0;
+}
+
 const char* opus_codec_strerror(int err) {
     switch (err) {
     case OPUS_OK: return "OK";

lib/opus_codec.h

@@ -1,3 +1,9 @@
+/* opus_codec — владеющие обёртки encoder/decoder libopus для int16 interleaved PCM.
+ * create принимает частоту и 1/2 канала; неположительная частота → 48000, неверные каналы → моно.
+ * Encoder/decoder имеют состояние потока; каждому нужен один последовательный владелец.
+ * frame_samples — отсчёты НА КАНАЛ: PCM вмещает frame_samples*channels элементов.
+ * encode возвращает байты Opus, decode — отсчёты на канал; отрицательное значение означает ошибку.
+ * out_cap — байты; decode с data=NULL/len=0 использует PLC libopus. Освобождение — соответствующим destroy. */
 #ifndef OPUS_CODEC_H
 #define OPUS_CODEC_H
 
@@ -10,6 +16,10 @@ extern "C" {
 typedef struct opus_codec_encoder opus_codec_encoder_t;
 typedef struct opus_codec_decoder opus_codec_decoder_t;
 
+/* Режим кодирования Opus: голос (VOIP, default) или музыка (AUDIO). */
+#define OPUS_CODEC_APP_VOIP  2048   /* OPUS_APPLICATION_VOIP */
+#define OPUS_CODEC_APP_AUDIO 2049   /* OPUS_APPLICATION_AUDIO */
+
 opus_codec_encoder_t* opus_codec_encoder_create(int sample_rate, int channels);
 void opus_codec_encoder_destroy(opus_codec_encoder_t* enc);
 int opus_codec_encode(opus_codec_encoder_t* enc, const int16_t* pcm, int frame_samples,
@@ -23,6 +33,9 @@ int opus_codec_decode(opus_codec_decoder_t* dec, const uint8_t* data, int len,
 int opus_codec_encoder_bitrate_set(opus_codec_encoder_t* enc, int bitrate_bps);
 int opus_codec_encoder_complexity_set(opus_codec_encoder_t* enc, int complexity);
 int opus_codec_encoder_signal_set(opus_codec_encoder_t* enc, int signal_type);
+int opus_codec_encoder_application_set(opus_codec_encoder_t* enc, int application);
+/* Задержка codec в сэмплах на канал; запрашивать после настройки encoder, не задавать константой. */
+int opus_codec_encoder_delay(opus_codec_encoder_t* enc, int* samples);
 
 const char* opus_codec_strerror(int err);
 

lib/platform_compat.c

@@ -39,6 +39,25 @@
     #endif
 #endif
 
+/*
+ * Классифицирует IPv4-адрес (network byte order):
+ * 1 = глобальный/публичный (маршрутизируемый в интернете),
+ * 0 = приватный, CGNAT, loopback, link-local, multicast или зарезервированный.
+ */
+int ip_is_public(uint32_t addr_be) {
+    uint32_t a = ntohl(addr_be);
+    if ((a & 0xFF000000u) == 0x0A000000u) return 0;       /* 10.0.0.0/8     */
+    if ((a & 0xFFF00000u) == 0xAC100000u) return 0;       /* 172.16.0.0/12  */
+    if ((a & 0xFFFF0000u) == 0xC0A80000u) return 0;       /* 192.168.0.0/16 */
+    if ((a & 0xFF000000u) == 0x7F000000u) return 0;       /* 127.0.0.0/8    */
+    if ((a & 0xFFFF0000u) == 0xA9FE0000u) return 0;       /* 169.254.0.0/16 */
+    if ((a & 0xFF000000u) == 0x00000000u) return 0;       /* 0.0.0.0/8      */
+    if ((a & 0xF0000000u) == 0xE0000000u) return 0;       /* 224.0.0.0/4    */
+    if ((a & 0xF0000000u) == 0xF0000000u) return 0;       /* 240.0.0.0/4    */
+    if ((a & 0xFFC00000u) == 0x64400000u) return 0;       /* 100.64.0.0/10 (CGNAT) */
+    return 1;
+}
+
 /*
  * Generate cryptographically secure random bytes
  * Returns 0 on success, -1 on error
@@ -60,6 +79,12 @@ int random_bytes(uint8_t *buffer, size_t len) {
 #endif
 }
 
+/* Глобальный unicast IPv6 (2000::/3). При выборе адреса интерфейса предпочитаем его
+ * ULA (fc00::/7) и link-local (fe80::/10). */
+static int ipv6_is_global_unicast(const uint8_t* a) {
+    return (a[0] & 0xe0) == 0x20;
+}
+
 #ifndef _WIN32
 uint32_t get_interface_ip_by_index(uint32_t netif_index) {
     struct ifaddrs *ifaddr, *ifa;
@@ -89,7 +114,8 @@ int get_interface_ipv6_by_index(uint32_t netif_index, int temporary, uint8_t* ad
     struct ifaddrs *ifaddr, *ifa;
     if (getifaddrs(&ifaddr) == -1) return -1;
 
-    int found = 0;
+    uint8_t global_match[16], local_match[16];
+    int has_global = 0, has_local = 0;
     for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
         if (ifa->ifa_addr == NULL) continue;
         if (ifa->ifa_name == NULL) continue;
@@ -100,20 +126,18 @@ int get_interface_ipv6_by_index(uint32_t netif_index, int temporary, uint8_t* ad
         struct sockaddr_in6* sin6 = (struct sockaddr_in6*)ifa->ifa_addr;
         if ((sin6->sin6_addr.s6_addr[0] & 0xfe) == 0xfe && sin6->sin6_addr.s6_addr[1] == 0x80) continue;
         int is_temporary = (ifa->ifa_flags & IFA_F_TEMPORARY) ? 1 : 0;
-        if (temporary && is_temporary) {
-            memcpy(addr_out, &sin6->sin6_addr, 16);
-            found = 1;
-            break;
-        }
-        if (!temporary && !is_temporary) {
-            memcpy(addr_out, &sin6->sin6_addr, 16);
-            found = 1;
-            break;
+        if ((temporary && !is_temporary) || (!temporary && is_temporary)) continue;
+        if (ipv6_is_global_unicast(sin6->sin6_addr.s6_addr)) {
+            if (!has_global) { memcpy(global_match, &sin6->sin6_addr, 16); has_global = 1; }
+        } else {
+            if (!has_local) { memcpy(local_match, &sin6->sin6_addr, 16); has_local = 1; }
         }
     }
 
     freeifaddrs(ifaddr);
-    return found ? 0 : -1;
+    if (has_global) { memcpy(addr_out, global_match, 16); return 0; }
+    if (has_local)  { memcpy(addr_out, local_match, 16);  return 0; }
+    return -1;
 }
 
 #ifdef __linux__
@@ -151,8 +175,8 @@ int get_interface_ipv6_addr_nl(uint32_t netif_index, int prefer_stable, uint8_t*
 
     if (send(nl_sock, &req, req.nlh.nlmsg_len, 0) < 0) { close(nl_sock); return -1; }
 
-    uint8_t fallback[16], stable_addr[16], temp_addr[16];
-    int has_fallback = 0, has_stable = 0, has_temp = 0;
+    uint8_t fallback[16], g_stable[16], g_temp[16], l_stable[16], l_temp[16];
+    int has_fallback = 0, has_g_stable = 0, has_g_temp = 0, has_l_stable = 0, has_l_temp = 0;
 
     char buf[8192];
     int done = 0;
@@ -181,19 +205,32 @@ int get_interface_ipv6_addr_nl(uint32_t netif_index, int prefer_stable, uint8_t*
 
             int is_temp = (ifa_flags & IFA_F_TEMPORARY) != 0;
             int is_mngtmp = (ifa_flags & IFA_F_MANAGETEMPADDR) != 0;
+            int is_global = ipv6_is_global_unicast(addr);
 
             if (!has_fallback) { memcpy(fallback, addr, 16); has_fallback = 1; }
 
-            if (!has_stable && (!is_temp || is_mngtmp)) { memcpy(stable_addr, addr, 16); has_stable = 1; }
-            if (!has_temp && is_temp && !is_mngtmp) { memcpy(temp_addr, addr, 16); has_temp = 1; }
+            if (is_global) {
+                if (!has_g_stable && (!is_temp || is_mngtmp)) { memcpy(g_stable, addr, 16); has_g_stable = 1; }
+                if (!has_g_temp && is_temp && !is_mngtmp) { memcpy(g_temp, addr, 16); has_g_temp = 1; }
+            } else {
+                if (!has_l_stable && (!is_temp || is_mngtmp)) { memcpy(l_stable, addr, 16); has_l_stable = 1; }
+                if (!has_l_temp && is_temp && !is_mngtmp) { memcpy(l_temp, addr, 16); has_l_temp = 1; }
+            }
         }
     }
     close(nl_sock);
 
-    if (prefer_stable && has_stable) { memcpy(addr_out, stable_addr, 16); return 0; }
-    if (!prefer_stable && has_temp) { memcpy(addr_out, temp_addr, 16); return 0; }
-    if (has_stable) { memcpy(addr_out, stable_addr, 16); return 0; }
-    if (has_temp) { memcpy(addr_out, temp_addr, 16); return 0; }
+    if (prefer_stable) {
+        if (has_g_stable) { memcpy(addr_out, g_stable, 16); return 0; }
+        if (has_g_temp)   { memcpy(addr_out, g_temp, 16);   return 0; }
+        if (has_l_stable) { memcpy(addr_out, l_stable, 16); return 0; }
+        if (has_l_temp)   { memcpy(addr_out, l_temp, 16);   return 0; }
+    } else {
+        if (has_g_temp)   { memcpy(addr_out, g_temp, 16);   return 0; }
+        if (has_g_stable) { memcpy(addr_out, g_stable, 16); return 0; }
+        if (has_l_temp)   { memcpy(addr_out, l_temp, 16);   return 0; }
+        if (has_l_stable) { memcpy(addr_out, l_stable, 16); return 0; }
+    }
     if (has_fallback) { memcpy(addr_out, fallback, 16); return 0; }
     return -1;
 }
@@ -335,6 +372,7 @@ int get_interface_ipv6_addr_nl(uint32_t netif_index, int prefer_stable, uint8_t*
     PIP_ADAPTER_ADDRESSES adapters = plat_win_get_adapters(AF_INET6);
     if (!adapters) return -1;
     int found = 0;
+    uint8_t local_match[16]; int has_local = 0;
     PIP_ADAPTER_ADDRESSES a = plat_win_find_adapter(adapters, netif_index);
     if (a) {
         for (PIP_ADAPTER_UNICAST_ADDRESS u = a->FirstUnicastAddress; u; u = u->Next) {
@@ -344,12 +382,12 @@ int get_interface_ipv6_addr_nl(uint32_t netif_index, int prefer_stable, uint8_t*
             { static const uint8_t lb[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
               if (memcmp(b, lb, 16) == 0) continue; }                /* loopback */
             { static const uint8_t z[16]; if (memcmp(b, z, 16) == 0) continue; } /* :: */
-            memcpy(addr_out, b, 16);
-            found = 1;
-            break;
+            if (ipv6_is_global_unicast(b)) { memcpy(addr_out, b, 16); found = 1; break; }
+            if (!has_local) { memcpy(local_match, b, 16); has_local = 1; }
         }
     }
     free(adapters);
+    if (!found && has_local) { memcpy(addr_out, local_match, 16); found = 1; }
     return found ? 0 : -1;
 }
 

lib/platform_compat.h

@@ -1,5 +1,13 @@
 /**
- * Platform compatibility layer for POSIX functions on Windows
+ * platform_compat — общие заголовки POSIX/Windows и адаптеры отсутствующих POSIX-функций.
+ * Также предоставляет криптографический random_bytes, адреса интерфейсов, выбор default route
+ * и классификацию публичных IPv4. Сокетные типы/ошибки и nonblocking API — в socket_compat.h.
+ * Подключать этот заголовок вместо прямых POSIX includes для общего кода.
+ * Windows: htobe16/32/64 и be16/32/64toh через byteswap, strcasecmp/strncasecmp через _stricmp/_strnicmp,
+ * memmem через inline-поиск (пустой образец возвращает начало), poll через WSAPoll, mkdir через _mkdir.
+ * utun_gettimeofday — календарное Unix-время (не монотонное); Windows игнорирует tz.
+ * Windows pipe — _pipe(4096, _O_BINARY). fcntl: F_GETFL возвращает 0, F_SETFL с O_NONBLOCK включает
+ * неблокирующий режим; остальные флаги игнорируются, обратное переключение этим адаптером не выполняется.
  */
 
 #ifndef PLATFORM_COMPAT_H
@@ -176,31 +184,38 @@ extern "C" {
 
 #include <stdint.h>
 
-// Generate cryptographically secure random bytes
-// Returns 0 on success, -1 on error
+// Заполняет buffer криптографическими случайными байтами: POSIX /dev/urandom, Windows BCryptGenRandom.
+// buffer не NULL, len > 0 (Windows: помещается в ULONG). 0 — всё заполнено, -1 — ошибка/неполное чтение.
 int random_bytes(uint8_t *buffer, size_t len);
 
 // Get IPv4 address of interface by its index (ifindex)
-// Returns IPv4 address in network byte order, 0 on error
+// POSIX: getifaddrs; Windows: IP Helper. Адрес в network byte order, 0 при ошибке/отсутствии адреса.
 uint32_t get_interface_ip_by_index(uint32_t netif_index);
 
 // Get IPv6 address of interface by its index (ifindex)
-// temporary=1: get temporary (privacy) IPv6, temporary=0: get permanent IPv6
+// POSIX фильтрует по IFA_F_TEMPORARY в ifa_flags, но getifaddrs не гарантирует адресные флаги;
+// для точного выбора temporary/stable на Linux использовать get_interface_ipv6_addr_nl().
+// Windows игнорирует temporary: предпочитает глобальный адрес, затем локальный, исключая link-local/loopback/::.
 // Returns 0 on success (fills addr_out with 16 bytes), -1 on error or not found
 int get_interface_ipv6_by_index(uint32_t netif_index, int temporary, uint8_t* addr_out);
 
-// Get IPv6 address using netlink (Linux-only, accurate IFA_F_* flags)
-// prefer_stable=1: prefer permanent/stable (IFA_F_MANAGETEMPADDR) over temporary
-// prefer_stable=0: prefer temporary over stable
+// Выбрать IPv6: Linux использует netlink с IFA_F_*, прочие POSIX — getifaddrs(), Windows — IP Helper.
+// POSIX: prefer_stable=1 предпочитает постоянный адрес, 0 — temporary; допускается fallback на другой тип.
+// Windows игнорирует prefer_stable, выбор как у get_interface_ipv6_by_index().
 // Returns 0 on success (fills addr_out with 16 bytes), -1 on error
 int get_interface_ipv6_addr_nl(uint32_t netif_index, int prefer_stable, uint8_t* addr_out);
 
 // Determine the interface index for the default route (outgoing traffic)
-// Creates a temp UDP socket, connects to a well-known address to force
-// kernel routing, then matches the chosen source IP to getifaddrs()
+// POSIX: UDP connect к 8.8.8.8:53 или [2001:4860:4860::8888]:53, сопоставление локального IP с getifaddrs().
+// Windows: GetBestInterfaceEx к тому же адресу. Результат — выбранный маршрут к этому адресу,
+// который может отличаться от default route при более специфичных маршрутах.
 // family: AF_INET or AF_INET6, returns ifindex (0 on failure)
 uint32_t get_default_route_netif_index(int family);
 
+// Классифицирует IPv4 (network byte order) по встроенному списку: 0 для 0/8, 10/8, 127/8, 169.254/16,
+// 172.16/12, 192.168/16, 100.64/10, 224/4 и 240/4; 1 для остальных. Это не проверка достижимости адреса.
+int ip_is_public(uint32_t addr_be);
+
 
 // Cross-platform mkdir
 #ifdef _WIN32

lib/platform_compat_doc.md

@@ -1,81 +0,0 @@
-# platform_compat — Cross-platform compatibility layer
-
-## 1. Назначение
-Унифицирует различия между POSIX (Linux/FreeBSD) и Windows (MSYS2 UCRT64) на уровне системных вызовов и типов. Предоставляет единый API для байтового порядка, строковых функций, энтропии, работы с сетевыми интерфейсами и времени. Полностью заголовочный (inline) для макросов и тривиальных обёрток, `.c` только для нетривиальных реализаций.
-
-## 2. Как пользоваться
-Подключить `"platform_compat.h"` — всё остальное разрешается автоматически в зависимости от `_WIN32`.
-
-### Байтовый порядок
-```c
-uint16_t v16 = htobe16(x);    // host → big-endian
-uint32_t v32 = be32toh(x);    // big-endian → host
-uint64_t v64 = be64toh(x);    // big-endian → host
-// На Linux использует <endian.h>, на Windows — _byteswap_*
-```
-
-### Криптостойкий random
-```c
-uint8_t salt[8];
-if (random_bytes(salt, sizeof(salt)) != 0) { /* ошибка */ }
-// Linux: /dev/urandom, Windows: BCryptGenRandom
-```
-
-### Сетевые интерфейсы
-```c
-// Определить интерфейс маршрута по умолчанию
-uint32_t ifidx = get_default_route_netif_index(AF_INET);   // или AF_INET6
-
-// Получить IPv4 адрес интерфейса по индексу
-uint32_t ipv4 = get_interface_ip_by_index(ifidx);           // network byte order
-
-// Получить IPv6 адрес (постоянный или временный)
-uint8_t ipv6[16];
-if (get_interface_ipv6_by_index(ifidx, 1, ipv6) == 0) {    // temporary=1
-    // ipv6 содержит 16 байт адреса
-}
-```
-**Windows**: `get_interface_ip_by_index`, `get_interface_ipv6_by_index`, `get_default_route_netif_index` — заглушки (возвращают 0/-1).
-
-### Время
-```c
-struct timeval tv;
-utun_gettimeofday(&tv, NULL);   // макрос: на Linux → gettimeofday, на Windows → inline-реализация
-```
-
-### Прочее
-- `strcasecmp`/`strncasecmp` — на Windows `_stricmp`/`_strnicmp`
-- `memmem` — на Windows inline-реализация `compat_memmem`
-- `pipe` — на Windows `_pipe` с `_O_BINARY`
-- `poll` — на Windows `WSAPoll`, флаги `POLLIN`/`POLLOUT` и т.д. определены если отсутствуют
-- `ssize_t` — определён если отсутствует
-- `fcntl` — на Windows упрощённая реализация только для `F_SETFL`/`O_NONBLOCK`
-- `utun_mkdir` — кроссплатформенный `mkdir`
-
-### Ограничения
-- Функции сетевых интерфейсов работают только на POSIX, на Windows — заглушки
-- `get_default_route_netif_index` создаёт временный UDP-сокет к `8.8.8.8` (IPv4) или `2001:4860:4860::8888` (IPv6) для определения интерфейса
-- Только IPv4/IPv6; `family` только `AF_INET` или `AF_INET6`
-
-## 3. API
-
-### Байтовый порядок
-| Макрос | Назначение |
-|--------|------------|
-| `htobe16(x)` / `be16toh(x)` | 16-bit host ↔ big-endian |
-| `htobe32(x)` / `be32toh(x)` | 32-bit host ↔ big-endian |
-| `htobe64(x)` / `be64toh(x)` | 64-bit host ↔ big-endian |
-
-### Основные функции
-| Функция | Назначение |
-|---------|------------|
-| `random_bytes(buffer, len)` | Криптостойкие случайные байты. 0 — успех, -1 — ошибка |
-| `get_interface_ip_by_index(ifindex)` | IPv4 адрес интерфейса в network byte order, 0 при ошибке |
-| `get_interface_ipv6_by_index(ifindex, temporary, out)` | IPv6 адрес (temporary=1 — временный privacy-адрес), 0 — успех |
-| `get_default_route_netif_index(family)` | ifindex дефолтного маршрута через connect() к внешнему IP |
-
-### Макросы-заменители (условные)
-| Макрос | Назначение |
-|--------|------------|
-| `utun_gettimeofday(tv, tz)` | gettimeofday (inline на Windows) |
-| `utun_mkdir(path, mode)` | mkdir |

lib/reed_solomon.c

@@ -0,0 +1,249 @@
+#include <string.h>
+
+#include "mem.h"
+#include "debug_config.h"
+#include "reed_solomon.h"
+
+struct rs_codec {
+    unsigned n;
+    unsigned k;
+    size_t max_block_size;
+    uint8_t gf_log[256];
+    uint8_t gf_exp[510];
+    uint8_t *generator;
+    uint8_t *work;
+    uint8_t storage[];
+};
+
+/* Умножение в GF(256) с примитивным полиномом x^8+x^4+x^3+x^2+1 (0x11d). */
+static uint8_t rs_multiply(const struct rs_codec *ctx, uint8_t a, uint8_t b) {
+    return a && b ? ctx->gf_exp[ctx->gf_log[a] + ctx->gf_log[b]] : 0;
+}
+
+/* Обратить k строк матрицы; результат — правая половина рабочей матрицы [A|I]. */
+static int rs_invert(struct rs_codec *ctx, const uint8_t *const rows[]) {
+    unsigned k = ctx->k;
+    unsigned stride = 2 * k;
+    for (unsigned i = 0; i < k; i++) {
+        uint8_t *row = ctx->work + i * stride;
+        memcpy(row, rows[i], k);
+        memset(row + k, 0, k);
+        row[k + i] = 1;
+    }
+    for (unsigned col = 0; col < k; col++) {
+        unsigned pivot = col;
+        while (pivot < k && !ctx->work[pivot * stride + col]) pivot++;
+        if (pivot == k) {
+            DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: singular matrix n=%u k=%u column=%u", ctx->n, k, col);
+            return RS_ERR_MATRIX;
+        }
+        uint8_t *row = ctx->work + col * stride;
+        if (pivot != col) {
+            uint8_t *other = ctx->work + pivot * stride;
+            for (unsigned j = 0; j < stride; j++) {
+                uint8_t tmp = row[j];
+                row[j] = other[j];
+                other[j] = tmp;
+            }
+        }
+        uint8_t inverse = ctx->gf_exp[255 - ctx->gf_log[row[col]]];
+        for (unsigned j = col; j < stride; j++) row[j] = rs_multiply(ctx, row[j], inverse);
+        for (unsigned i = 0; i < k; i++) {
+            if (i == col) continue;
+            uint8_t *other = ctx->work + i * stride;
+            uint8_t factor = other[col];
+            if (!factor) continue;
+            for (unsigned j = col; j < stride; j++) other[j] ^= rs_multiply(ctx, factor, row[j]);
+        }
+    }
+    return RS_OK;
+}
+
+/* Построить систематическую матрицу G=V*inverse(V[0:k]) в точках 2^i поля GF(256). */
+static int rs_build_generator(struct rs_codec *ctx) {
+    unsigned k = ctx->k;
+    if (ctx->n != k) {
+        const uint8_t *rows[RS_MAX_BLOCKS];
+        for (unsigned i = 0; i < ctx->n; i++) {
+            uint8_t value = 1;
+            for (unsigned j = 0; j < k; j++) {
+                ctx->generator[i * k + j] = value;
+                value = rs_multiply(ctx, value, ctx->gf_exp[i]);
+            }
+        }
+        for (unsigned i = 0; i < k; i++) rows[i] = ctx->generator + i * k;
+        int rc = rs_invert(ctx, rows);
+        if (rc != RS_OK) return rc;
+        for (unsigned i = k; i < ctx->n; i++) {
+            uint8_t result[RS_MAX_BLOCKS];
+            for (unsigned j = 0; j < k; j++) {
+                uint8_t value = 0;
+                for (unsigned t = 0; t < k; t++) {
+                    value ^= rs_multiply(ctx, ctx->generator[i * k + t], ctx->work[t * 2 * k + k + j]);
+                }
+                result[j] = value;
+            }
+            memcpy(ctx->generator + i * k, result, k);
+        }
+    }
+    memset(ctx->generator, 0, k * k);
+    for (unsigned i = 0; i < k; i++) ctx->generator[i * k + i] = 1;
+    return RS_OK;
+}
+
+/* Инициализация параметров, таблиц поля и матрицы; все рабочие данные в одной аллокации. */
+int rs_init(struct rs_codec **out, unsigned n, unsigned r, size_t block_size) {
+    if (out) *out = NULL;
+    if (!out || !n || n > RS_MAX_BLOCKS || r >= n || block_size <= RS_HEADER_SIZE || block_size > RS_MAX_BLOCK_SIZE) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: invalid init ctx=%p n=%u r=%u block_size=%zu", (void *)out, n, r, block_size);
+        return RS_ERR_INVALID_ARG;
+    }
+    unsigned k = n - r;
+    size_t bytes = sizeof(struct rs_codec) + n * k + 2 * k * k;
+    struct rs_codec *ctx = u_calloc(1, (uint32_t)bytes);
+    if (!ctx) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: allocation failed n=%u r=%u block_size=%zu bytes=%zu", n, r, block_size, bytes);
+        return RS_ERR_MEMORY;
+    }
+    ctx->n = n;
+    ctx->k = k;
+    ctx->max_block_size = block_size;
+    ctx->generator = ctx->storage;
+    ctx->work = ctx->storage + n * k;
+    unsigned value = 1;
+    for (unsigned i = 0; i < 255; i++) {
+        ctx->gf_exp[i] = (uint8_t)value;
+        ctx->gf_log[value] = (uint8_t)i;
+        value <<= 1;
+        if (value & 256) value ^= 0x11d;
+    }
+    for (unsigned i = 255; i < 510; i++) ctx->gf_exp[i] = ctx->gf_exp[i - 255];
+    int rc = rs_build_generator(ctx);
+    if (rc != RS_OK) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: generator failed n=%u k=%u rc=%d", n, k, rc);
+        u_free(ctx);
+        return rc;
+    }
+    *out = ctx;
+    DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "reed_solomon: initialized n=%u r=%u max_block_size=%zu input_capacity=%zu memory=%zu",
+               n, r, block_size, k * (block_size - RS_HEADER_SIZE), bytes);
+    return RS_OK;
+}
+
+void rs_free(struct rs_codec *ctx) {
+    if (!ctx) return;
+    DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "reed_solomon: free n=%u r=%u max_block_size=%zu", ctx->n, ctx->n - ctx->k, ctx->max_block_size);
+    u_free(ctx);
+}
+
+size_t rs_input_capacity(const struct rs_codec *ctx) {
+    if (!ctx) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: input_capacity requires a context");
+        return 0;
+    }
+    return ctx->k * (ctx->max_block_size - RS_HEADER_SIZE);
+}
+
+/* Записать заголовки и исходные субблоки, затем вычислить r проверочных субблоков. */
+int rs_encode(struct rs_codec *ctx, uint64_t seq, const uint8_t *input, size_t length,
+              uint8_t *const blocks[], size_t *block_size) {
+    if (!ctx || !input || !blocks || !block_size || !length || length > rs_input_capacity(ctx)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: invalid encode ctx=%p input=%p blocks=%p length=%zu size_out=%p",
+                    (void *)ctx, (const void *)input, (const void *)blocks, length, (void *)block_size);
+        return RS_ERR_INVALID_ARG;
+    }
+    size_t payload_size = (length + ctx->k - 1) / ctx->k;
+    for (unsigned i = 0; i < ctx->n; i++) {
+        if (!blocks[i]) {
+            DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: missing encode buffer seq=%llu subblock=%u", (unsigned long long)seq, i);
+            return RS_ERR_INVALID_ARG;
+        }
+    }
+    for (unsigned i = 0; i < ctx->n; i++) {
+        for (unsigned j = 0; j < 8; j++) blocks[i][j] = (uint8_t)(seq >> (56 - 8 * j));
+        blocks[i][8] = (uint8_t)i;
+        uint8_t *payload = blocks[i] + RS_HEADER_SIZE;
+        memset(payload, 0, payload_size);
+        if (i < ctx->k) {
+            size_t offset = i * payload_size;
+            size_t take = offset < length ? length - offset : 0;
+            if (take > payload_size) take = payload_size;
+            if (take) memcpy(payload, input + offset, take);
+            continue;
+        }
+        for (unsigned j = 0; j < ctx->k; j++) {
+            uint8_t factor = ctx->generator[i * ctx->k + j];
+            if (!factor) continue;
+            const uint8_t *source = blocks[j] + RS_HEADER_SIZE;
+            for (size_t b = 0; b < payload_size; b++) payload[b] ^= rs_multiply(ctx, factor, source[b]);
+        }
+    }
+    *block_size = RS_HEADER_SIZE + payload_size;
+    DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "reed_solomon: encoded seq=%llu n=%u r=%u length=%zu padding=%zu block_size=%zu max=%zu",
+                (unsigned long long)seq, ctx->n, ctx->n - ctx->k, length, ctx->k * payload_size - length,
+                *block_size, ctx->max_block_size);
+    return RS_OK;
+}
+
+/* Проверить всю пачку и восстановить только отсутствующие исходные субблоки. */
+int rs_decode(struct rs_codec *ctx, const uint8_t *const blocks[], size_t block_size,
+              uint8_t *output, size_t output_capacity) {
+    if (!ctx || !blocks || !output || block_size <= RS_HEADER_SIZE || block_size > ctx->max_block_size
+        || output_capacity < ctx->k * (block_size - RS_HEADER_SIZE)) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: invalid decode ctx=%p blocks=%p output=%p block_size=%zu capacity=%zu",
+                    (void *)ctx, (const void *)blocks, (void *)output, block_size, output_capacity);
+        return RS_ERR_INVALID_ARG;
+    }
+    size_t payload_size = block_size - RS_HEADER_SIZE;
+    const uint8_t *rows[RS_MAX_BLOCKS];
+    unsigned selected[RS_MAX_BLOCKS];
+    unsigned count = 0;
+    unsigned missing = 0;
+    uint64_t seq = 0;
+    for (unsigned i = 0; i < ctx->n; i++) {
+        if (!blocks[i]) {
+            if (i < ctx->k) missing++;
+            continue;
+        }
+        uint64_t block_seq = 0;
+        for (unsigned j = 0; j < 8; j++) block_seq = (block_seq << 8) | blocks[i][j];
+        if (blocks[i][8] != i || (count && block_seq != seq)) {
+            DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: invalid header slot=%u subblock=%u seq=%llu expected_seq=%llu",
+                        i, blocks[i][8], (unsigned long long)block_seq, (unsigned long long)(count ? seq : block_seq));
+            return RS_ERR_HEADER;
+        }
+        seq = block_seq;
+        if (count < ctx->k) {
+            selected[count] = i;
+            rows[count] = ctx->generator + i * ctx->k;
+        }
+        count++;
+    }
+    if (count < ctx->k) {
+        DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "reed_solomon: insufficient blocks seq=%llu received=%u required=%u n=%u",
+                    (unsigned long long)seq, count, ctx->k, ctx->n);
+        return RS_ERR_INSUFFICIENT;
+    }
+    if (missing) {
+        int rc = rs_invert(ctx, rows);
+        if (rc != RS_OK) return rc;
+    }
+    for (unsigned i = 0; i < ctx->k; i++) {
+        uint8_t *target = output + i * payload_size;
+        if (blocks[i]) {
+            memcpy(target, blocks[i] + RS_HEADER_SIZE, payload_size);
+            continue;
+        }
+        memset(target, 0, payload_size);
+        for (unsigned j = 0; j < ctx->k; j++) {
+            uint8_t factor = ctx->work[i * 2 * ctx->k + ctx->k + j];
+            if (!factor) continue;
+            const uint8_t *source = blocks[selected[j]] + RS_HEADER_SIZE;
+            for (size_t b = 0; b < payload_size; b++) target[b] ^= rs_multiply(ctx, factor, source[b]);
+        }
+        DEBUG_TRACE(DEBUG_CATEGORY_GENERAL, "reed_solomon: recovered seq=%llu subblock=%u", (unsigned long long)seq, i);
+    }
+    DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "reed_solomon: decoded seq=%llu received=%u recovered=%u output_size=%zu",
+                (unsigned long long)seq, count, missing, ctx->k * payload_size);
+    return RS_OK;
+}

lib/reed_solomon.h

@@ -0,0 +1,73 @@
+/**
+ * Reed–Solomon: кодирование и восстановление одной пачки по известным пропускам.
+ * rs_init задаёт n кодограмм, r проверочных и максимальный размер каждой кодограммы.
+ * Первые n-r кодограмм содержат исходные данные, остальные — проверочные.
+ * Формат: seq (8 байт, big-endian), subblock (1 байт), полезные данные.
+ * blocks[i] всегда соответствует subblock=i; при decode NULL обозначает пропуск.
+ * Любые n-r присутствующих кодограмм восстанавливают всю исходную пачку.
+ * Полученные данные и заголовки должны быть проверены транспортом на повреждения.
+ * Все входные/выходные буферы принадлежат вызывающему коду и не перекрываются.
+ * Кодек выделяет рабочую память только при init; один контекст используют последовательно.
+ * encode принимает действительную длину, выбирает минимальный одинаковый размер частей
+ * и дополняет хвост максимум n-r-1 нулями. Размер и исходную длину хранит вызывающий код.
+ */
+#ifndef REED_SOLOMON_H
+#define REED_SOLOMON_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RS_HEADER_SIZE 9
+#define RS_MAX_BLOCK_SIZE 4096
+#define RS_MAX_BLOCKS 255
+
+enum rs_result {
+    RS_OK = 0,
+    RS_ERR_INVALID_ARG = -1,
+    RS_ERR_MEMORY = -2,
+    RS_ERR_INSUFFICIENT = -3,
+    RS_ERR_HEADER = -4,
+    RS_ERR_MATRIX = -5
+};
+
+struct rs_codec;
+
+/* Создать кодек: 1 <= n <= 255, 0 <= r < n, 10 <= max_block_size <= 4096.
+ * ctx — выходной указатель; при ошибке *ctx=NULL. Старый контекст сначала освобождают.
+ * Возвращает RS_OK или отрицательный rs_result.
+ */
+int rs_init(struct rs_codec **ctx, unsigned n, unsigned r, size_t max_block_size);
+
+/* Освободить контекст и рабочую память; NULL допустим. */
+void rs_free(struct rs_codec *ctx);
+
+/* Максимальная длина входа encode: (n-r)*(max_block_size-RS_HEADER_SIZE).
+ * Для NULL возвращает 0 и логирует ошибку.
+ */
+size_t rs_input_capacity(const struct rs_codec *ctx);
+
+/* Читать 0 < length <= rs_input_capacity(ctx) байт input, записать n кодограмм.
+ * blocks — n ненулевых указателей на буферы ёмкостью max_block_size каждый.
+ * block_size получает RS_HEADER_SIZE+ceil(length/(n-r)); хвост за этим размером не меняется.
+ * При ошибке аргументов выходные буферы и block_size не изменяются.
+ */
+int rs_encode(struct rs_codec *ctx, uint64_t seq, const uint8_t *input, size_t length,
+              uint8_t *const blocks[], size_t *block_size);
+
+/* Восстановить (n-r)*(block_size-RS_HEADER_SIZE) байт, включая нулевой хвост.
+ * Ненулевые буферы содержат block_size байт; NULL обозначает пропуск. Размер общий для пачки.
+ * output_capacity проверяется до записи; block_size не превышает максимум контекста.
+ * Проверяет одинаковый seq и subblock=i у всех присутствующих кодограмм.
+ * Входные буферы не изменяются. При ошибке output не изменяется.
+ */
+int rs_decode(struct rs_codec *ctx, const uint8_t *const blocks[], size_t block_size,
+              uint8_t *output, size_t output_capacity);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

lib/serialize.h

@@ -22,17 +22,24 @@
  * • Все динамические данные (строки, массивы, списки) выделяются через u_malloc.
  * • При encode длина переменных полей кодируется всегда 2 байтами (uint16_t, big-endian).
  * • Для linked list в буфере сохраняется только количество узлов + сырые данные узлов
- *   (next-указатели НЕ сериализуются, они восстанавливаются при decode).
+ *   (включая байты next/padding; decode заменяет next восстановленными ссылками).
  * • serialize_decode принимает буфер БЕЗ заголовка.
- * • serialize_free освобождает ВСЮ структуру и все вложенные динамические объекты.
- * • Поля в schema.fields должны идти в порядке возрастания offset.
- * • max_size (если > 0) — жёсткий лимит размера выходного буфера.
+ * • serialize_free освобождает структуру, динамические поля схемы и узлы списков; обнуляет указатель на структуру.
+ *   Указатели внутри элементов массивов и узлов списков рекурсивно не освобождаются.
+ * • Поля кодируются в порядке schema.fields; фиксированные данные копируются без смены endian.
+ * • max_size (если > 0) — лимит encode; header при header_len > 0 обязателен.
+ * • При encode counts больше 65535 молча усекаются: сохраняются первые 65535 элементов массива/списка или байтов строки.
+ * • elem_size=1 добавляет NUL и для byte-массивов.
+ * • Linked nodes копируются целиком, без рекурсивного кодирования вложенных указателей.
+ * • Этот формат зависит от ABI сырых полей; сериализация не нормализует размер/выравнивание структур.
+ * • Схема доверенная: offsets, типы, размеры и выравнивание полей/next проверяет её автор, не decode.
+ * • Независимые операции не используют общее изменяемое состояние; доступ к одной структуре согласует владелец.
  *
  * @example
  * // 1. Описание структуры
  * typedef struct Node {
  *     uint32_t value;
- *     struct Node* next;   // next по offset = 4
+ *     struct Node* next;   // положение задаётся offsetof(Node, next)
  * } Node;
  *
  * typedef struct {
@@ -100,7 +107,7 @@ struct SerializeField {
     uint16_t offset;     ///< смещение поля в структуре
     uint8_t  elem_size;  ///< размер элемента (для fixed = размер данных, для array/linked = размер одного элемента)
     uint8_t  type;       ///< SERIALIZE_TYPE_*
-    uint16_t len_offset; ///< смещение поля-счётчика (игнорируется для type 0,1,2)
+    uint16_t len_offset; ///< type 3–5: смещение счётчика в структуре; type 6: смещение next в узле; type 0–2: игнорируется
 };
 
 /**
@@ -111,25 +118,37 @@ struct SerializeSchema {
     uint16_t struct_size; ///< размер основной структуры
     uint16_t max_size;    ///< максимальный размер сериализованных данных (0 = без ограничения)
     uint16_t header_len;  ///< длина заголовка
-    const struct SerializeField* fields;
+    const struct SerializeField* fields; ///< field_count описателей в порядке записи; схема заимствуется на время вызова
 };
 
 #define SERIALIZE_ERR_OK    0  ///< успех
-#define SERIALIZE_ERR_BUF  -1  ///< ошибка выделения памяти
+#define SERIALIZE_ERR_BUF  -1  ///< нехватка памяти; decode также: обрезанные данные или неизвестный тип поля
 #define SERIALIZE_ERR_NULL -2  ///< NULL-указатель
-#define SERIALIZE_ERR_SIZE -3  ///< превышен max_size
-#define SERIALIZE_ERR_NOTSUP -4  ///< неподдерживаемый тип
+#define SERIALIZE_ERR_SIZE -3  ///< encode: превышен max_size
+#define SERIALIZE_ERR_NOTSUP -4  ///< encode: неподдерживаемый тип поля
 
+/* Кодирует structure по schema; при header_len > 0 header указывает минимум на header_len байт.
+ * При успехе *out_buf — новый блок u_malloc (освободить u_free), *out_len — фактически записанная длина с header.
+ * Входная структура и её вложенные данные остаются у владельца. На ошибке выходные значения не меняются.
+ * Возврат: OK, NULL (обязательные аргументы), BUF (OOM), SIZE (max_size), NOTSUP (неизвестный тип).
+ * ASCIIZ требует elem_size=1; порядок fields задаёт формат, сортировка по offset не требуется. */
 int serialize_encode(const void* structure,
                      const struct SerializeSchema* schema,
                      const uint8_t* header,
                      uint8_t** out_buf,
                      size_t* out_len);
 
+/* Декодирует in_len байт БЕЗ header: передавать buf + header_len, len - header_len.
+ * При успехе *structure — новая структура с выделенными полями; очищать serialize_free с той же схемой.
+ * При ошибке частично созданные объекты освобождаются, *structure = NULL. Старый *structure не освобождает.
+ * max_size не ограничивает decode; хвост после последнего поля игнорируется.
+ * Возврат: OK, NULL (аргументы), BUF (OOM, обрезанные данные или неизвестный тип). */
 int serialize_decode(const uint8_t* in_buf, size_t in_len,
                      const struct SerializeSchema* schema,
                      void** structure);
 
+// Освобождает выделенную через u_malloc структуру, поля схемы и узлы списков, обнуляет *structure; NULL допустим.
+// Вложенные указатели внутри элементов массивов/узлов не обходит; к структуре на стеке применять нельзя.
 void serialize_free(const struct SerializeSchema* schema, void** structure);
 
 

lib/serialize_doc.md

@@ -1,117 +0,0 @@
-# Binary Serialization Library
-
-## 1. Назначение
-
-Библиотека бинарной сериализации C-структур с динамическими полями (строки, массивы, singly-linked списки) в компактный бинарный буфер и обратно. Предназначена для кодирования/декодирования сообщений сетевого протокола (контрольный сервер, синхронизация БД, обмен конфигурацией).
-
-Что сериализуется:
-- Фиксированные поля (целые, флаги, структуры) — копируются «как есть».
-- ASCIIZ-строки (`char*`) — длина определяется через `strlen`, сохраняется с терминальным нулём.
-- Динамические массивы (`uint8_t*`) — счётчик элементов в поле `UINT8`/`UINT16`/`UINT32` или ровно 1 элемент (`ARRAY_FIXED`).
-- Singly-linked списки — `next`-указатели не сериализуются, сохраняются только `count+data`.
-
-Формат: header (`header_len` байт, передаётся отдельно) + данные полей. Длина переменных полей кодируется 2 байтами (`uint16_t`, big-endian).
-
-Потокобезопасность: нет, однопоточное использование.
-
-## 2. Как пользоваться
-
-```c
-#include "../lib/serialize.h"
-
-// --- 1. Определяем структуру ---
-typedef struct Node {
-    uint32_t id;
-    struct Node *next;
-} Node;
-
-typedef struct {
-    uint8_t   version;
-    uint8_t   name_len;
-    char     *name;        // ASCIIZ (elem_size=1)
-    uint16_t  addrs_cnt;
-    uint8_t  *addrs;       // массив байт (elem_size=1)
-    Node     *list;        // linked list
-} Message;
-
-// --- 2. Описываем схему ---
-static const struct SerializeField msg_fields[] = {
-    {offsetof(Message, version), sizeof(uint8_t), SERIALIZE_TYPE_FIXED,    0},
-    {offsetof(Message, name),    1,               SERIALIZE_TYPE_ARRAY_U8,  offsetof(Message, name_len)},
-    {offsetof(Message, addrs),   1,               SERIALIZE_TYPE_ARRAY_U16, offsetof(Message, addrs_cnt)},
-    {offsetof(Message, list),    sizeof(Node),    SERIALIZE_TYPE_LINKED,    offsetof(Node, next)}
-};
-
-static const struct SerializeSchema msg_schema = {
-    .field_count = 4,
-    .struct_size = sizeof(Message),
-    .max_size    = 4096,        // 0 = без лимита
-    .header_len  = 4,           // байты заголовка (напр. версия протокола)
-    .fields      = msg_fields
-};
-
-// --- 3. Сериализация ---
-Message msg = { .version = 1, .name = "test", .name_len = 4, .list = NULL };
-msg.addrs_cnt = 2;
-msg.addrs = u_malloc(2);  msg.addrs[0] = 0xAA; msg.addrs[1] = 0xBB;
-
-uint8_t header[] = {0x01, 0x00, 0x00, 0x00};  // 4-байтный заголовок
-uint8_t *buf = NULL;
-size_t len;
-if (serialize_encode(&msg, &msg_schema, header, &buf, &len) != SERIALIZE_ERR_OK)
-    goto fail;
-
-// buf содержит: header (4) + version (1) + [len=2]name(4) + '\0' + [len=2]addrs(2)
-
-// --- 4. Десериализация (buf без заголовка!) ---
-Message *restored = NULL;
-uint8_t *data_ptr = buf + msg_schema.header_len;  // пропускаем header
-if (serialize_decode(data_ptr, len - msg_schema.header_len, &msg_schema, (void**)&restored) != SERIALIZE_ERR_OK)
-    goto fail;
-
-// restored->name == "test", restored->name_len == 4
-// restored->addrs[0] == 0xAA, restored->addrs_cnt == 2
-// restored->list == NULL  (список пуст — не падает)
-
-// --- 5. Очистка ---
-serialize_free(&msg_schema, (void**)&restored); // освобождает всё: name, addrs, list, структуру
-u_free(buf);
-```
-
-**Ключевые нюансы:**
-- Поля в `schema.fields` должны идти в порядке возрастания `offset` в структуре.
-- `serialize_decode` принимает буфер **без заголовка** — передаётся `buf + schema.header_len`.
-- `serialize_free` освобождает структуру и все вложенные динамические поля (строки, массивы, списки).
-- При ошибке `serialize_decode` **автоматически освобождает** всю частично выделенную память → `*structure = NULL`.
-- `max_size > 0` — жёсткий лимит, при превышении `SERIALIZE_ERR_SIZE`.
-- Длина переменных полей всегда 2 байта (максимум 65535 элементов).
-- ASCIIZ-строки (`elem_size=1`) сохраняются с терминальным `\0`; пустая строка → 1 байт (`\0`).
-- Для linked list поле `len_offset` указывает смещение `next`-указателя внутри узла.
-- Передавать буфер в `serialize_decode` **без заголовка** — он не знает про `header_len`.
-
-## 3. API
-
-| Функция | Назначение |
-|---------|-----------|
-| `serialize_encode(structure, schema, header, &buf, &len)` | Кодирует структуру. `header` копируется в начало `buf`. |
-| `serialize_decode(in_buf, in_len, schema, &structure)` | Декодирует буфер **без заголовка**. При ошибке всё освобождает. |
-| `serialize_free(schema, &structure)` | Рекурсивно освобождает структуру и динамические поля, затем обнуляет указатель. |
-
-**Типы полей (`SERIALIZE_TYPE_*`):**
-
-| Тип | `data` | `elem_size` | `len_offset` |
-|-----|--------|-------------|--------------|
-| `FIXED` (0) | Встроенные данные | Размер поля | Не исп. |
-| `ASCIIZ` (1) | `char*` | 1 | Не исп. (длина = `strlen`) |
-| `ARRAY_FIXED` (2) | `uint8_t*` (ровно 1 элемент) | Размер элемента | Не исп. |
-| `ARRAY_U8` (3) | `uint8_t*` | Размер элемента | Смещение `uint8_t`-счётчика |
-| `ARRAY_U16` (4) | `uint8_t*` | Размер элемента | Смещение `uint16_t`-счётчика |
-| `ARRAY_U32` (5) | `uint8_t*` | Размер элемента | Смещение `uint32_t`-счётчика |
-| `LINKED` (6) | `void*` (голова списка) | Размер узла | Смещение `next` внутри узла |
-
-**Коды возврата:**
-- `SERIALIZE_ERR_OK (0)` — успех.
-- `SERIALIZE_ERR_BUF (-1)` — ошибка выделения памяти.
-- `SERIALIZE_ERR_NULL (-2)` — NULL-указатель во входных параметрах.
-- `SERIALIZE_ERR_SIZE (-3)` — превышен `max_size`.
-- `SERIALIZE_ERR_NOTSUP (-4)` — неподдерживаемый тип поля.

lib/silero_vad.c

@@ -0,0 +1,312 @@
+#include "silero_vad.h"
+#include "debug_config.h"
+#include "mem.h"
+
+#ifdef HAVE_SILERO_VAD
+
+#include <stdio.h>
+#include <string.h>
+
+#include <onnxruntime/onnxruntime_c_api.h>
+
+#include "silero_vad_model.inc"
+
+/* Число float-элементов рекуррентного состояния модели: 2 * 1 * 128 */
+#define SILERO_VAD_STATE_COUNT 256
+/* ONNX-вход: 64 отсчёта предыдущего окна + 512 новых отсчётов @16кГц. */
+#define SILERO_VAD_CONTEXT_SAMPLES 64
+#define SILERO_VAD_INPUT_SAMPLES (SILERO_VAD_CONTEXT_SAMPLES + SILERO_VAD_WINDOW_SAMPLES)
+
+struct silero_vad {
+    const OrtApi* ort;
+    OrtEnv* env;
+    OrtSession* session;
+    OrtMemoryInfo* mem_info;
+    float state[SILERO_VAD_STATE_COUNT];   /* рекуррентное состояние между вызовами */
+    float context[SILERO_VAD_CONTEXT_SAMPLES]; /* звуковой контекст предыдущего окна */
+    uint8_t* model_data;                   /* байты .onnx, загруженные в память (для file-версии) */
+    size_t model_len;
+};
+
+/* Освободить OrtStatus и залогировать его сообщение как ошибку */
+static void vad_report_ort_error(const OrtApi* ort, OrtStatus* status, const char* what) {
+    const char* msg = ort->GetErrorMessage(status);
+    DEBUG_ERROR(DEBUG_CATEGORY_VAD, "%s: %s", what, msg ? msg : "unknown onnxruntime error");
+    ort->ReleaseStatus(status);
+}
+
+/* Прочитать файл целиком в буфер. 0 при успехе: буфер пишется в out/out_len (u_malloc). */
+static int vad_read_file(const char* path, uint8_t** out, size_t* out_len) {
+    FILE* f;
+    long size;
+    uint8_t* buf;
+
+    *out = NULL;
+    *out_len = 0;
+
+    f = fopen(path, "rb");
+    if (!f) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "vad_read_file: cannot open model '%s'", path);
+        return -1;
+    }
+    if (fseek(f, 0, SEEK_END) != 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "vad_read_file: fseek failed on '%s'", path);
+        fclose(f);
+        return -1;
+    }
+    size = ftell(f);
+    if (size <= 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "vad_read_file: empty or unreadable model '%s'", path);
+        fclose(f);
+        return -1;
+    }
+    rewind(f);
+
+    buf = (uint8_t*)u_malloc((size_t)size);
+    if (!buf) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "vad_read_file: OOM for %ld bytes", size);
+        fclose(f);
+        return -1;
+    }
+    if (fread(buf, 1, (size_t)size, f) != (size_t)size) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "vad_read_file: short read on '%s'", path);
+        u_free(buf);
+        fclose(f);
+        return -1;
+    }
+    fclose(f);
+
+    *out = buf;
+    *out_len = (size_t)size;
+    return 0;
+}
+
+/* Общая инициализация детектора из байтов модели (файл или вшитая модель).
+ * owned_buf передаётся детектору только при успехе; при ошибке остаётся у вызывающего.
+ * Для вшитой модели owned_buf == NULL, её байты не освобождаются. */
+static silero_vad_t* silero_vad_create_from_bytes(const uint8_t* data, size_t len,
+                                                  const uint8_t* owned_buf, const char* label) {
+    silero_vad_t* vad = NULL;
+    const OrtApi* ort;
+    OrtStatus* status;
+    OrtSessionOptions* opts = NULL;
+
+    if (!data || len == 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_create(%s): empty model", label);
+        return NULL;
+    }
+
+    ort = OrtGetApiBase() ? OrtGetApiBase()->GetApi(ORT_API_VERSION) : NULL;
+    if (!ort) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_create(%s): onnxruntime C API unavailable", label);
+        return NULL;
+    }
+
+    vad = (silero_vad_t*)u_calloc(1, sizeof(*vad));
+    if (!vad) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_create(%s): OOM", label);
+        return NULL;
+    }
+    vad->ort = ort;
+    vad->model_len = len;
+
+    status = ort->CreateEnv(ORT_LOGGING_LEVEL_WARNING, "utun_silero_vad", &vad->env);
+    if (status) { vad_report_ort_error(ort, status, "CreateEnv"); goto fail; }
+
+    status = ort->CreateSessionOptions(&opts);
+    if (status) { vad_report_ort_error(ort, status, "CreateSessionOptions"); goto fail; }
+    status = ort->SetIntraOpNumThreads(opts, 1);
+    if (status) { vad_report_ort_error(ort, status, "SetIntraOpNumThreads"); }
+    status = ort->SetSessionGraphOptimizationLevel(opts, ORT_ENABLE_ALL);
+    if (status) { vad_report_ort_error(ort, status, "SetSessionGraphOptimizationLevel"); }
+
+    status = ort->CreateSessionFromArray(vad->env, data, len, opts, &vad->session);
+    if (status) { vad_report_ort_error(ort, status, "CreateSessionFromArray"); goto fail; }
+
+    status = ort->CreateCpuMemoryInfo(OrtArenaAllocator, OrtMemTypeDefault, &vad->mem_info);
+    if (status) { vad_report_ort_error(ort, status, "CreateCpuMemoryInfo"); goto fail; }
+
+    ort->ReleaseSessionOptions(opts);
+    vad->model_data = (uint8_t*)owned_buf;
+
+    DEBUG_INFO(DEBUG_CATEGORY_VAD, "silero_vad_create(%s): ok bytes=%zu window=%d context=%d input=%d", label, len,
+               SILERO_VAD_WINDOW_SAMPLES, SILERO_VAD_CONTEXT_SAMPLES, SILERO_VAD_INPUT_SAMPLES);
+    return vad;
+
+fail:
+    if (opts) ort->ReleaseSessionOptions(opts);
+    silero_vad_destroy(vad);
+    return NULL;
+}
+
+silero_vad_t* silero_vad_create(const char* model_path) {
+    uint8_t* buf = NULL;
+    size_t len = 0;
+    silero_vad_t* vad;
+
+    if (!model_path || !*model_path) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_create: empty model path");
+        return NULL;
+    }
+    if (vad_read_file(model_path, &buf, &len) != 0) return NULL;
+    vad = silero_vad_create_from_bytes(buf, len, buf, model_path);
+    if (!vad) u_free(buf);
+    return vad;
+}
+
+silero_vad_t* silero_vad_create_default(void) {
+    return silero_vad_create_from_bytes(silero_vad_model_data, silero_vad_model_len, NULL, "embedded");
+}
+
+void silero_vad_destroy(silero_vad_t* vad) {
+    if (!vad) return;
+    const OrtApi* ort = vad->ort;
+    if (ort) {
+        if (vad->mem_info) ort->ReleaseMemoryInfo(vad->mem_info);
+        if (vad->session) ort->ReleaseSession(vad->session);
+        if (vad->env) ort->ReleaseEnv(vad->env);
+    }
+    if (vad->model_data) u_free(vad->model_data);
+    DEBUG_DEBUG(DEBUG_CATEGORY_VAD, "silero_vad_destroy");
+    u_free(vad);
+}
+
+void silero_vad_reset(silero_vad_t* vad) {
+    if (!vad) return;
+    memset(vad->state, 0, sizeof(vad->state));
+    memset(vad->context, 0, sizeof(vad->context));
+    DEBUG_DEBUG(DEBUG_CATEGORY_VAD, "silero_vad_reset: recurrent state and audio context cleared");
+}
+
+int silero_vad_process(silero_vad_t* vad, const float* samples, float* prob) {
+    const OrtApi* ort;
+    OrtStatus* status;
+    OrtValue* in_input = NULL;
+    OrtValue* in_state = NULL;
+    OrtValue* in_sr = NULL;
+    OrtValue* out_prob = NULL;
+    OrtValue* out_state = NULL;
+    const char* input_names[3];
+    const char* output_names[2];
+    const OrtValue* inputs[3];
+    OrtValue* outputs[2];
+    int64_t shape_input[2] = {1, SILERO_VAD_INPUT_SAMPLES};
+    int64_t shape_state[3] = {2, 1, 128};
+    int64_t shape_prob[2] = {1, 1};
+    int64_t sr_value = SILERO_VAD_SAMPLE_RATE;
+    float prob_local = 0.0f;
+    float next_state[SILERO_VAD_STATE_COUNT];
+    float input[SILERO_VAD_INPUT_SAMPLES];
+    int rc = -1;
+
+    if (!vad || !samples || !prob) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_process: invalid args");
+        return -1;
+    }
+    ort = vad->ort;
+    memcpy(input, vad->context, sizeof(vad->context));
+    memcpy(input + SILERO_VAD_CONTEXT_SAMPLES, samples, SILERO_VAD_WINDOW_SAMPLES * sizeof(float));
+
+    status = ort->CreateTensorWithDataAsOrtValue(vad->mem_info, input,
+            sizeof(input), shape_input, 2,
+            ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &in_input);
+    if (status) { vad_report_ort_error(ort, status, "input tensor"); return -1; }
+
+    status = ort->CreateTensorWithDataAsOrtValue(vad->mem_info, vad->state,
+            SILERO_VAD_STATE_COUNT * sizeof(float), shape_state, 3,
+            ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &in_state);
+    if (status) { vad_report_ort_error(ort, status, "state tensor"); goto done; }
+
+    status = ort->CreateTensorWithDataAsOrtValue(vad->mem_info, &sr_value,
+            sizeof(sr_value), NULL, 0,
+            ONNX_TENSOR_ELEMENT_DATA_TYPE_INT64, &in_sr);
+    if (status) { vad_report_ort_error(ort, status, "sr tensor"); goto done; }
+
+    status = ort->CreateTensorWithDataAsOrtValue(vad->mem_info, &prob_local,
+            sizeof(float), shape_prob, 2,
+            ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &out_prob);
+    if (status) { vad_report_ort_error(ort, status, "output tensor"); goto done; }
+
+    status = ort->CreateTensorWithDataAsOrtValue(vad->mem_info, next_state,
+            SILERO_VAD_STATE_COUNT * sizeof(float), shape_state, 3,
+            ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT, &out_state);
+    if (status) { vad_report_ort_error(ort, status, "stateN tensor"); goto done; }
+
+    input_names[0] = "input";
+    input_names[1] = "state";
+    input_names[2] = "sr";
+    inputs[0] = in_input;
+    inputs[1] = in_state;
+    inputs[2] = in_sr;
+
+    output_names[0] = "output";
+    output_names[1] = "stateN";
+    outputs[0] = out_prob;
+    outputs[1] = out_state;
+
+    status = ort->Run(vad->session, NULL, input_names, inputs, 3, output_names, 2, outputs);
+    if (status) {
+        vad_report_ort_error(ort, status, "Run");
+        goto done;
+    }
+
+    memcpy(vad->state, next_state, sizeof(next_state));
+    memcpy(vad->context, input + SILERO_VAD_INPUT_SAMPLES - SILERO_VAD_CONTEXT_SAMPLES, sizeof(vad->context));
+    *prob = prob_local;
+    rc = 0;
+
+done:
+    if (in_input) ort->ReleaseValue(in_input);
+    if (in_state) ort->ReleaseValue(in_state);
+    if (in_sr) ort->ReleaseValue(in_sr);
+    if (out_prob) ort->ReleaseValue(out_prob);
+    if (out_state) ort->ReleaseValue(out_state);
+    return rc;
+}
+
+int silero_vad_process_pcm16(silero_vad_t* vad, const int16_t* pcm, float* prob) {
+    float samples[SILERO_VAD_WINDOW_SAMPLES];
+    int i;
+
+    if (!pcm) {
+        DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_process_pcm16: pcm == NULL");
+        return -1;
+    }
+    for (i = 0; i < SILERO_VAD_WINDOW_SAMPLES; i++) {
+        samples[i] = (float)pcm[i] / 32768.0f;
+    }
+    return silero_vad_process(vad, samples, prob);
+}
+
+#else  /* !HAVE_SILERO_VAD — пустые стабы (сборки без onnxruntime) */
+
+silero_vad_t* silero_vad_create(const char* model_path) {
+    (void)model_path;
+    DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_create: built without onnxruntime (HAVE_SILERO_VAD not defined)");
+    return NULL;
+}
+
+silero_vad_t* silero_vad_create_default(void) {
+    DEBUG_ERROR(DEBUG_CATEGORY_VAD, "silero_vad_create_default: built without onnxruntime (HAVE_SILERO_VAD not defined)");
+    return NULL;
+}
+
+void silero_vad_destroy(silero_vad_t* vad) {
+    (void)vad;
+}
+
+void silero_vad_reset(silero_vad_t* vad) {
+    (void)vad;
+}
+
+int silero_vad_process(silero_vad_t* vad, const float* samples, float* prob) {
+    (void)vad; (void)samples; (void)prob;
+    return -1;
+}
+
+int silero_vad_process_pcm16(silero_vad_t* vad, const int16_t* pcm, float* prob) {
+    (void)vad; (void)pcm; (void)prob;
+    return -1;
+}
+
+#endif /* HAVE_SILERO_VAD */

lib/silero_vad.h

@@ -0,0 +1,77 @@
+/**
+ * Silero VAD (Voice Activity Detector) — C-обёртка над ONNX Runtime.
+ *
+ * Запускает официальную стриминговую модель silero_vad.onnx (v5, ~2.3 МБ),
+ * которая по окну аудио возвращает вероятность наличия речи [0..1].
+ * Рекуррентное состояние модели хранится внутри объекта и переносится между
+ * вызовами. Обёртка также хранит 64 последних отсчёта аудио и добавляет их
+ * перед новым окном: ONNX получает 576 отсчётов, публичный API принимает 512.
+ *
+ * Требования к входному аудио:
+ *   - частота дискретизации 16 кГц (модель поддерживает только 16k);
+ *   - моно;
+ *   - окно ровно SILERO_VAD_WINDOW_SAMPLES = 512 сэмплов (32 мс);
+ *   - float-сэмплы в диапазоне примерно [-1;1] (для int16 есть
+ *     silero_vad_process_pcm16, который сам делит на 32768).
+ *
+ * Порог и гистерезис (задержки начала/конца речи) намеренно оставлены
+ * вызывающему — радио/звонок сами решают, как интерпретировать вероятность.
+ *
+ * Зависимость: libonnxruntime (C API). Сборка включается опцией
+ * `--with-silero-vad` (см. configure.ac) или макросом HAVE_SILERO_VAD в
+ * CMake-сборках. Без HAVE_SILERO_VAD модуль компилируется в пустые стабы
+ * (все create-функции возвращают NULL, process — ошибку), чтобы исходники lib/
+ * можно было GLOB-ить во всех сборках (Android/chatgui) без onnxruntime.
+ *
+ * Лицензия модели: MIT (Silero Team, https://github.com/snakers4/silero-vad).
+ */
+#ifndef SILERO_VAD_H
+#define SILERO_VAD_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Фиксированное окно стриминговой модели: 512 сэмплов @ 16 кГц = 32 мс */
+#define SILERO_VAD_WINDOW_SAMPLES 512
+#define SILERO_VAD_SAMPLE_RATE    16000
+
+typedef struct silero_vad silero_vad_t;
+
+/**
+ * Создать детектор, загрузив ONNX-модель из файла model_path.
+ * Возвращает NULL при ошибке (подробности — в лог категории "vad").
+ */
+silero_vad_t* silero_vad_create(const char* model_path);
+
+/**
+ * Создать детектор из модели, вшитой в бинарник (silero_vad_model_data в
+ * silero_vad.c). Не требует файла на диске. NULL при ошибке.
+ */
+silero_vad_t* silero_vad_create_default(void);
+
+/* Освободить детектор. NULL безопасен. */
+void silero_vad_destroy(silero_vad_t* vad);
+
+/* Сбросить рекуррентное состояние и звуковой контекст (начало нового потока / разрыв захвата). */
+void silero_vad_reset(silero_vad_t* vad);
+
+/**
+ * Обработать окно из 512 float-сэмплов @ 16 кГц (примерно [-1;1]).
+ * При успехе возвращает 0 и заполняет *prob вероятностью речи [0..1];
+ * при ошибке — отрицательное значение (проб не трогается).
+ */
+int silero_vad_process(silero_vad_t* vad, const float* samples, float* prob);
+
+/**
+ * То же, но вход — int16 PCM: сэмплы преобразуются к float делением на 32768.
+ */
+int silero_vad_process_pcm16(silero_vad_t* vad, const int16_t* pcm, float* prob);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SILERO_VAD_H */

lib/socket_compat.c

@@ -4,6 +4,7 @@
 
 #include "socket_compat.h"
 #include "debug_config.h"
+#include <limits.h>
 
 #ifdef _WIN32
 // ==================== Windows Implementation ====================
@@ -211,6 +212,27 @@ int socket_set_mark(socket_t sock, int mark) {
 #endif
 }
 
+/* Ошибки send остаются у вызывающего; закрытый пир не завершает процесс сигналом. */
+ssize_t socket_send(socket_t sock, const void* buf, size_t len) {
+#ifdef _WIN32
+    if (len > INT_MAX) { WSASetLastError(WSAEMSGSIZE); return SOCKET_ERROR_CODE; }
+    return send(sock, (const char*)buf, (int)len, 0);
+#elif defined(MSG_NOSIGNAL)
+    return send(sock, buf, len, MSG_NOSIGNAL);
+#elif defined(SO_NOSIGPIPE)
+    int enabled = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, &enabled, sizeof(enabled)) < 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "cannot disable SIGPIPE for socket=%d: %s", (int)sock, strerror(errno));
+        return SOCKET_ERROR_CODE;
+    }
+    return send(sock, buf, len, 0);
+#else
+    DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "safe TCP send is unsupported on this platform");
+    errno = ENOTSUP;
+    return SOCKET_ERROR_CODE;
+#endif
+}
+
 ssize_t socket_sendto(socket_t sock, const void* buf, size_t len,
                        const struct sockaddr* dest, socklen_t dest_len) {
 #ifdef _WIN32
@@ -246,3 +268,16 @@ uint16_t ss_get_port(const struct sockaddr_storage *addr) {
 
     return 0;
 }
+
+uint16_t socket_get_bound_port(socket_t sock) {
+    struct sockaddr_storage address; socklen_t size = sizeof(address);
+    if (getsockname(sock, (struct sockaddr*)&address, &size) != 0) {
+        DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "getsockname fd=%llu failed: %s",
+                    (unsigned long long)sock, socket_strerror(socket_get_error()));
+        return 0;
+    }
+    uint16_t port = ss_get_port(&address);
+    if (!port) DEBUG_ERROR(DEBUG_CATEGORY_SOCKET, "socket fd=%llu family=%d has no bound port",
+                           (unsigned long long)sock, address.ss_family);
+    return port;
+}

lib/socket_compat.h

@@ -1,6 +1,9 @@
 /**
- * Socket compatibility layer for cross-platform support (POSIX / Windows)
- * MSYS2 UCRT64 compatible
+ * Единые socket_t, коды ошибок и wrappers сокетов POSIX/Windows (включая MSYS2 UCRT64).
+ * platform_init/cleanup обслуживают Winsock; UDP/nonblocking/options/sendto/recvfrom — операции ОС.
+ * Созданные сокеты закрывает владелец через socket_close_wrapper; event loop находится в u_async.h.
+ * Использование: platform_init → create_udp → set_nonblocking/options → sendto/recvfrom → close → cleanup.
+ * До регистрации в uasync вызывающий должен включить nonblocking. Winsock init/cleanup согласовать между потоками.
  */
 
 #ifndef SOCKET_COMPAT_H
@@ -44,13 +47,16 @@ extern "C" {
     #define ERR_INTR EINTR
 #endif
 
-// Platform initialization/cleanup
+// POSIX: 0 без системной инициализации. Windows: WSAStartup при первом init, счётчик вложенности; 0 / -1.
 int socket_platform_init(void);
+// Парный cleanup: Windows уменьшает счётчик и вызывает WSACleanup на нуле; POSIX ничего не освобождает.
 void socket_platform_cleanup(void);
 
-// Socket operations
+// UDP-сокет для family (обычно AF_INET/AF_INET6); SOCKET_INVALID при ошибке. Владение передаётся вызывающему.
 socket_t socket_create_udp(int family);
+// Включает nonblocking: 0 — успех, -1 — ошибка.
 int socket_set_nonblocking(socket_t sock);
+/* Закрыть сокет средствами ОС; на POSIX sock=0 оставляет дескриптор открытым и возвращает 0. */
 int socket_close_wrapper(socket_t sock);
 static inline int socket_get_error(void) {
 #ifdef _WIN32
@@ -60,23 +66,35 @@ static inline int socket_get_error(void) {
 #endif
 }
 
-// Socket options
+// Пробует установить оба буфера SO_SNDBUF/SO_RCVBUF: 0 при успехе обоих, -1 при любой ошибке; отката нет.
 int socket_set_buffers(socket_t sock, int sndbuf, int rcvbuf);
+// Устанавливает SO_REUSEADDR в значение reuse; 0 / -1.
 int socket_set_reuseaddr(socket_t sock, int reuse);
+// SO_BINDTODEVICE для строки ifname (не NULL); 0 / -1. Без поддержки опции, в том числе Windows, возвращает -1.
 int socket_bind_to_device(socket_t sock, const char* ifname);
+// SO_MARK в значение mark; 0 / -1. Без поддержки опции, в том числе Windows, возвращает -1.
 int socket_set_mark(socket_t sock, int mark);
 
-// I/O operations
+/* Один TCP send без SIGPIPE и изменения обработчиков процесса. Буфер заимствован;
+ * возвращает число байт либо SOCKET_ERROR_CODE, включая EAGAIN. Ошибку логирует владелец.
+ * MSG_NOSIGNAL либо SO_NOSIGPIPE; без поддержки возвращает ENOTSUP. Windows: len <= INT_MAX. */
+ssize_t socket_send(socket_t sock, const void* buf, size_t len);
+
+// Один sendto/recvfrom с flags=0: число байт или SOCKET_ERROR_CODE; errno/WSA-код читать через socket_get_error.
+// буферами владеет вызывающий; для Windows len должен помещаться в int. dest_len — размер адреса назначения;
+// src_len при приёме — входная ёмкость/выходная длина адреса (может быть NULL по правилам recvfrom ОС).
 ssize_t socket_sendto(socket_t sock, const void* buf, size_t len,
                       const struct sockaddr* dest, socklen_t dest_len);
 ssize_t socket_recvfrom(socket_t sock, void* buf, size_t len,
                         struct sockaddr* src, socklen_t* src_len);
 
-// Utility
+// Заимствованный текст ошибки: Windows — один статический буфер (перезаписывается следующим вызовом), POSIX — strerror.
 const char* socket_strerror(int err);
 
-// взять порт из sockaddr_storage
+// IPv4/IPv6-порт в host byte order; 0 при NULL или другом семействе.
 uint16_t ss_get_port(const struct sockaddr_storage *addr);
+// Фактический IPv4/IPv6-порт уже привязанного сокета; 0 при ошибке.
+uint16_t socket_get_bound_port(socket_t sock);
 
 
 #ifdef __cplusplus

lib/socket_compat_doc.md

@@ -1,99 +0,0 @@
-# socket_compat — Cross-platform socket abstraction
-
-## 1. Назначение
-Унифицирует работу с UDP-сокетами между POSIX и Windows (MSYS2 UCRT64). Скрывает различия в типах дескрипторов (`int` vs `SOCKET`), инициализации подсистемы (WSAStartup/WSACleanup), кодах ошибок и сигнатурах системных вызовов.
-
-## 2. Как пользоваться
-
-### Инициализация (однократно при старте)
-```c
-if (socket_platform_init() != 0) { /* фатальная ошибка */ }
-// ... работа с сокетами ...
-socket_platform_cleanup();   // при завершении
-```
-На Windows WSAStartup/WSACleanup с refcount — можно вызывать init/cleanup вложенно.
-
-### Создание и настройка сокета
-```c
-socket_t sock = socket_create_udp(AF_INET);     // или AF_INET6
-if (sock == SOCKET_INVALID) { /* ошибка */ }
-
-socket_set_nonblocking(sock);                   // обязательно для u_async
-socket_set_reuseaddr(sock, 1);
-socket_set_buffers(sock, 256*1024, 256*1024);   // SO_SNDBUF/SO_RCVBUF
-socket_bind_to_device(sock, "eth0");            // только Linux, SO_BINDTODEVICE
-socket_set_mark(sock, 42);                      // только Linux, SO_MARK
-```
-
-### Отправка и приём
-```c
-ssize_t sent = socket_sendto(sock, buf, len, (struct sockaddr*)&addr, addr_len);
-ssize_t recv = socket_recvfrom(sock, buf, sizeof(buf), (struct sockaddr*)&src, &src_len);
-
-uint16_t port = ss_get_port(&src);              // порт из sockaddr_storage
-```
-
-### Обработка ошибок
-```c
-if (sent == SOCKET_ERROR_CODE) {
-    int err = socket_get_error();
-    if (err == ERR_WOULDBLOCK) { /* нормально для неблокирующего */ }
-    // на POSIX ERR_WOULDBLOCK == EWOULDBLOCK (может совпадать с EAGAIN)
-    DEBUG_ERROR(..., "%s", socket_strerror(err));
-}
-```
-
-### Закрытие
-```c
-socket_close_wrapper(sock);   // на POSIX: close() с защитой от fd 0
-```
-
-### Ключевые нюансы
-- **Всегда вызывать `socket_platform_init()` перед работой** — иначе на Windows сокеты не будут работать
-- **Всегда `socket_set_nonblocking()`** — u_async требует неблокирующих сокетов
-- `socket_t` — на POSIX `int`, на Windows `SOCKET` (unsigned)
-- `SOCKET_INVALID` — константа для невалидного сокета (`-1` на POSIX, `INVALID_SOCKET` на Windows)
-- `SOCKET_ERROR_CODE` — код ошибки сокетных вызовов (`-1` на POSIX, `SOCKET_ERROR` на Windows)
-- `socket_strerror()` на Windows использует статический буфер — не thread-safe для параллельного использования
-- `socket_bind_to_device` и `socket_set_mark` — только Linux, на остальных платформах возвращают -1 с DEBUG-сообщением
-- `socket_close_wrapper` на POSIX не закроет fd 0 (защита)
-
-## 3. API
-
-### Типы и константы
-| Имя | Назначение |
-|-----|------------|
-| `socket_t` | Кроссплатформенный тип дескриптора сокета (`int` / `SOCKET`) |
-| `SOCKET_INVALID` | Невалидный сокет (`-1` / `INVALID_SOCKET`) |
-| `SOCKET_ERROR_CODE` | Код ошибки сокетного вызова (`-1` / `SOCKET_ERROR`) |
-| `ERR_WOULDBLOCK` / `ERR_AGAIN` / `ERR_INTR` | Кроссплатформенные коды ошибок |
-
-### Инициализация
-| Функция | Назначение |
-|---------|------------|
-| `socket_platform_init()` | Инициализация сокетной подсистемы (WSAStartup на Windows). 0 — успех |
-| `socket_platform_cleanup()` | Деинициализация (WSACleanup на Windows), refcount |
-
-### Создание и настройка
-| Функция | Назначение |
-|---------|------------|
-| `socket_create_udp(family)` | Создать UDP-сокет (AF_INET или AF_INET6) |
-| `socket_set_nonblocking(sock)` | Перевести в неблокирующий режим |
-| `socket_set_buffers(sock, snd, rcv)` | Установить SO_SNDBUF и SO_RCVBUF |
-| `socket_set_reuseaddr(sock, reuse)` | Установить SO_REUSEADDR |
-| `socket_bind_to_device(sock, ifname)` | Привязать к интерфейсу (Linux SO_BINDTODEVICE) |
-| `socket_set_mark(sock, mark)` | Установить SO_MARK (Linux) |
-
-### I/O
-| Функция | Назначение |
-|---------|------------|
-| `socket_sendto(sock, buf, len, dest, dest_len)` | Отправить UDP-датаграмму |
-| `socket_recvfrom(sock, buf, len, src, src_len)` | Принять UDP-датаграмму |
-
-### Утилиты
-| Функция | Назначение |
-|---------|------------|
-| `socket_get_error()` | Текущий код ошибки (inline: `WSAGetLastError()` / `errno`) |
-| `socket_strerror(err)` | Текстовое описание ошибки (Windows: статический буфер, не thread-safe) |
-| `socket_close_wrapper(sock)` | Закрыть сокет (POSIX: защита от закрытия fd 0) |
-| `ss_get_port(addr)` | Извлечь порт в host byte order из `sockaddr_storage` |

lib/soundtouch-master/.gitignore

@@ -0,0 +1,55 @@
+bin
+lib
+
+# Win build files
+*.dll
+*.exe
+*.lib
+
+# GNU build files
+*.o
+*.so*
+*.lo
+*.P*
+*.la*
+*.a
+*.pc
+*config*
+Makefile
+Makefile.in
+.libs
+aclocal.m4
+autom4te.cache
+stamp-*
+libtool
+soundstretch
+
+# Files generated by MSVC
+*.bsc
+*.suo
+*.sdf
+*.filters
+*.user
+source/SoundTouch/Win32/
+source/SoundTouch/x64/
+source/SoundStretch/Win32/
+source/SoundStretch/x64/
+source/SoundTouchDll/Win32/
+source/SoundTouchDll/x64/
+source/SoundTouchDll/DllTest/Win32/
+source/SoundTouchDll/DllTest/x64/
+.vs
+
+# Files generated by Android Studio
+source/android-lib/.gradle
+source/android-lib/.idea
+**/*.iml
+source/android-lib/local.properties
+source/android-lib/build
+source/android-lib/.externalNativeBuild
+
+# CMake build directory
+build*
+CMakeFiles
+CMakeCache.txt
+*.cmake

lib/soundtouch-master/CMakeLists.txt

@@ -0,0 +1,131 @@
+cmake_minimum_required(VERSION 3.16)
+project(SoundTouch VERSION 2.3.3 LANGUAGES CXX)
+set(CMAKE_CXX_STANDARD 17)
+
+include(GNUInstallDirs)
+
+set(COMPILE_OPTIONS)
+
+if(MSVC)
+  list(APPEND COMPILE_OPTIONS /O2 /fp:fast)
+else()
+  list(APPEND COMPILE_OPTIONS -Wall -Wextra -Wzero-as-null-pointer-constant -Wno-unknown-pragmas)
+  if(EMSCRIPTEN)
+    list(APPEND COMPILE_OPTIONS -O3)
+  else()
+    list(APPEND COMPILE_OPTIONS -Ofast)
+  endif()
+endif()
+
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+
+#####################
+# SoundTouch library
+
+add_library(SoundTouch STATIC
+  source/SoundTouch/AAFilter.cpp
+  source/SoundTouch/BPMDetect.cpp
+  source/SoundTouch/cpu_detect_x86.cpp
+  source/SoundTouch/FIFOSampleBuffer.cpp
+  source/SoundTouch/FIRFilter.cpp
+  source/SoundTouch/InterpolateCubic.cpp
+  source/SoundTouch/InterpolateLinear.cpp
+  source/SoundTouch/InterpolateShannon.cpp
+  source/SoundTouch/mmx_optimized.cpp
+  source/SoundTouch/PeakFinder.cpp
+  source/SoundTouch/RateTransposer.cpp
+  source/SoundTouch/SoundTouch.cpp
+  source/SoundTouch/sse_optimized.cpp
+  source/SoundTouch/TDStretch.cpp
+)
+target_include_directories(SoundTouch PUBLIC
+   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+   $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+target_include_directories(SoundTouch PRIVATE
+   ${CMAKE_CURRENT_SOURCE_DIR}/include/soundtouch
+)
+
+target_compile_definitions(SoundTouch PRIVATE ${COMPILE_DEFINITIONS})
+target_compile_options(SoundTouch PRIVATE ${COMPILE_OPTIONS})
+set_target_properties(SoundTouch PROPERTIES OUTPUT_NAME "soundtouch-static")
+
+option(INTEGER_SAMPLES "Use integers instead of floats for samples" OFF)
+if(INTEGER_SAMPLES)
+  target_compile_definitions(SoundTouch PRIVATE SOUNDTOUCH_INTEGER_SAMPLES)
+  set(SOUNDTOUCH_INTEGER_SAMPLES TRUE)
+else()
+  target_compile_definitions(SoundTouch PRIVATE SOUNDTOUCH_FLOAT_SAMPLES)
+  set(SOUNDTOUCH_FLOAT_SAMPLES TRUE)
+endif()
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7.*)$")
+  target_compile_options(SoundTouch PRIVATE -mfpu=neon)
+endif()
+
+install(
+  FILES
+    include/soundtouch/BPMDetect.h
+    include/soundtouch/FIFOSampleBuffer.h
+    include/soundtouch/FIFOSamplePipe.h
+    include/soundtouch/STTypes.h
+    include/soundtouch/SoundTouch.h
+  DESTINATION
+    "${CMAKE_INSTALL_INCLUDEDIR}/soundtouch"
+)
+
+
+########################
+# SoundTouchDll library
+
+option(SOUNDTOUCH_DLL "Build SoundTouchDLL C wrapper library" ON)
+if(SOUNDTOUCH_DLL)
+  add_library(SoundTouchDLL SHARED
+    source/SoundTouchDLL/SoundTouchDLL.cpp
+    source/SoundTouchDLL/SoundTouchDLL.rc
+  )
+  set_target_properties(SoundTouch PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+  target_compile_options(SoundTouchDLL PRIVATE ${COMPILE_OPTIONS})
+  set_target_properties(SoundTouchDLL PROPERTIES CXX_VISIBILITY_PRESET hidden)
+  target_compile_definitions(SoundTouchDLL PRIVATE DLL_EXPORTS)
+  target_include_directories(SoundTouchDLL INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+  target_include_directories(SoundTouchDLL PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include/soundtouch")
+  target_link_libraries(SoundTouchDLL PRIVATE SoundTouch)
+  set_target_properties(SoundTouchDLL PROPERTIES OUTPUT_NAME "soundtouch")
+  if(NOT ANDROID)
+    set_target_properties(SoundTouchDLL PROPERTIES VERSION ${CMAKE_PROJECT_VERSION})
+    if(NOT WIN32)
+      set_target_properties(SoundTouchDLL PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
+    endif()
+  endif()
+  install(FILES include/soundtouch/SoundTouchDLL.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/soundtouch")
+  install(TARGETS SoundTouchDLL EXPORT SoundTouchTargets)
+endif()
+
+########################
+
+# CMake config
+include(CMakePackageConfigHelpers)
+set(SOUNDTOUCH_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/SoundTouch")
+install(
+  EXPORT SoundTouchTargets
+  FILE SoundTouchTargets.cmake
+  NAMESPACE SoundTouch::
+  DESTINATION "${SOUNDTOUCH_INSTALL_CMAKEDIR}"
+)
+configure_package_config_file(SoundTouchConfig.cmake.in
+  "${CMAKE_CURRENT_BINARY_DIR}/SoundTouchConfig.cmake"
+  INSTALL_DESTINATION "${SOUNDTOUCH_INSTALL_CMAKEDIR}"
+)
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/SoundTouchConfigVersion.cmake"
+  VERSION "${CMAKE_PROJECT_VERSION}"
+  COMPATIBILITY SameMajorVersion
+)
+install(
+  FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/SoundTouchConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/SoundTouchConfigVersion.cmake"
+  DESTINATION "${SOUNDTOUCH_INSTALL_CMAKEDIR}"
+)

lib/soundtouch-master/COPYING.TXT

@@ -0,0 +1,458 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS

lib/soundtouch-master/SoundTouchConfig.cmake.in

@@ -0,0 +1,11 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/SoundTouchTargets.cmake")
+
+check_required_components(SoundTouch)
+
+if(@SOUNDTOUCH_DLL@)
+  check_required_components(SoundTouchDLL)
+  get_target_property(SoundTouchDLL_LOCATION SoundTouch::SoundTouchDLL LOCATION)
+  message(STATUS "Found SoundTouchDLL: ${SoundTouchDLL_LOCATION}")
+endif()