17 changed files with 141 additions and 2407 deletions
--- a/LEDMapper.spec
+++ b/LEDMapper.spec
@ -1,8 +1,6 @@
 # -*- mode: python ; coding: utf-8 -*-
 import os
 import subprocess
 import sys
 from pathlib import Path
 from datetime import datetime
@ -12,15 +10,15 @@ spec_dir = Path(SPECPATH)
 def git_build_ref():
    try:
-        dirty = subprocess.check_output(
+        dirty = subprocess.run(
-            ['git', 'status', '--porcelain', '--untracked-files=normal'],
+            ['git', 'diff-index', '--quiet', 'HEAD', '--'],
            cwd=spec_dir,
            stderr=subprocess.DEVNULL,
-            text=True,
+            stdout=subprocess.DEVNULL,
-        )
+        ).returncode != 0
-        if dirty.strip():
+        if dirty:
            return datetime.now().strftime('%H%M%S-%d%m%Y')
-    except (OSError, subprocess.CalledProcessError):
+    except OSError:
        return datetime.now().strftime('%H%M%S-%d%m%Y')
    try:
        tag = subprocess.check_output(
@ -47,54 +45,16 @@ def git_build_ref():
    return 'untagged'
 def _build_library_roots():
    windows_root = Path(os.environ.get('SystemRoot', r'C:\Windows')).resolve()
    return tuple(dict.fromkeys(
        path.resolve() for path in (
            Path(sys.executable).parent,
            Path(sys.prefix),
            Path(sys.base_prefix),
            Path(sys.base_prefix) / 'DLLs',
            windows_root / 'System32',
            windows_root,
        ) if path.is_dir()
    ))
 def _set_isolated_build_path(roots):
    # Analysis searches PATH for DLLs. Unrelated tools may provide incompatible
    # copies of the Windows runtime or ICU libraries there.
    os.environ['PATH'] = os.pathsep.join(str(root) for root in roots)
 def _check_binary_sources(binaries, roots):
    foreign = [
        (name, source)
        for name, source, kind in binaries
        if kind == 'BINARY'
        and not any(Path(source).resolve().is_relative_to(root) for root in roots)
    ]
    if foreign:
        details = '\n'.join(f'{name}: {source}' for name, source in foreign[:10])
        raise RuntimeError(f'Build contains DLLs outside Python and Windows:\n{details}')
 app_name = f'LEDMapper-{git_build_ref()}'
 library_roots = _build_library_roots()
 _set_isolated_build_path(library_roots)
 build_version_path = spec_dir.parent / 'build' / 'ledmapper-build-version.txt'
 build_version_path.parent.mkdir(parents=True, exist_ok=True)
 build_version_path.write_text(app_name.removeprefix('LEDMapper-'), encoding='utf-8')
 a = Analysis(
    [str(spec_dir / 'main.py')],
    pathex=[str(spec_dir), str(spec_dir.parent)],
    binaries=[],
-    datas=[(str(spec_dir / 'assets'), 'assets'), (str(build_version_path), '.')],
+    datas=[(str(spec_dir / 'assets'), 'assets')],
    hiddenimports=[
        'canvas',
        'background_image_loader',
        'background_dialog',
        'icons',
        'localization',
@ -106,8 +66,6 @@ a = Analysis(
        'settings_dialog',
        'theme',
        'unfolding',
        'update_service',
        'version',
    ],
    hookspath=[],
    hooksconfig={},
@ -116,7 +74,6 @@ a = Analysis(
    noarchive=False,
    optimize=0,
 )
 _check_binary_sources(a.binaries, library_roots)
 pyz = PYZ(a.pure)
 exe = EXE(
--- a/README.md
+++ b/README.md
@ -10,7 +10,6 @@ LED Mapper — настольное приложение на Python и PySide6
 - Отображение схемы в реальных координатах.
 - Выделение точек мышью и работа через таблицу выбранных LED.
 - До 4 физических линий светодиодных лент.
 - Нумерация линий и блоков с `0`.
 - Блоки внутри линий, включая пустые блоки.
 - Индексация LED отдельно для каждой линии, начиная с `0`.
 - Индексация внутри каждого блока.
@ -18,16 +17,14 @@ LED Mapper — настольное приложение на Python и PySide6
 - Продолжение существующего блока кистью от последней точки блока.
 - Предпросмотр зоны действия кисти и точек, которые будут добавлены.
 - Сетка с настраиваемым шагом (по умолчанию 34 мм) во всех режимах редактирования и генерации.
- Настраиваемые абсолютные размеры LED-точек и текста их индексов: визуальный размер не меняется при приближении.
+- Настраиваемый абсолютный диаметр LED-точек: визуальный размер не меняется при приближении.
- Свободные многострочные текстовые комментарии на схеме.
+- Undo/redo для операций разметки.
 - Undo/redo для операций разметки и комментариев.
 - Удаление назначений через `Del` и контекстные меню.
 - Пакетное удаление выбранных блоков через дерево одной операцией с единым Undo.
 - Сворачивание боковой панели.
 - Сортировка таблицы выбранных точек по столбцам.
 - Генерация `vm_map.h`, `ordered_circles.json`, `validation_report.txt` и README для результата.
 - Сборка самостоятельного Windows EXE через PyInstaller.
 - Проверка и установка Windows-обновлений из релизов Gitea.
 ## Структура приложения
@ -37,8 +34,6 @@ main_window.py             Главное окно, меню, действия,
 canvas.py                  Холст схемы, выделение, кисть, сетка и связи
 models.py                  Модель карты, линий, блоков и алгоритмы маршрутов
 panel_mapping_generator.py Генерация файлов маппинга
 update_service.py          Проверка релизов и безопасная установка Windows EXE
 version.py                 Базовая версия приложения при запуске из исходников
 icons.py                   Встроенные lucide-иконки
 unfolding.py               Описание развертки линий и блоков
 qa_smoke.py                Smoke-тесты приложения
@ -90,28 +85,12 @@ python -m venv .venv
 6. Проверьте счетчики в верхней части боковой панели: количество линий, блоков и назначенных LED.
 7. Сгенерируйте скрипт через `Файл -> Сгенерировать скрипт`.
-Шаг сетки, диаметр точек и размер текста индексов меняются в `Файл -> Параметры -> Внешний вид`. Для каждого значения рядом есть кнопка `Сбросить`. Размер текста индексов обновляется на схеме сразу во время настройки; при отмене возвращается прежнее значение. Шаг сетки сохраняется в JSON текущей схемы, а диаметр точек и размер текста индексов — в пользовательских параметрах приложения. Визуальные размеры точек и подписей не меняются при приближении схемы. Изменение шага не перемещает уже существующие LED автоматически.
+Шаг сетки и диаметр точек меняются в `Файл -> Параметры -> Внешний вид`. Для каждого значения рядом есть кнопка `Сбросить`. Шаг сетки сохраняется в JSON текущей схемы, а диаметр точек — в пользовательских параметрах приложения. Изменение шага не перемещает уже существующие LED автоматически.
 Чтобы удалить несколько блоков, выделите их в дереве с `Ctrl` или `Shift`, затем нажмите `Ctrl+Del` или выберите удаление в контекстном меню. Приложение показывает одно подтверждение и создаёт одну операцию Undo.
 В режиме редактирования выбранные светодиоды можно скопировать через `Ctrl+C` и вставить через `Ctrl+V`. Вставленные LED остаются свободными, сохраняют взаимное расположение и пользовательские поля исходных точек. Первая копия смещается на один шаг сетки вправо и вниз, а следующие вставки образуют каскад. Вся группа вставляется одной операцией Undo и сразу становится текущим выделением.
 В собранном Windows EXE приложение проверяет наличие нового стабильного релиза после запуска. В меню `Справка` можно запустить проверку вручную и, если новая версия найдена, выбрать `Установить обновление`. Загружается только артефакт вида `LEDMapper-vX.Y.Z.exe` из репозитория `Robotail/LED-mapper` на `git.robotail.pro`. После проверки размера и формата EXE приложение предлагает сохранить изменённую схему, закрывается, а отдельный процесс заменяет EXE по прежнему пути и запускает новую версию — существующие ярлыки продолжают работать. Версия релизной сборки хранится внутри EXE, поэтому переименование файла не вызывает повторную установку того же обновления. При неудачном запуске старая версия восстанавливается; причина записывается рядом с EXE в `update-error.log`. Для обновления нужны доступ к серверу релизов и право записи в каталог приложения. Из исходников можно проверить наличие версии, но автоустановка недоступна.
 Перед загрузкой проверяются права записи в каталог приложения. Перенаправления на страницу входа, другой сайт или неожиданный путь того же сервера отклоняются; объявленный сервером размер файла должен совпадать с размером артефакта в данных релиза.
 Если не назначен ни один светодиод, генерация не запускается. Если назначены не все светодиоды, приложение показывает предупреждение и предлагает либо сгенерировать неполный маппинг, либо продолжить редактирование.
 ## Текстовые комментарии на схеме
 Чтобы разместить заметку, нажмите правой кнопкой мыши в нужном месте схемы и выберите `Добавить комментарий…`. Команда `Инструменты -> Добавить комментарий…` создаёт заметку в центре видимой области. Введите многострочный текст и подтвердите ввод.
 Комментарий можно свободно перетаскивать левой кнопкой мыши в любом режиме. Двойной щелчок открывает редактирование текста; в контекстном меню комментария доступны изменение и удаление. Размер текста остаётся читаемым при изменении масштаба. Команда `Показать всё` учитывает комментарии, в том числе за пределами LED-схемы.
 Добавление, изменение, перемещение и удаление поддерживают Undo/Redo. Отмена диалога и пустой текст не изменяют схему. Комментарии сохраняются в JSON в списке `comments`: `id`, `text`, `x`, `y`; координаты используют единицы схемы. Старые JSON без этого списка открываются без комментариев. Можно сохранить схему, содержащую только комментарии.
 Комментарии не привязаны к линиям, блокам или LED и не влияют на физические адреса в `VM_MAPPINGS`. Экспорт изображения маппинга через меню `Файл` по-прежнему показывает LED и легенду; текстовые комментарии сохраняются в JSON и отображаются в редакторе.
 ## Горячие клавиши
 | Действие | Клавиши |
@ -122,8 +101,6 @@ python -m venv .venv
 | Сгенерировать скрипт | `Ctrl+G` |
 | Отменить | `Ctrl+Z` |
 | Повторить | `Ctrl+Y` |
 | Копировать выбранные LED | `Ctrl+C` |
 | Вставить скопированные LED | `Ctrl+V` |
 | Удалить фиксацию | `Del` |
 | Удалить выбранные точки или блоки | `Ctrl+Del` |
 | Удалить все | `Ctrl+Shift+Del` |
@ -147,13 +124,11 @@ python -m venv .venv
 Устаревший `virtual_matrix_legacy.ino.txt` больше не создаётся. Если файл с этим точным именем остался в выходной папке от прежней версии, следующая успешная генерация удалит его. Другие `.ino`-файлы не затрагиваются.
-JSON схемы хранит `coordinate_unit`, `grid_step_mm` и `index_base: 0`. При первом открытии старого файла без единицы координат приложение определяет её один раз и затем сохраняет явно. Старые схемы с 1-based ID линий и блоков при загрузке переводятся на 0-based; сохранение записывает маркер `index_base: 0`, чтобы повторная загрузка не сдвигала ID. Сохранение выполняется через временный файл и атомарную замену, поэтому исходный JSON не повреждается при ошибке записи.
+JSON схемы хранит `coordinate_unit` и `grid_step_mm`. При первом открытии старого файла без единицы координат приложение определяет её один раз и затем сохраняет явно. Сохранение выполняется через временный файл и атомарную замену, поэтому исходный JSON не повреждается при ошибке записи.
 Если у схемы есть подложка, при сохранении исходное изображение встраивается в секцию `background.embedded_image` внутри JSON вместе с именем, MIME-типом и контрольной суммой. Диалог выбора показывает все форматы, которые доступны в поставляемой версии Qt (включая PNG, JPEG/JFIF, BMP, GIF, WebP, TIFF и SVG), распознаёт содержимое независимо от регистра и расширения файла и учитывает EXIF-ориентацию. Большие изображения безопасно уменьшаются для отображения. Если изображение повреждено или его декодер недоступен, приложение показывает причину и сохраняет прежнюю подложку. После сохранения схема не зависит от внешнего файла, а размеры и параметры подложки сохраняются при редактировании и переносе JSON. Для уже встроенного и не заменённого изображения диалог `Подложка` показывает в поле пути значение `Встроенная`. Чтобы заменить его, нажмите `Выбрать` и укажите новый файл; новое изображение будет встроено при следующем сохранении схемы.
 В `vm_map.h` используются физические адреса из GUI:
- `strip = line_id`
+- `strip = line_id - 1`
 - `led_id = line_index`
 Неназначенные точки не попадают в рабочий `VM_MAPPINGS`, но исходные точки могут оставаться в служебных метаданных.
@ -197,12 +172,10 @@ JSON схемы хранит `coordinate_unit`, `grid_step_mm` и `index_base: 0
 .\.venv\Scripts\python.exe -m PyInstaller --noconfirm --clean app\LEDMapper.spec
 ```
-Сборочный `spec` ограничивает поиск DLL каталогами Python, виртуального окружения и Windows. Это защищает EXE от несовместимых системных библиотек сторонних программ, добавленных в `PATH`. После сборки проверяйте готовый файл командой `dist\LEDMapper-vX.Y.Z.exe --verify-bundle`: успешная проверка завершается с кодом `0` без открытия окна приложения.
+Готовый файл появится здесь:
 В чистой сборке из релизного тега файл будет называться:
 ```text
-dist/LEDMapper-vX.Y.Z.exe
+dist/LEDMapper.exe
 ```
 `build/` и `dist/` не коммитятся, потому что это воспроизводимые артефакты сборки.
--- a/init.py
+++ b/init.py
@ -1,3 +1 @@
 """LED Mapper Editor application package."""
 from .version import __version__
--- a/background_dialog.py
+++ b/background_dialog.py
@ -16,31 +16,21 @@ from PySide6.QtWidgets import (
 )
 try:
    from .background_image_loader import supported_image_filter
    from .localization import localize_dialog_buttons
    from .models import BackgroundImage
 except ImportError:
    from background_image_loader import supported_image_filter
    from localization import localize_dialog_buttons
    from models import BackgroundImage
 class BackgroundDialog(QDialog):
    EMBEDDED_PATH_LABEL = "Встроенная"
    def __init__(self, background: BackgroundImage, parent=None) -> None:  # noqa: ANN001
        super().__init__(parent)
        self.setWindowTitle("Подложка")
        self.setMinimumWidth(460)
-        self._source_background = background
+        self.path = QLineEdit(background.path)
-        self._keep_embedded_image = background.has_embedded_image()
+        self.path.setPlaceholderText("PNG или JPEG")
        self.path = QLineEdit(self.EMBEDDED_PATH_LABEL if self._keep_embedded_image else background.path)
        self.path.setPlaceholderText("Файл изображения")
        self.path.setReadOnly(self._keep_embedded_image)
        if self._keep_embedded_image:
            source_name = background.embedded_image_name or "изображение"
            self.path.setToolTip(f"{source_name} встроено в JSON схемы")
        browse = QPushButton("Выбрать")
        browse.clicked.connect(self._browse)
        path_row = QWidget()
@ -79,19 +69,14 @@ class BackgroundDialog(QDialog):
        form.addRow(buttons)
    def background(self) -> BackgroundImage:
        embedded = self._source_background if self._keep_embedded_image else BackgroundImage()
        return BackgroundImage(
-            path="" if self._keep_embedded_image else self.path.text().strip(),
+            path=self.path.text().strip(),
            offset_x=self.offset_x.value(),
            offset_y=self.offset_y.value(),
            scale_x_percent=self.scale_x.value(),
            scale_y_percent=self.scale_y.value(),
            opacity_percent=self.opacity.value(),
            visible=self.visible.isChecked(),
            embedded_image_base64=embedded.embedded_image_base64,
            embedded_image_mime_type=embedded.embedded_image_mime_type,
            embedded_image_name=embedded.embedded_image_name,
            embedded_image_sha256=embedded.embedded_image_sha256,
        )
    def _reset_scale(self) -> None:
@ -99,22 +84,16 @@ class BackgroundDialog(QDialog):
        self.scale_y.setValue(100.0)
    def _browse(self) -> None:
-        start = "" if self._keep_embedded_image else self.path.text().strip()
+        start = self.path.text().strip()
        start_path = Path(start).parent if start else Path.home()
        selected, _ = QFileDialog.getOpenFileName(
            self,
            "Выбрать подложку",
            str(start_path),
-            supported_image_filter(),
+            "Изображения (*.png *.jpg *.jpeg);;Все файлы (*.*)",
        )
        if selected:
-            self._set_external_path(selected)
+            self.path.setText(selected)
    def _set_external_path(self, path: str) -> None:
        self._keep_embedded_image = False
        self.path.setReadOnly(False)
        self.path.setToolTip("")
        self.path.setText(path)
    @staticmethod
    def _spin(minimum: float, maximum: float, value: float, suffix: str) -> QDoubleSpinBox:
--- a/background_image_loader.py
+++ b/background_image_loader.py
@ -1,147 +0,0 @@
 from __future__ import annotations
 from dataclasses import dataclass
 import math
 from pathlib import Path
 from PySide6.QtCore import QByteArray, QBuffer, QIODevice, QSize, Qt
 from PySide6.QtGui import QImage, QImageIOHandler, QImageReader
 try:
    from .models import BackgroundImage
 except ImportError:
    from models import BackgroundImage
 MAX_BACKGROUND_IMAGE_SIDE = 8192
 MAX_BACKGROUND_IMAGE_PIXELS = 32_000_000
 MAX_UNSCALED_SOURCE_PIXELS = 100_000_000
@dataclass(frozen=True)
 class BackgroundImageLoadResult:
    image: QImage
    error: str = ""
    @property
    def loaded(self) -> bool:
        return not self.image.isNull()
 def supported_image_filter() -> str:
    formats = sorted(
        {
            bytes(image_format).decode("ascii", errors="ignore").lower()
            for image_format in QImageReader.supportedImageFormats()
            if image_format
        }
    )
    wildcards: list[str] = []
    for image_format in formats:
        if not image_format or image_format == "pdf":
            continue
        wildcards.extend((f"*.{image_format}", f"*.{image_format.upper()}"))
    patterns = " ".join(dict.fromkeys(wildcards))
    return f"Изображения ({patterns});;Все файлы (*.*)"
 def resolve_background_path(background: BackgroundImage, document_path: Path | None = None) -> Path:
    path = Path(background.path)
    if not path.is_absolute() and document_path is not None:
        path = document_path.parent / path
    return path
 def background_cache_key(background: BackgroundImage, document_path: Path | None = None) -> tuple[object, ...]:
    if background.has_embedded_image():
        image_bytes = background.embedded_image_bytes()
        return ("embedded", background.embedded_image_sha256 or hash(image_bytes), len(image_bytes))
    path = resolve_background_path(background, document_path)
    try:
        stat = path.stat()
    except OSError:
        return ("file", str(path), None, None)
    return ("file", str(path), stat.st_mtime_ns, stat.st_size)
 def _bounded_image_size(size: QSize, max_side: int) -> QSize:
    if not size.isValid() or max_side <= 0:
        return size
    side_factor = min(1.0, max_side / max(size.width(), size.height()))
    pixel_factor = min(1.0, math.sqrt(MAX_BACKGROUND_IMAGE_PIXELS / (size.width() * size.height())))
    factor = min(side_factor, pixel_factor)
    if factor >= 1.0:
        return size
    return QSize(max(1, math.floor(size.width() * factor)), max(1, math.floor(size.height() * factor)))
 def load_background_image(
    background: BackgroundImage,
    document_path: Path | None = None,
    *,
    max_side: int = MAX_BACKGROUND_IMAGE_SIDE,
 ) -> BackgroundImageLoadResult:
    buffer: QBuffer | None = None
    if background.has_embedded_image():
        image_bytes = background.embedded_image_bytes()
        if not image_bytes:
            return BackgroundImageLoadResult(QImage(), "Встроенные данные изображения повреждены или пусты.")
        buffer = QBuffer()
        buffer.setData(QByteArray(image_bytes))
        if not buffer.open(QIODevice.OpenModeFlag.ReadOnly):
            return BackgroundImageLoadResult(QImage(), "Не удалось открыть встроенные данные изображения.")
        reader = QImageReader(buffer)
        source_name = background.embedded_image_name or "встроенное изображение"
    else:
        path = resolve_background_path(background, document_path)
        if not path.is_file():
            return BackgroundImageLoadResult(QImage(), f"Файл не найден: {path}")
        reader = QImageReader(str(path))
        source_name = path.name
    previous_allocation_limit: int | None = None
    try:
        reader.setAutoTransform(True)
        reader.setDecideFormatFromContent(True)
        size = reader.size()
        bounded_size = _bounded_image_size(size, max_side)
        if bounded_size != size:
            if not reader.supportsOption(QImageIOHandler.ImageOption.ScaledSize):
                source_pixels = size.width() * size.height()
                if source_pixels > MAX_UNSCALED_SOURCE_PIXELS:
                    return BackgroundImageLoadResult(
                        QImage(),
                        f"Изображение «{source_name}» слишком большое для безопасного декодирования "
                        f"({size.width()}×{size.height()} пикселей).",
                    )
                current_allocation_limit = QImageReader.allocationLimit()
                required_megabytes = math.ceil(source_pixels * 8 / (1024 * 1024)) + 16
                if current_allocation_limit > 0 and required_megabytes > current_allocation_limit:
                    previous_allocation_limit = current_allocation_limit
                    QImageReader.setAllocationLimit(required_megabytes)
            reader.setScaledSize(bounded_size)
        image = reader.read()
        if image.isNull():
            details = reader.errorString().strip()
            message = f"Не удалось декодировать «{source_name}»"
            if details:
                message += f": {details}"
            return BackgroundImageLoadResult(QImage(), message + ".")
        bounded_size = _bounded_image_size(image.size(), max_side)
        if bounded_size != image.size():
            image = image.scaled(
                bounded_size,
                Qt.AspectRatioMode.KeepAspectRatio,
                Qt.TransformationMode.SmoothTransformation,
            )
        if image.format() not in (QImage.Format.Format_ARGB32, QImage.Format.Format_ARGB32_Premultiplied):
            image = image.convertToFormat(QImage.Format.Format_ARGB32_Premultiplied)
        if image.isNull():
            return BackgroundImageLoadResult(QImage(), f"Не удалось преобразовать «{source_name}» для отображения.")
        return BackgroundImageLoadResult(image)
    finally:
        if previous_allocation_limit is not None:
            QImageReader.setAllocationLimit(previous_allocation_limit)
        if buffer is not None:
            buffer.close()
--- a/canvas.py
+++ b/canvas.py
@ -1,9 +1,10 @@
 from __future__ import annotations
 import math
 from pathlib import Path
-from PySide6.QtCore import QPointF, QRectF, Qt, QTimer, Signal
+from PySide6.QtCore import QPointF, QRectF, QSize, Qt, QTimer, Signal
-from PySide6.QtGui import QColor, QBrush, QFont, QPainter, QPainterPath, QPen, QPixmap, QTransform
+from PySide6.QtGui import QColor, QBrush, QImage, QImageReader, QPainter, QPainterPath, QPen, QPixmap, QTransform
 from PySide6.QtWidgets import (
    QApplication,
    QGraphicsEllipseItem,
@ -14,7 +15,6 @@ from PySide6.QtWidgets import (
    QGraphicsRectItem,
    QGraphicsScene,
    QGraphicsSimpleTextItem,
    QGraphicsTextItem,
    QGraphicsView,
    QMenu,
    QScrollBar,
@ -22,13 +22,12 @@ from PySide6.QtWidgets import (
 from shiboken6 import isValid
 try:
    from .background_image_loader import background_cache_key, load_background_image
    from .models import BackgroundImage, LedLine, LedPoint, MappingDocument, coordinate_display_scale
 except ImportError:
    from background_image_loader import background_cache_key, load_background_image
    from models import BackgroundImage, LedLine, LedPoint, MappingDocument, coordinate_display_scale
 MAX_BACKGROUND_PIXMAP_SIDE = 8192
 MAX_GRID_LINES = 800
@ -56,43 +55,6 @@ class LedItem(QGraphicsEllipseItem):
        )
 class CommentItem(QGraphicsTextItem):
    """Свободная заметка; положение хранится в координатах документа."""
    def __init__(self, comment, dark: bool) -> None:  # noqa: ANN001
        super().__init__()
        self.comment_id = comment.id
        self.dark = dark
        self.setPlainText(comment.text)
        font = QFont()
        font.setPixelSize(14)
        self.setFont(font)
        self.document().setDocumentMargin(10)
        self.setTextWidth(240)
        self.setTextInteractionFlags(Qt.NoTextInteraction)
        self.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
        self.setZValue(55)
        self.setCursor(Qt.SizeAllCursor)
        self.setToolTip("Перетащите комментарий мышью. Двойной щелчок — изменить текст. ПКМ — меню.")
        self.apply_theme(dark)
    def apply_theme(self, dark: bool) -> None:
        self.dark = dark
        self.setDefaultTextColor(QColor("#fef3c7" if dark else "#451a03"))
        self.update()
    def paint(self, painter, option, widget=None) -> None:  # noqa: ANN001
        painter.save()
        painter.setBrush(QColor("#483b20" if self.dark else "#fff4c2"))
        pen = QPen(QColor("#b68c3d" if self.dark else "#d4a437"), 1)
        pen.setCosmetic(True)
        painter.setPen(pen)
        painter.drawRoundedRect(self.boundingRect().adjusted(0.5, 0.5, -0.5, -0.5), 5, 5)
        painter.restore()
        super().paint(painter, option, widget)
 class LedCanvas(QGraphicsView):
    selectionChanged = Signal(list)
    deleteSelectionRequested = Signal()
@ -106,10 +68,6 @@ class LedCanvas(QGraphicsView):
    brushPointTouched = Signal(int)
    brushStrokeFinished = Signal()
    addLedRequested = Signal(float, float)
    addCommentRequested = Signal(float, float)
    editCommentRequested = Signal(str)
    deleteCommentRequested = Signal(str)
    commentMoveFinished = Signal(str, float, float)
    backgroundEditStarted = Signal()
    backgroundChanged = Signal()
    backgroundEditFinished = Signal(bool)
@ -127,8 +85,6 @@ class LedCanvas(QGraphicsView):
        self.document: MappingDocument | None = None
        self.active_line_id: int | None = None
        self.items_by_id: dict[int, LedItem] = {}
        self.comment_items: dict[str, CommentItem] = {}
        self._comment_drag: dict | None = None
        self.grid_items: list[QGraphicsLineItem] = []
        self.connection_items: list[QGraphicsPathItem] = []
        self.line_index_label_items: dict[int, QGraphicsSimpleTextItem] = {}
@ -137,13 +93,11 @@ class LedCanvas(QGraphicsView):
        self._background_handles: dict[str, QGraphicsRectItem] = {}
        self._background_edit_mode = False
        self._background_drag: dict | None = None
-        self._background_pixmap_cache_key: tuple[object, ...] | None = None
+        self._background_pixmap_cache_key: tuple[str, int | None] | None = None
        self._background_pixmap_cache: QPixmap | None = None
        self._background_load_error = ""
        self._background_loaded = False
        self._direction_arrows_visible = True
        self._line_index_labels_visible = True
        self._line_index_font_size_px = 12
        self._point_radius = 4.5
        self._brush_radius = 18.0
        self._zoom_focus_pull = 0.35
@ -284,18 +238,6 @@ class LedCanvas(QGraphicsView):
    def line_index_labels_visible(self) -> bool:
        return self._line_index_labels_visible
    def set_line_index_font_size(self, font_size_px: int) -> None:
        font_size = max(1, min(256, int(font_size_px)))
        if self._line_index_font_size_px == font_size:
            return
        self._line_index_font_size_px = font_size
        for label in self.line_index_label_items.values():
            if label is not None and isValid(label):
                font = label.font()
                font.setPixelSize(font_size)
                label.setFont(font)
        self._position_line_index_labels()
    def set_brush_radius(self, radius: int) -> None:
        self._brush_radius = float(max(4, min(80, radius)))
        if self._brush_zone_item is not None and isValid(self._brush_zone_item):
@ -376,15 +318,6 @@ class LedCanvas(QGraphicsView):
    def background_loaded(self) -> bool:
        return self._background_loaded
    def background_load_error(self) -> str:
        return self._background_load_error
    def validate_background(self, background: BackgroundImage) -> bool:
        if not background.is_enabled():
            self._background_load_error = "Не выбран файл изображения подложки."
            return False
        return not self._load_background_pixmap(background).isNull()
    def set_background(self, background: BackgroundImage) -> None:
        if self.document is None:
            return
@ -444,8 +377,6 @@ class LedCanvas(QGraphicsView):
        self.setUpdatesEnabled(False)
        try:
            self.items_by_id.clear()
            self.comment_items.clear()
            self._comment_drag = None
            self.grid_items.clear()
            self.connection_items.clear()
            self.line_index_label_items.clear()
@ -468,15 +399,8 @@ class LedCanvas(QGraphicsView):
        self._raw_bounds = None
        self._content_scene_rect = None
        if self.document is None or not self.document.points:
            self._display_scale = 1.0
            self._refresh_background()
            self._refresh_comments()
            self._update_scene_rect()
            if reset_view:
                self.fit_to_content()
            else:
                self.setTransform(old_transform)
                self.centerOn(old_center)
            return
        # Keep display scale completely stable to prevent grid and camera jumps
@ -507,7 +431,6 @@ class LedCanvas(QGraphicsView):
        stable_min_x, stable_max_x, stable_min_y, stable_max_y = self._stable_edit_bounds
        self._update_led_content_rect()
        self._refresh_background()
        self._refresh_comments()
        self._update_scene_rect()
        self._refresh_grid()
        self.refresh_styles()
@ -530,8 +453,6 @@ class LedCanvas(QGraphicsView):
                    self.centerOn(old_center)
    def refresh_styles(self, redraw_connections: bool = True) -> None:
        for comment_item in self.comment_items.values():
            comment_item.apply_theme(self._theme == "dark")
        if self.document is None:
            return
        if redraw_connections:
@ -611,7 +532,10 @@ class LedCanvas(QGraphicsView):
        self._remove_background_items()
        if self.document is None or not self.document.background.is_enabled():
            return
-        pixmap = self._load_background_pixmap(self.document.background)
+        image_path = Path(self.document.background.path)
        if not image_path.is_absolute() and self.document.path is not None:
            image_path = self.document.path.parent / image_path
        pixmap = self._load_background_pixmap(image_path)
        if pixmap.isNull():
            self._background_loaded = False
            return
@ -631,14 +555,17 @@ class LedCanvas(QGraphicsView):
        self._background_handles.clear()
        self._background_loaded = False
-    def _load_background_pixmap(self, background: BackgroundImage) -> QPixmap:
+    def _load_background_pixmap(self, path: Path) -> QPixmap:
-        document_path = self.document.path if self.document is not None else None
+        cache_key = (str(path), path.stat().st_mtime_ns if path.exists() else None)
        cache_key = background_cache_key(background, document_path)
        if self._background_pixmap_cache_key == cache_key and self._background_pixmap_cache is not None:
            return self._background_pixmap_cache
-        result = load_background_image(background, document_path)
+        reader = QImageReader(str(path))
-        self._background_load_error = result.error
+        size = reader.size()
-        pixmap = QPixmap.fromImage(result.image) if result.loaded else QPixmap()
+        if size.isValid() and max(size.width(), size.height()) > MAX_BACKGROUND_PIXMAP_SIDE:
            factor = MAX_BACKGROUND_PIXMAP_SIDE / max(size.width(), size.height())
            reader.setScaledSize(QSize(max(1, int(size.width() * factor)), max(1, int(size.height() * factor))))
        image = reader.read()
        pixmap = QPixmap.fromImage(image) if not image.isNull() else QPixmap()
        self._background_pixmap_cache_key = cache_key
        self._background_pixmap_cache = pixmap
        return pixmap
@ -680,47 +607,8 @@ class LedCanvas(QGraphicsView):
            return None
        return self._background_item.sceneBoundingRect()
    def _refresh_comments(self) -> None:
        for item in self.comment_items.values():
            if isValid(item):
                self.scene().removeItem(item)
        self.comment_items.clear()
        if self.document is None:
            return
        for comment in self.document.comments:
            item = CommentItem(comment, self._theme == "dark")
            item.setPos(self._to_scene_point(comment.x, comment.y))
            self.scene().addItem(item)
            self.comment_items[comment.id] = item
    def _comment_at(self, viewport_pos) -> CommentItem | None:  # noqa: ANN001
        for item in self.items(viewport_pos):
            if isinstance(item, CommentItem):
                return item
        return None
    def _rect_with_comments(self, rect: QRectF | None) -> QRectF | None:
        scale = max(abs(self.transform().m11()), 1e-9)
        for item in self.comment_items.values():
            local = item.boundingRect().adjusted(-20, -20, 20, 20)
            bounds = QRectF(
                item.pos().x() + local.x() / scale, item.pos().y() + local.y() / scale,
                local.width() / scale, local.height() / scale,
            )
            rect = bounds if rect is None else rect.united(bounds)
        return rect
    def mouseDoubleClickEvent(self, event) -> None:  # noqa: ANN001
        item = self._comment_at(event.pos())
        if event.button() == Qt.LeftButton and item is not None:
            self._comment_drag = None
            self.editCommentRequested.emit(item.comment_id)
            event.accept()
            return
        super().mouseDoubleClickEvent(event)
    def _update_scene_rect(self) -> None:
-        rect = self._rect_with_comments(self._content_scene_rect)
+        rect = self._content_scene_rect
        background_rect = self._background_scene_rect()
        if rect is None:
            rect = background_rect
@ -774,12 +662,12 @@ class LedCanvas(QGraphicsView):
            handle.setPos(point)
    def fit_to_content(self) -> None:
        if self.scene() is None:
            return
        # Размер заметок в пикселях постоянен; их границы в сцене зависят от масштаба.
        for _ in range(8 if self.comment_items else 1):
        self._update_scene_rect()
-            rect = self._rect_with_comments(self._content_scene_rect)
+        if self.scene() is None or self.sceneRect().isEmpty():
            return
        # Focus camera on actual document content bounds, ignoring expanded edit sceneRect bounds
        rect = self._content_scene_rect
        background_rect = self._background_scene_rect()
        if rect is None:
            rect = background_rect
@ -787,13 +675,8 @@ class LedCanvas(QGraphicsView):
            rect = rect.united(background_rect)
        if rect is None or rect.isEmpty():
            rect = self.sceneRect()
-            if rect.isEmpty():
+            
                return
        self.fitInView(rect, Qt.KeepAspectRatio)
            if self.comment_items and self.transform().m11() > 1.0:
                self.resetTransform()
                self.centerOn(rect.center())
                break
        self._refresh_grid()
        self._position_line_index_labels()
        self._update_selection_bbox()
@ -899,16 +782,6 @@ class LedCanvas(QGraphicsView):
            self._start_pan(event.pos())
            event.accept()
            return
        if event.button() == Qt.LeftButton:
            comment = self._comment_at(event.pos())
            if comment is not None:
                self.setFocus(Qt.MouseFocusReason)
                self._comment_drag = {
                    "item": comment, "start": self.mapToScene(event.pos()),
                    "origin": QPointF(comment.pos()),
                }
                event.accept()
                return
        is_move_tool = getattr(self, "_edit_tool", "select") == "move"
        has_alt = bool(event.modifiers() & Qt.AltModifier)
        if event.button() == Qt.LeftButton and (has_alt or is_move_tool) and self._start_point_drag(event.pos()):
@ -965,11 +838,6 @@ class LedCanvas(QGraphicsView):
            self._move_scrollbar(self.verticalScrollBar(), delta.y())
            event.accept()
            return
        if self._comment_drag is not None:
            drag = self._comment_drag
            drag["item"].setPos(drag["origin"] + self.mapToScene(event.pos()) - drag["start"])
            event.accept()
            return
        if self._background_drag is not None:
            self._move_background_edit(event.pos())
            event.accept()
@ -1020,17 +888,6 @@ class LedCanvas(QGraphicsView):
            self._finish_pan()
            event.accept()
            return
        if event.button() == Qt.LeftButton and self._comment_drag is not None:
            drag = self._comment_drag
            self._comment_drag = None
            position = drag["origin"] + self.mapToScene(event.pos()) - drag["start"]
            item = drag["item"]
            item.setPos(position)
            if position != drag["origin"]:
                point = self._document_point_from_scene(position)
                self.commentMoveFinished.emit(item.comment_id, point.x(), point.y())
            event.accept()
            return
        if event.button() == Qt.LeftButton and self._background_drag is not None:
            self._finish_background_edit()
            event.accept()
@ -1403,9 +1260,6 @@ class LedCanvas(QGraphicsView):
        )
    def _start_pan(self, pos) -> None:  # noqa: ANN001
        if self._comment_drag is not None:
            self._comment_drag["item"].setPos(self._comment_drag["origin"])
            self._comment_drag = None
        self._is_panning = True
        self._last_pan_pos = pos
        self._apply_default_cursor()
@ -1416,24 +1270,10 @@ class LedCanvas(QGraphicsView):
        self._apply_default_cursor()
    def contextMenuEvent(self, event) -> None:  # noqa: ANN001
        comment = self._comment_at(event.pos())
        if comment is not None:
            menu = QMenu(self)
            edit_comment = menu.addAction("Изменить комментарий…")
            delete_comment = menu.addAction("Удалить комментарий")
            chosen = menu.exec(event.globalPos())
            if chosen == edit_comment:
                self.editCommentRequested.emit(comment.comment_id)
            elif chosen == delete_comment:
                self.deleteCommentRequested.emit(comment.comment_id)
            return
        item = self._led_item_at(event.pos())
        point_id = item.point_id if item is not None else self._single_selected_point_id()
        menu = QMenu(self)
        add_comment = menu.addAction("Добавить комментарий…")
        comment_position = self._document_point_from_scene(self.mapToScene(event.pos()))
        menu.addSeparator()
        edit_action = menu.addAction("Редактировать координаты")
        edit_action.setEnabled(point_id is not None)
        delete_action = menu.addAction("Удалить фиксацию выбранных LED")
@ -1481,11 +1321,9 @@ class LedCanvas(QGraphicsView):
                    select_block_action = menu.addAction(f"Выделить блок '{block_name}'")
        fit_action = menu.addAction("Показать все точки")
-        fit_action.setEnabled(self.document is not None and bool(self.document.points or self.document.comments))
+        fit_action.setEnabled(self.document is not None and bool(self.document.points))
        chosen = menu.exec(event.globalPos())
-        if chosen == add_comment:
+        if chosen == edit_action and point_id is not None:
            self.addCommentRequested.emit(comment_position.x(), comment_position.y())
        elif chosen == edit_action and point_id is not None:
            self.editPointRequested.emit(point_id)
        elif chosen == delete_action:
            self.deleteSelectionRequested.emit()
@ -1553,9 +1391,6 @@ class LedCanvas(QGraphicsView):
            if item is None or not isValid(item):
                continue
            label = QGraphicsSimpleTextItem(str(point.line_index))
            font = QFont(label.font())
            font.setPixelSize(self._line_index_font_size_px)
            label.setFont(font)
            label.setBrush(QColor("#f8fafc" if self._theme == "dark" else "#111827"))
            label.setZValue(40)
            label.setFlag(QGraphicsItem.ItemIgnoresTransformations, True)
--- a/docs/superpowers/plans/2026-11-05-text-comments.md
+++ b/docs/superpowers/plans/2026-11-05-text-comments.md
@ -1,13 +0,0 @@
 # Свободные текстовые комментарии — план
 Цель: свободные многострочные заметки на схеме, согласованные пользователем 05.11.2026.
 Архитектура: отдельная коллекция `comments` документа с устойчивым ID, текстом и координатами в единицах документа. Холст отвечает за отображение и жесты, главное окно — за диалог и историю. Существующие файлы без comments загружаются с пустой коллекцией; неизвестные поля сохраняются. Физический маппинг не изменяется.
 Варианты: привязка к LED/линиям отклонена пользователем; выбрано свободное расположение. Техническое решение: встроить объекты в существующий QGraphicsView и deepcopy-историю без новых зависимостей.
 - [x] Модель: тест round-trip Unicode, отрицательных/дробных координат, неизвестных полей и старого JSON; добавить TextComment и CRUD.
 - [x] Интерфейс: контекстное меню добавления/изменения/удаления, двойной щелчок, перетаскивание. Проверить Undo/Redo, отмену/пустой текст, пустую схему, масштаб и единицы m/mm.
 - [x] Документация и проверка: README, полный smoke-набор, py_compile, интерактивные события Qt и рендер холста. Сохранить фактические результаты в AgentMemory.
 Ограничения: использовать .venv; сохранить существующие пользовательские изменения; не создавать коммиты и релизы. Обнаружена грязная рабочая копия с HEAD 3699586 — это отличается от исторической записи памяти о релизе v3.4.0; version.py содержит 3.4.0. Работа ведётся поверх текущих файлов без отката.
--- a/icons.py
+++ b/icons.py
@ -10,8 +10,6 @@ LUCIDE_PATHS = {
    "arrow-right": '<path d="M5 12h14"/><path d="m12 5 7 7-7 7"/>',
    "brush": '<path d="m9.06 11.9 8.07-8.06a2.85 2.85 0 1 1 4.03 4.03l-8.06 8.08"/><path d="M7.07 14.94c-1.66 0-3 1.35-3 3.01 0 1.1-.89 2-2 2 1.4 1.4 3.67 1.4 5.07 0l2.94-2.94a2.93 2.93 0 0 0-4.14-4.14z"/>',
    "chevron-right": '<path d="m9 18 6-6-6-6"/>',
    "clipboard-paste": '<rect width="8" height="4" x="8" y="2" rx="1"/><path d="M16 4h2a2 2 0 0 1 2 2v5M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"/><path d="m16 19 3-3-3-3"/><path d="M19 16h-7"/>',
    "copy": '<rect width="14" height="14" x="8" y="8" rx="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/>',
    "eraser": '<path d="m7 21-4.3-4.3c-.9-.9-.9-2.4 0-3.3L14 2l8 8-11 11Z"/><path d="M22 21H7"/><path d="m5 11 8 8"/>',
    "eye": '<path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7-10-7-10-7Z"/><circle cx="12" cy="12" r="3"/>',
    "file-plus": '<path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8Z"/><path d="M14 2v6h6"/><path d="M12 18v-6"/><path d="M9 15h6"/>',
--- a/main.py
+++ b/main.py
@ -3,7 +3,6 @@ from __future__ import annotations
 import sys
 from pathlib import Path
 from PySide6.QtCore import QTimer
 from PySide6.QtWidgets import QApplication
 APP_DIR = Path(__file__).resolve().parent
@ -15,20 +14,15 @@ try:
    from .main_window import MainWindow
    from .settings import AppSettings
    from .theme import apply_app_theme, effective_theme
    from .update_service import signal_update_ready
 except ImportError:
    from icons import lucide_icon
    from main_window import MainWindow
    from settings import AppSettings
    from theme import apply_app_theme, effective_theme
    from update_service import signal_update_ready
 def main() -> int:
    app = QApplication(sys.argv)
    if "--verify-bundle" in sys.argv:
        app.processEvents()
        return 0
    settings = AppSettings.load()
    apply_app_theme(settings.theme)
    icon_color = "#111827" if effective_theme(settings.theme) == "light" else "#e5e7eb"
@ -37,7 +31,6 @@ def main() -> int:
    window = MainWindow()
    window.setWindowIcon(app_icon)
    window.show()
    QTimer.singleShot(500, signal_update_ready)
    return app.exec()
--- a/main_window.py
+++ b/main_window.py
@ -2,10 +2,9 @@ from __future__ import annotations
 from copy import deepcopy
 from pathlib import Path
 import sys
 from threading import Event, Thread
-from PySide6.QtCore import QEvent, QObject, QSignalBlocker, QSize, Qt, QTimer, Signal
+from PySide6.QtCore import QEvent, QSignalBlocker, QSize, Qt, QTimer
-from PySide6.QtGui import QAction, QColor, QKeySequence
+from PySide6.QtGui import QAction, QColor, QImageReader, QKeySequence
 from PySide6.QtWidgets import (
    QButtonGroup,
    QAbstractItemView,
@ -55,17 +54,13 @@ try:
        show_information,
        show_warning,
    )
-    from .models import LedBlock, LedLine, LedPoint, MappingDocument
+    from .models import LedBlock, LedLine, MappingDocument
    from .panel_mapping_generator import generate_panel_mapping_from_document
    from .settings import DEFAULT_SHORTCUTS, AppSettings
    from .settings_dialog import SettingsDialog
    from .theme import apply_app_theme, effective_theme
    from .unfolding import MAX_LINES
    from .mapping_renderer import render_mapping_image
    from .update_service import (
        UpdateCancelled, UpdateError, UpdateInfo, check_for_update, current_executable, current_version,
        download_update, launch_update,
    )
 except ImportError:
    from background_dialog import BackgroundDialog
    from canvas import LedCanvas
@ -78,17 +73,13 @@ except ImportError:
        show_information,
        show_warning,
    )
-    from models import LedBlock, LedLine, LedPoint, MappingDocument
+    from models import LedBlock, LedLine, MappingDocument
    from panel_mapping_generator import generate_panel_mapping_from_document
    from settings import DEFAULT_SHORTCUTS, AppSettings
    from settings_dialog import SettingsDialog
    from theme import apply_app_theme, effective_theme
    from unfolding import MAX_LINES
    from mapping_renderer import render_mapping_image
    from update_service import (
        UpdateCancelled, UpdateError, UpdateInfo, check_for_update, current_executable, current_version,
        download_update, launch_update,
    )
 ROOT_DIR = Path(__file__).resolve().parents[1]
@ -200,13 +191,6 @@ class GenerationStrategyDialog(QDialog):
            self.ok_button.setEnabled(True)
 class UpdateSignals(QObject):
    checked = Signal(object)
    downloaded = Signal(object)
    progress = Signal(int)
    failed = Signal(str)
 class MainWindow(QMainWindow):
    def __init__(self) -> None:
        super().__init__()
@ -220,8 +204,6 @@ class MainWindow(QMainWindow):
        self._undo_stack: list[tuple[MappingDocument, int | None, list[int], bool]] = []
        self._redo_stack: list[tuple[MappingDocument, int | None, list[int], bool]] = []
        self._pending_background_undo_state: tuple[MappingDocument, int | None, list[int], bool] | None = None
        self._copied_led_points: list[LedPoint] = []
        self._paste_sequence = 0
        self.settings = AppSettings.load()
        self.document.grid_step_mm = self.settings.grid_step_mm
        apply_app_theme(self.settings.theme)
@ -247,16 +229,6 @@ class MainWindow(QMainWindow):
        self.menu_buttons_widget: QWidget | None = None
        self.right_panel: QFrame | None = None
        self.right_panel_buttons: dict[str, tuple[QToolButton, str]] = {}
        self._update_info: UpdateInfo | None = None
        self._update_busy = False
        self._update_manual_check = False
        self._update_cancel = Event()
        self._installing_update = False
        self._update_signals = UpdateSignals(self)
        self._update_signals.checked.connect(self._on_update_checked)
        self._update_signals.downloaded.connect(self._on_update_downloaded)
        self._update_signals.progress.connect(self._on_update_progress)
        self._update_signals.failed.connect(self._on_update_failed)
        self.canvas = LedCanvas()
        self._apply_canvas_settings()
@ -269,10 +241,6 @@ class MainWindow(QMainWindow):
        self.canvas.autoBlockFromPointRequested.connect(self.auto_block_from_point)
        self.canvas.counterclockwiseBlockFromPointRequested.connect(self.auto_block_from_point_counterclockwise)
        self.canvas.addLedRequested.connect(self.add_manual_led)
        self.canvas.addCommentRequested.connect(self.add_comment_from_canvas)
        self.canvas.editCommentRequested.connect(self.edit_comment)
        self.canvas.deleteCommentRequested.connect(self.delete_comment)
        self.canvas.commentMoveFinished.connect(self.move_comment_from_canvas)
        self.canvas.brushStrokeStarted.connect(self.start_brush_stroke)
        self.canvas.brushPointTouched.connect(self.add_brush_point_to_block)
        self.canvas.brushStrokeFinished.connect(self.finish_brush_stroke)
@ -351,8 +319,6 @@ class MainWindow(QMainWindow):
            application.focusChanged.connect(self._on_application_focus_changed)
            application.installEventFilter(self)
        self._refresh_ui_state()
        if getattr(sys, "frozen", False):
            QTimer.singleShot(1200, self.check_updates)
    def _build_actions(self) -> None:
        def add_action(
@ -378,7 +344,6 @@ class MainWindow(QMainWindow):
            self.actions[key] = action
            return action
        add_action("add_comment", "Добавить комментарий…", self.add_comment_at_center)
        add_action("new", "Создать...", self.new_file, "file-plus", QKeySequence.New)
        add_action("open", "Открыть", self.open_file, "folder-open", QKeySequence.Open)
        add_action("save", "Сохранить", self.save_file, "save", QKeySequence.Save)
@ -392,9 +357,6 @@ class MainWindow(QMainWindow):
            "Экспортировать текущую схему маппинга в изображение (PNG, JPEG)"
        )
        add_action("settings", "Параметры", self.open_settings, "settings", QKeySequence("Ctrl+,"))
        add_action("check_updates", "Проверить обновления", self.check_updates)
        add_action("install_update", "Установить обновление", self.install_update)
        self.actions["install_update"].setEnabled(False)
        add_action(
            "generate_script",
            "Сгенерировать скрипт",
@ -422,22 +384,6 @@ class MainWindow(QMainWindow):
        brush_action.setCheckable(True)
        add_action("undo", "Отменить", self.undo_last_change, "undo-2", QKeySequence.Undo)
        add_action("redo", "Повторить", self.redo_last_change, "redo-2", QKeySequence.Redo)
        add_action(
            "copy_leds",
            "Копировать светодиоды",
            self.copy_selected_leds,
            "copy",
            QKeySequence.Copy,
            "Скопировать выбранные LED в режиме редактирования",
        )
        add_action(
            "paste_leds",
            "Вставить светодиоды",
            self.paste_copied_leds,
            "clipboard-paste",
            QKeySequence.Paste,
            "Вставить свободные копии LED со смещением на шаг сетки",
        )
        self.delete_action = add_action(
            "delete",
            "Удалить фиксацию",
@ -532,9 +478,6 @@ class MainWindow(QMainWindow):
        edit_menu.addAction(self.actions["undo"])
        edit_menu.addAction(self.actions["redo"])
        edit_menu.addSeparator()
        edit_menu.addAction(self.actions["copy_leds"])
        edit_menu.addAction(self.actions["paste_leds"])
        edit_menu.addSeparator()
        edit_menu.addAction(self.actions["delete"])
        edit_menu.addAction(self.actions["delete_points"])
        edit_menu.addAction(self.actions["clear_all"])
@ -558,7 +501,6 @@ class MainWindow(QMainWindow):
        tools_menu = menu_bar.addMenu("Инструменты")
        tools_menu.addAction(self.actions["add_line"])
        tools_menu.addAction(self.actions["add_led"])
        tools_menu.addAction(self.actions["add_comment"])
        tools_menu.addAction(self.actions["generate_script"])
        tools_menu.addSeparator()
        tools_menu.addAction(self.actions["auto_blocks"])
@ -566,10 +508,6 @@ class MainWindow(QMainWindow):
        tools_menu.addSeparator()
        tools_menu.addAction(self.actions["brush"])
        help_menu = menu_bar.addMenu("Справка")
        help_menu.addAction(self.actions["check_updates"])
        help_menu.addAction(self.actions["install_update"])
        # Delete old widget if recreating
        if hasattr(self, "menu_buttons_widget") and self.menu_buttons_widget is not None:
            self.menu_buttons_widget.deleteLater()
@ -609,23 +547,15 @@ class MainWindow(QMainWindow):
        if not hasattr(self, "menu_buttons_widget") or self.menu_buttons_widget is None:
            return
        menu_bar = self.menuBar()
-        action_rects = [
+        actions = menu_bar.actions()
-            menu_bar.actionGeometry(action)
+        if len(actions) < 4:
            for action in menu_bar.actions()
            if action.isVisible()
        ]
        action_rects = [rect for rect in action_rects if rect.isValid() and rect.right() > 0]
        if not action_rects:
            self.menu_buttons_widget.hide()
            return
-        left = max(rect.right() for rect in action_rects) + 10
+        tools_action = actions[3]
-        height = menu_bar.height()
+        rect = menu_bar.actionGeometry(tools_action)
-        width = self.menu_buttons_widget.sizeHint().width()
+        if rect.isValid() and rect.right() > 0:
-        if left + width > menu_bar.contentsRect().right() + 1:
+            h = menu_bar.height()
-            self.menu_buttons_widget.hide()
+            w = self.menu_buttons_widget.sizeHint().width()
-            return
+            self.menu_buttons_widget.setGeometry(rect.right() + 10, (h - 20) // 2, w, 20)
        self.menu_buttons_widget.setGeometry(left, max(0, (height - 20) // 2), width, 20)
        self.menu_buttons_widget.show()
    def _build_layout(self) -> None:
        side = QWidget()
@ -1038,11 +968,14 @@ class MainWindow(QMainWindow):
        if res != BackgroundDialog.Accepted:
            return
        background = dialog.background()
-        if not background.is_enabled():
+        if not background.path:
            return
-        if not self.canvas.validate_background(background):
+        image_path = Path(background.path)
-            details = self.canvas.background_load_error() or "Формат или содержимое изображения не поддерживается."
+        if not image_path.is_absolute() and self.document.path is not None:
-            show_warning(self, "Подложка не загружена", details)
+            image_path = self.document.path.parent / image_path
        reader = QImageReader(str(image_path))
        if not reader.canRead():
            show_warning(self, "Подложка не загружена", "Не удалось загрузить изображение подложки. Выберите PNG или JPEG файл.")
            return
        if background.to_payload() == self.document.background.to_payload():
            self.status.setText("Подложка не изменилась.")
@ -1128,15 +1061,12 @@ class MainWindow(QMainWindow):
        dialog_settings = deepcopy(self.settings)
        dialog_settings.grid_step_mm = self.document.grid_step_mm
        dialog = SettingsDialog(dialog_settings, self)
        previous_index_font_size = self.settings.led_index_font_size_px
        dialog.led_index_font_size.valueChanged.connect(self.canvas.set_line_index_font_size)
        self._disable_shortcuts()
        try:
            res = dialog.exec()
        finally:
            self._enable_shortcuts()
        if res != SettingsDialog.Accepted:
            self.canvas.set_line_index_font_size(previous_index_font_size)
            return
        new_settings = dialog.settings()
        grid_changed = abs(self.document.grid_step_mm - new_settings.grid_step_mm) > 1e-9
@ -1181,7 +1111,6 @@ class MainWindow(QMainWindow):
        self.canvas.set_grid_visible(self.settings.show_grid_by_default)
        self.canvas.set_direction_arrows_visible(self.settings.show_direction_arrows_by_default)
        self.canvas.set_line_index_labels_visible(self.settings.show_led_ids_by_default)
        self.canvas.set_line_index_font_size(self.settings.led_index_font_size_px)
        self.canvas.set_brush_radius(self.settings.brush_radius)
        self.canvas.set_grid_step_mm(self.document.grid_step_mm)
        self.canvas.set_point_diameter(self.settings.led_point_diameter_px)
@ -1190,11 +1119,7 @@ class MainWindow(QMainWindow):
        self.canvas.set_instant_space_pan(self.settings.instant_space_pan)
    def eventFilter(self, obj, event) -> bool:  # noqa: ANN001, N802
-        if event.type() == QEvent.Type.ShortcutOverride:
+        if event.type() == QEvent.Type.ShortcutOverride and self._is_tree_bulk_delete_event(event):
            if self._text_input_owns_copy_paste(event):
                event.accept()
                return True
            if self._is_tree_bulk_delete_event(event):
            event.accept()
            return self.remove_selected_tree_item()
        if event.type() == QEvent.Type.KeyPress and not event.isAutoRepeat():
@ -1221,8 +1146,6 @@ class MainWindow(QMainWindow):
        modifiers = event.modifiers()
        if isinstance(focus, QKeySequenceEdit):
            return False
        if self._text_input_owns_copy_paste(event):
            return False
        text_input_has_focus = isinstance(focus, (QLineEdit, QTextEdit, QPlainTextEdit, QKeySequenceEdit))
        if text_input_has_focus and not (modifiers & (Qt.ControlModifier | Qt.AltModifier)):
            return False
@ -1237,13 +1160,6 @@ class MainWindow(QMainWindow):
                return True
        return False
    @staticmethod
    def _text_input_owns_copy_paste(event) -> bool:  # noqa: ANN001
        focus = QApplication.focusWidget()
        if not isinstance(focus, (QLineEdit, QTextEdit, QPlainTextEdit)):
            return False
        return event.matches(QKeySequence.StandardKey.Copy) or event.matches(QKeySequence.StandardKey.Paste)
    def _physical_key_sequence(self, event) -> str:  # noqa: ANN001
        key_name = physical_key_name(event)
        if not key_name:
@ -1724,55 +1640,6 @@ class MainWindow(QMainWindow):
        self.status.setText(f"Создана {line.name}. {self._line_summary(line)}")
        self._refresh_ui_state()
    def add_comment_at_center(self) -> None:
        point = self.canvas._document_point_from_scene(
            self.canvas.mapToScene(self.canvas.viewport().rect().center())
        )
        self.add_comment_from_canvas(point.x(), point.y())
    def add_comment_from_canvas(self, x: float, y: float) -> None:
        text, accepted = QInputDialog.getMultiLineText(self, "Новый комментарий", "Текст комментария:")
        if not accepted or not text.strip():
            return
        self._push_undo()
        self.document.add_comment(text, x, y)
        self._after_comment_change("Комментарий добавлен.")
    def edit_comment(self, comment_id: str) -> None:
        comment = self.document.get_comment(comment_id)
        text, accepted = QInputDialog.getMultiLineText(
            self, "Изменить комментарий", "Текст комментария:", comment.text,
        )
        if not accepted or not text.strip() or text == comment.text:
            return
        self._push_undo()
        self.document.update_comment(comment_id, text=text)
        self._after_comment_change("Комментарий изменён.")
    def move_comment_from_canvas(self, comment_id: str, x: float, y: float) -> None:
        comment = self.document.get_comment(comment_id)
        if (comment.x, comment.y) == (x, y):
            return
        self._push_undo()
        self.document.update_comment(comment_id, x=x, y=y)
        self._after_comment_change("Комментарий перемещён.")
    def delete_comment(self, comment_id: str) -> None:
        self.document.get_comment(comment_id)
        self._push_undo()
        self.document.remove_comment(comment_id)
        self._after_comment_change("Комментарий удалён.")
    def _after_comment_change(self, message: str) -> None:
        self._dirty = True
        if self.canvas.document is not self.document:
            self.canvas.set_document(self.document, reset_view=False)
        else:
            self.canvas._refresh_comments()
            self.canvas._update_scene_rect()
        self.status.setText(message)
        self._refresh_ui_state()
    def add_manual_led(self, x: float, y: float) -> None:
        self._push_undo()
        point = self.document.add_manual_point(x, y)
@ -1784,56 +1651,6 @@ class MainWindow(QMainWindow):
        self.status.setText(f"Добавлен свободный LED ID {point.source_id}: X={point.x:.3f}, Y={point.y:.3f}.")
        self._refresh_ui_state()
    def copy_selected_leds(self) -> bool:
        if not self._edit_mode_is_enabled():
            self.status.setText("Копирование LED доступно только в режиме редактирования.")
            self._refresh_ui_state()
            return False
        point_ids = self.canvas.selected_point_ids()
        if not point_ids:
            self.status.setText("Выберите светодиоды для копирования.")
            self._refresh_ui_state()
            return False
        self._copied_led_points = [deepcopy(self.document.get_point(point_id)) for point_id in point_ids]
        self._paste_sequence = 0
        self.status.setText(f"Скопировано светодиодов: {len(self._copied_led_points)}.")
        self._refresh_ui_state(point_ids)
        return True
    def paste_copied_leds(self) -> bool:
        if not self._edit_mode_is_enabled():
            self.status.setText("Вставка LED доступна только в режиме редактирования.")
            self._refresh_ui_state()
            return False
        if not self._copied_led_points:
            self.status.setText("Сначала скопируйте выбранные светодиоды.")
            self._refresh_ui_state()
            return False
        self._push_undo()
        self._paste_sequence += 1
        offset = float(self.document.grid_step_in_document_units()) * self._paste_sequence
        pasted = self.document.add_point_copies(
            self._copied_led_points,
            offset_x=offset,
            offset_y=-offset,
        )
        pasted_ids = [point.uid for point in pasted]
        self._dirty = True
        self.canvas.set_document(self.document, reset_view=False)
        self.canvas.select_points(pasted_ids)
        self.refresh_tree()
        self._on_selection_changed(pasted_ids)
        self.status.setText(
            f"Вставлено свободных светодиодов: {len(pasted)}. "
            f"Смещение: {self._paste_sequence} шаг(а) сетки вправо и вниз."
        )
        self._refresh_ui_state(pasted_ids)
        return True
    def _edit_mode_is_enabled(self) -> bool:
        action = self.actions.get("toggle_edit_mode")
        return bool(action is not None and action.isChecked())
    def edit_point_coordinates(self, point_id: int) -> None:
        if not 0 <= point_id < len(self.document.points):
            return
@ -2865,7 +2682,6 @@ class MainWindow(QMainWindow):
        has_visible_background = has_loaded_background and self.document.background.visible
        has_active_line = self._get_line_or_none(self.active_line_id) is not None
        has_selection = bool(point_ids)
        edit_mode_enabled = self._edit_mode_is_enabled()
        selected_has_assignment = any(
            self.document.get_point(point_id).line_id is not None
            or self.document.get_point(point_id).block_id is not None
@ -2893,14 +2709,12 @@ class MainWindow(QMainWindow):
        self.selection_label.setText(self._selection_summary(point_ids))
        state = {
-            "save": bool(has_points or self.document.comments or self.document.path is not None) and self._dirty,
+            "save": has_points and self._dirty,
-            "save_as": bool(has_points or self.document.comments or self.document.path is not None),
+            "save_as": has_points,
            "export_image": has_points,
            "generate_script": has_points,
            "undo": bool(self._undo_stack),
            "redo": bool(self._redo_stack),
            "copy_leds": edit_mode_enabled and has_selection,
            "paste_leds": edit_mode_enabled and bool(self._copied_led_points),
            "add_line": has_points and len(self.document.lines) < MAX_LINES,
            "add_led": True,
            "add_block": has_points and has_active_line,
@ -2913,7 +2727,7 @@ class MainWindow(QMainWindow):
            "delete_points": has_selection,
            "clear_all": has_lines,
            "clear_selection": has_selection,
-            "fit_view": has_points or has_visible_background or bool(self.document.comments),
+            "fit_view": has_points or has_visible_background,
            "grid": True,
            "background": True,
            "background_visible": has_loaded_background,
@ -3157,117 +2971,8 @@ class MainWindow(QMainWindow):
        )
        return answer == QMessageBox.StandardButton.Yes
    def check_updates(self) -> None:
        if self._update_busy:
            return
        self._update_manual_check = not bool(getattr(sys, "frozen", False)) or self.sender() is self.actions["check_updates"]
        self._update_busy = True
        self.actions["check_updates"].setEnabled(False)
        self.actions["install_update"].setEnabled(False)
        if self._update_manual_check:
            self.status.setText("Проверка обновлений...")
        def worker() -> None:
            try:
                self._update_signals.checked.emit(check_for_update(current_version()))
            except (UpdateError, OSError) as exc:
                self._update_signals.failed.emit(str(exc))
        Thread(target=worker, name="ledmapper-update-check", daemon=True).start()
    def _on_update_checked(self, info: UpdateInfo | None) -> None:
        self._update_busy = False
        self._update_info = info
        self.actions["check_updates"].setEnabled(True)
        self.actions["install_update"].setEnabled(info is not None and bool(getattr(sys, "frozen", False)))
        if info is None:
            if self._update_manual_check:
                show_information(self, "Обновления", f"Установлена актуальная версия {current_version()}.")
            return
        self.actions["install_update"].setText(f"Установить обновление {info.tag}")
        self.status.setText(f"Доступна версия {info.tag}. Меню «Справка» → «Установить обновление».")
        if not getattr(sys, "frozen", False) and self._update_manual_check:
            show_information(self, "Обновление", "Автоустановка доступна только в собранном EXE.")
    def install_update(self) -> None:
        info = self._update_info
        if info is None or self._update_busy:
            return
        try:
            executable = current_executable()
        except UpdateError as exc:
            show_warning(self, "Обновление", str(exc))
            return
        answer = ask_question(self, "Обновление LED Mapper", f"Скачать {info.asset_name} и перезапустить приложение?")
        if answer != QMessageBox.StandardButton.Yes:
            return
        self._update_busy = True
        self._update_cancel.clear()
        self.actions["check_updates"].setEnabled(False)
        self.actions["install_update"].setEnabled(False)
        self.status.setText(f"Загрузка {info.asset_name}: 0 %")
        def worker() -> None:
            try:
                downloaded = download_update(
                    info, executable.parent,
                    progress=self._update_signals.progress.emit,
                    cancelled=self._update_cancel.is_set,
                )
                if self._update_cancel.is_set():
                    downloaded.unlink(missing_ok=True)
                    return
                self._update_signals.downloaded.emit(downloaded)
            except UpdateCancelled:
                return
            except (UpdateError, OSError) as exc:
                self._update_signals.failed.emit(str(exc))
        Thread(target=worker, name="ledmapper-update-download", daemon=True).start()
    def _on_update_progress(self, percent: int) -> None:
        if self._update_info is not None:
            self.status.setText(f"Загрузка {self._update_info.asset_name}: {percent} %")
    def _on_update_downloaded(self, downloaded: Path) -> None:
        self._update_busy = False
        self.actions["check_updates"].setEnabled(True)
        self.actions["install_update"].setEnabled(True)
        info = self._update_info
        if info is None:
            downloaded.unlink(missing_ok=True)
            return
        if self._dirty:
            answer = ask_question(self, "Сохранить схему", "Перед перезапуском нужно сохранить изменения схемы. Сохранить сейчас?")
            if answer != QMessageBox.StandardButton.Yes:
                downloaded.unlink(missing_ok=True)
                return
            self.save_file()
            if self._dirty:
                downloaded.unlink(missing_ok=True)
                return
        try:
            launch_update(downloaded, info)
        except UpdateError as exc:
            downloaded.unlink(missing_ok=True)
            show_warning(self, "Обновление", str(exc))
            return
        self._installing_update = True
        self.close()
    def _on_update_failed(self, message: str) -> None:
        self._update_busy = False
        self.actions["check_updates"].setEnabled(True)
        self.actions["install_update"].setEnabled(
            self._update_info is not None and bool(getattr(sys, "frozen", False))
        )
        self.status.setText(f"Ошибка обновления: {message}")
        if self._update_manual_check or self._update_info is not None:
            show_warning(self, "Обновление", message)
    def closeEvent(self, event) -> None:  # noqa: ANN001
-        if self._installing_update or self._confirm_discard_changes("Закрыть приложение и потерять несохраненные изменения текущей карты?"):
+        if self._confirm_discard_changes("Закрыть приложение и потерять несохраненные изменения текущей карты?"):
            self._update_cancel.set()
            event.accept()
        else:
            event.ignore()
--- a/models.py
+++ b/models.py
@ -1,18 +1,12 @@
 from __future__ import annotations
 import base64
 import binascii
 import hashlib
 import json
 import math
 import mimetypes
 import os
 import re
 import tempfile
 import uuid
 from collections import deque
-from copy import deepcopy
+from dataclasses import dataclass, field
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
@ -27,11 +21,9 @@ MAX_NEIGHBOR_TOLERANCE_MM = 2.0
 METER_LIKE_MAX_SPAN = 10.0
 _DOCUMENT_KNOWN_FIELDS = {
    "background",
    "comments",
    "circles",
    "coordinate_unit",
    "grid_step_mm",
    "index_base",
    "leds",
    "lines",
    "unit",
@ -208,33 +200,11 @@ class BackgroundImage:
    scale_y_percent: float = 100.0
    opacity_percent: float = 100.0
    visible: bool = True
    embedded_image_base64: str = ""
    embedded_image_mime_type: str = ""
    embedded_image_name: str = ""
    embedded_image_sha256: str = ""
    @classmethod
    def from_payload(cls, payload) -> "BackgroundImage":  # noqa: ANN001
        if not isinstance(payload, dict):
            return cls()
        embedded = payload.get("embedded_image")
        embedded_data = ""
        embedded_mime_type = ""
        embedded_name = ""
        embedded_sha256 = ""
        if isinstance(embedded, dict):
            candidate_data = str(embedded.get("data") or "")
            try:
                decoded = base64.b64decode(candidate_data, validate=True) if candidate_data else b""
            except (binascii.Error, ValueError, TypeError):
                decoded = b""
            candidate_sha256 = str(embedded.get("sha256") or "").strip().lower()
            actual_sha256 = hashlib.sha256(decoded).hexdigest() if decoded else ""
            if decoded and (not candidate_sha256 or candidate_sha256 == actual_sha256):
                embedded_data = candidate_data
                embedded_mime_type = str(embedded.get("mime_type") or "application/octet-stream")
                embedded_name = Path(str(embedded.get("name") or "background")).name
                embedded_sha256 = actual_sha256
        scale = _optional_float(payload.get("scale_percent"))
        scale_x = _optional_float(payload.get("scale_x_percent"))
        scale_y = _optional_float(payload.get("scale_y_percent"))
@ -253,14 +223,10 @@ class BackgroundImage:
            scale_y_percent=max(1.0, float(scale_y)),
            opacity_percent=min(100.0, max(0.0, 100.0 if opacity is None else float(opacity))),
            visible=bool(payload.get("visible", True)),
            embedded_image_base64=embedded_data,
            embedded_image_mime_type=embedded_mime_type,
            embedded_image_name=embedded_name,
            embedded_image_sha256=embedded_sha256,
        )
-    def to_payload(self) -> dict[str, Any]:
+    def to_payload(self) -> dict[str, bool | float | str]:
-        payload: dict[str, Any] = {
+        return {
            "path": self.path,
            "offset_x": self.offset_x,
            "offset_y": self.offset_y,
@ -269,80 +235,9 @@ class BackgroundImage:
            "opacity_percent": self.opacity_percent,
            "visible": self.visible,
        }
        if self.has_embedded_image():
            payload["embedded_image"] = {
                "encoding": "base64",
                "mime_type": self.embedded_image_mime_type or "application/octet-stream",
                "name": self.embedded_image_name or "background",
                "sha256": self.embedded_image_sha256 or hashlib.sha256(self.embedded_image_bytes()).hexdigest(),
                "data": self.embedded_image_base64,
            }
        return payload
    def is_enabled(self) -> bool:
-        return bool(self.path) or self.has_embedded_image()
+        return bool(self.path)
    def has_embedded_image(self) -> bool:
        return bool(self.embedded_image_base64)
    def embedded_image_bytes(self) -> bytes:
        if not self.embedded_image_base64:
            return b""
        try:
            return base64.b64decode(self.embedded_image_base64, validate=True)
        except (binascii.Error, ValueError, TypeError):
            return b""
    def with_embedded_image(self, base_dir: Path | None = None) -> "BackgroundImage":
        if self.has_embedded_image() or not self.path:
            return self
        image_path = Path(self.path)
        if not image_path.is_absolute() and base_dir is not None:
            image_path = base_dir / image_path
        image_bytes = image_path.read_bytes()
        if not image_bytes:
            raise ValueError("Файл подложки пуст и не может быть встроен в схему.")
        mime_type = mimetypes.guess_type(image_path.name)[0] or "application/octet-stream"
        return replace(
            self,
            path="",
            embedded_image_base64=base64.b64encode(image_bytes).decode("ascii"),
            embedded_image_mime_type=mime_type,
            embedded_image_name=image_path.name,
            embedded_image_sha256=hashlib.sha256(image_bytes).hexdigest(),
        )
@dataclass
 class TextComment:
    id: str
    text: str
    x: float
    y: float
    extra_payload: dict[str, Any] = field(default_factory=dict)
    @classmethod
    def from_payload(cls, payload: dict[str, Any]) -> "TextComment":
        text, x, y = cls.validate(payload.get("text", ""), payload.get("x", 0), payload.get("y", 0))
        return cls(
            id=str(payload.get("id") or uuid.uuid4().hex), text=text, x=x, y=y,
            extra_payload={key: deepcopy(value) for key, value in payload.items()
                           if key not in {"id", "text", "x", "y"}},
        )
    @staticmethod
    def validate(text: str, x: float, y: float) -> tuple[str, float, float]:
        if not isinstance(text, str) or not text.strip():
            raise ValueError("Введите текст комментария.")
        x, y = float(x), float(y)
        if not math.isfinite(x) or not math.isfinite(y):
            raise ValueError("Координаты комментария должны быть конечными числами.")
        return text, x, y
    def to_payload(self) -> dict[str, Any]:
        text, x, y = self.validate(self.text, self.x, self.y)
        return {**deepcopy(self.extra_payload), "id": self.id, "text": text, "x": x, "y": y}
 class MappingDocument:
@ -351,28 +246,26 @@ class MappingDocument:
        self.collection_name = "circles"
        self.points: list[LedPoint] = []
        self.lines: list[LedLine] = []
        self.comments: list[TextComment] = []
        self.background = BackgroundImage()
        self.unfolding = UnfoldingDescription()
        self.coordinate_unit = "mm"
        self.grid_step_mm = DEFAULT_GRID_STEP_MM
        self.extra_payload: dict[str, Any] = {}
-        self._next_line_id = 0
+        self._next_line_id = 1
-        self._next_block_id = 0
+        self._next_block_id = 1
    def clear(self) -> None:
        self.path = None
        self.collection_name = "circles"
        self.points.clear()
        self.lines.clear()
        self.comments.clear()
        self.background = BackgroundImage()
        self.unfolding = UnfoldingDescription()
        self.coordinate_unit = "mm"
        self.grid_step_mm = DEFAULT_GRID_STEP_MM
        self.extra_payload.clear()
-        self._next_line_id = 0
+        self._next_line_id = 1
-        self._next_block_id = 0
+        self._next_block_id = 1
    def load(self, path: str | Path) -> None:
        self.clear()
@ -421,21 +314,8 @@ class MappingDocument:
            )
        self._canonicalize_coordinate_unit()
        comments_data = data.get("comments", [])
        if not isinstance(comments_data, list):
            raise ValueError("Поле comments должно содержать список комментариев.")
        seen_comment_ids: set[str] = set()
        for payload in comments_data:
            if not isinstance(payload, dict):
                raise ValueError("Комментарий должен быть объектом JSON.")
            comment = TextComment.from_payload(payload)
            if comment.id in seen_comment_ids:
                comment.id = uuid.uuid4().hex
            seen_comment_ids.add(comment.id)
            self.comments.append(comment)
        self._load_lines(data)
        self._migrate_legacy_index_base(data)
        self.background = BackgroundImage.from_payload(data.get("background"))
        self.unfolding = UnfoldingDescription.from_payload(data.get("unfolding"))
        self.unfolding.max_lines = MAX_LINES
@ -474,41 +354,6 @@ class MappingDocument:
            self.lines.append(line)
            self._next_line_id = max(self._next_line_id, line_id + 1)
    def _migrate_legacy_index_base(self, data: dict[str, Any]) -> None:
        """Однократно переводит старые 1-based ID, сохраняя физические адреса лент."""
        marker = data.get("index_base")
        if marker == 0:
            return
        if marker not in (None, 1):
            raise ValueError("Unsupported mapping index_base; expected 0 or 1.")
        identifiers = [line.id for line in self.lines]
        identifiers.extend(point.line_id for point in self.points if point.line_id is not None)
        if marker is None and (not identifiers or min(identifiers) == 0):
            return
        if identifiers and min(identifiers) < 1:
            return
        for line in self.lines:
            old_id = line.id
            line.id -= 1
            if re.fullmatch(r"(?:Линия|Line)\s+\d+", line.name):
                line.name = f"Линия {line.id}"
            if line.color == default_color(old_id):
                line.color = default_color(line.id)
            for block in line.blocks:
                block.id -= 1
                if re.fullmatch(r"(?:Блок|Block)\s+\d+", block.name):
                    block.name = f"Блок {block.id}"
        for point in self.points:
            if point.line_id is not None:
                point.line_id -= 1
            if point.block_id is not None:
                point.block_id -= 1
        self._next_line_id = max((line.id for line in self.lines), default=-1) + 1
        self._next_block_id = max(
            (block.id for line in self.lines for block in line.blocks),
            default=-1,
        ) + 1
    def _rebuild_lines_from_points(self) -> None:
        for line_id in sorted({point.line_id for point in self.points if point.line_id is not None}):
            line = LedLine(int(line_id), f"Line {line_id}", default_color(int(line_id)))
@ -530,7 +375,7 @@ class MappingDocument:
                    if point.line_id == line_id
                ]
                if ids:
-                    line.blocks.append(LedBlock(self._next_block_id, f"Блок {self._next_block_id}", ids))
+                    line.blocks.append(LedBlock(self._next_block_id, "Block 1", ids))
                    self._next_block_id += 1
            for block_id in block_ids:
                ids = [
@ -552,9 +397,7 @@ class MappingDocument:
    def save(self, path: str | Path) -> None:
        path = Path(path)
        self.reindex_all()
-        source_base_dir = self.path.parent if self.path is not None else path.parent
+        payload = self.to_payload()
        background_for_save = self.background.with_embedded_image(source_base_dir)
        payload = self.to_payload(background=background_for_save)
        serialized = json.dumps(payload, ensure_ascii=False, indent=2, allow_nan=False)
        if json.loads(serialized) != payload:
            raise ValueError("Не удалось без потерь сериализовать схему.")
@ -579,7 +422,6 @@ class MappingDocument:
            if temporary_path is not None and temporary_path.exists():
                temporary_path.unlink()
        self.path = path
        self.background = background_for_save
    def to_payload(
        self,
@ -587,7 +429,6 @@ class MappingDocument:
        point_payloads: list[dict[str, Any]] | None = None,
        lines_payload: list[dict[str, Any]] | None = None,
        collection_name: str | None = None,
        background: BackgroundImage | None = None,
    ) -> dict[str, Any]:
        payload = dict(self.extra_payload)
        payload[collection_name or self.collection_name] = (
@ -598,10 +439,8 @@ class MappingDocument:
        payload["unfolding"] = self.describe_unfolding().to_payload()
        payload["coordinate_unit"] = self._coordinate_unit_for_save()
        payload["grid_step_mm"] = self.grid_step_mm
-        payload["index_base"] = 0
+        payload["background"] = self.background.to_payload()
        payload["background"] = (self.background if background is None else background).to_payload()
        payload["lines"] = self.lines_to_payload() if lines_payload is None else lines_payload
        payload["comments"] = [comment.to_payload() for comment in self.comments]
        return payload
    def point_to_payload(self, point: LedPoint, *, id_value: int | None = None) -> dict[str, Any]:
@ -645,32 +484,6 @@ class MappingDocument:
            for line in self.lines
        ]
    def add_comment(self, text: str, x: float, y: float) -> TextComment:
        text, x, y = TextComment.validate(text, x, y)
        comment = TextComment(uuid.uuid4().hex, text, x, y)
        self.comments.append(comment)
        return comment
    def get_comment(self, comment_id: str) -> TextComment:
        for comment in self.comments:
            if comment.id == comment_id:
                return comment
        raise KeyError(comment_id)
    def update_comment(
        self, comment_id: str, *, text: str | None = None,
        x: float | None = None, y: float | None = None,
    ) -> None:
        comment = self.get_comment(comment_id)
        values = TextComment.validate(
            comment.text if text is None else text,
            comment.x if x is None else x, comment.y if y is None else y,
        )
        comment.text, comment.x, comment.y = values
    def remove_comment(self, comment_id: str) -> None:
        self.comments.remove(self.get_comment(comment_id))
    def add_line(self) -> LedLine:
        line_limit = self._line_limit()
        if len(self.lines) >= line_limit:
@ -697,37 +510,6 @@ class MappingDocument:
        self.points.append(point)
        return point
    def add_point_copies(
        self,
        templates: list[LedPoint],
        *,
        offset_x: float,
        offset_y: float,
    ) -> list[LedPoint]:
        if not templates:
            return []
        next_source_id = max((point.source_id for point in self.points), default=-1) + 1
        copies: list[LedPoint] = []
        for template in list(templates):
            x = float(template.x) + float(offset_x)
            y = float(template.y) + float(offset_y)
            row, col = self._grid_cell_for_coordinate(x, y)
            point = LedPoint(
                uid=len(self.points),
                source_id=next_source_id,
                x=x,
                y=y,
                row=row,
                col=col,
                coordinate_unit=self._coordinate_unit_for_save(),
                manual=True,
                extra_payload=deepcopy(template.extra_payload),
            )
            self.points.append(point)
            copies.append(point)
            next_source_id += 1
        return copies
    def update_point_position(self, point_id: int, x: float | None = None, y: float | None = None) -> None:
        point = self.get_point(point_id)
        if x is not None:
@ -768,7 +550,7 @@ class MappingDocument:
            point_id for point_id in point_ids if 0 <= point_id < len(self.points)
        ])
        self._detach_points_from_blocks(clean_point_ids)
-        block = LedBlock(len(line.blocks), f"Блок {len(line.blocks)}", clean_point_ids)
+        block = LedBlock(len(line.blocks) + 1, f"Блок {len(line.blocks) + 1}", clean_point_ids)
        insert_index = len(line.blocks)
        if after_block_id is not None:
            for index, existing_block in enumerate(line.blocks):
@ -912,14 +694,14 @@ class MappingDocument:
        assigned = sum(1 for point in self.points if point.line_id is not None or point.block_id is not None)
        self.lines.clear()
        self._clear_points([point.uid for point in self.points])
-        self._next_line_id = 0
+        self._next_line_id = 1
-        self._next_block_id = 0
+        self._next_block_id = 1
        return assigned
    def renumber_lines(self) -> None:
        self.order_lines_clockwise()
        id_map: dict[int, int] = {}
-        for new_id, line in enumerate(self.lines):
+        for new_id, line in enumerate(self.lines, start=1):
            old_id = line.id
            id_map[old_id] = new_id
            line.id = new_id
@ -931,7 +713,7 @@ class MappingDocument:
            if point.line_id in id_map:
                point.line_id = id_map[point.line_id]
-        self._next_line_id = len(self.lines)
+        self._next_line_id = len(self.lines) + 1
    def _validate_line_limit(self) -> None:
        line_limit = self._line_limit()
@ -1098,7 +880,7 @@ class MappingDocument:
        start_id = start_ids[0] if start_ids else point_ids[0]
        groups = self.route_groups_from_points(point_ids, start_id)
        line.blocks.clear()
-        for block_number, group in enumerate(groups):
+        for block_number, group in enumerate(groups, start=1):
            line.blocks.append(LedBlock(block_number, f"Блок {block_number}", group))
        self.reindex_all()
        return len(groups)
@ -1110,7 +892,7 @@ class MappingDocument:
        self._detach_points_from_blocks([point_id for group in groups for point_id in group])
        line = self.get_line(line_id)
        for group_ids in groups:
-            block_number = len(line.blocks)
+            block_number = len(line.blocks) + 1
            block = LedBlock(block_number, f"Блок {block_number}", unique_in_order(group_ids))
            line.blocks.append(block)
        self.order_blocks_clockwise(line_id, reorder_leds=False)
@ -1220,7 +1002,7 @@ class MappingDocument:
    @staticmethod
    def renumber_blocks(line: LedLine) -> None:
-        for block_number, block in enumerate(line.blocks):
+        for block_number, block in enumerate(line.blocks, start=1):
            block.id = block_number
            if not block.name or re.match(r"^(Блок|Block)\s+\d+$", block.name):
                block.name = f"Блок {block_number}"
@ -1329,7 +1111,7 @@ def _correlation_sign(value: float) -> int:
 def default_color(line_id: int) -> str:
    colors = ["#e11d48", "#2563eb", "#16a34a", "#f59e0b", "#7c3aed", "#0891b2"]
-    return colors[line_id % len(colors)]
+    return colors[(line_id - 1) % len(colors)]
 def distance(a: LedPoint, b: LedPoint) -> float:
--- a/panel_mapping_generator.py
+++ b/panel_mapping_generator.py
@ -205,7 +205,7 @@ def normalize_document_points(document: MappingDocument) -> list[PanelLedPoint]:
            generated_id=index,
            source_id=point.source_id,
            input_index=point.uid,
-            strip=point.line_id,
+            strip=(point.line_id - 1) if point.line_id is not None else None,
            led_id=point.line_index,
            x_mm=point.x * scale,
            y_mm=point.y * scale,
@ -586,8 +586,6 @@ def write_readme(path: Path) -> None:
                "- `validation_report.txt` — результаты проверки маршрутов и ячеек.",
                "- `README.md` — описание набора файлов.",
                "",
                "Физический адрес ленты в `vm_map.h`: `strip = line_id`; нумерация начинается с `0`.",
                "",
                "Устаревший `virtual_matrix_legacy.ino.txt` больше не создаётся.",
                "",
            ]
--- a/qa_smoke.py
+++ b/qa_smoke.py
--- a/settings.py
+++ b/settings.py
@ -18,8 +18,6 @@ SHORTCUT_DEFINITIONS: list[tuple[str, str, str]] = [
    ("settings", "Параметры", "Ctrl+,"),
    ("undo", "Отменить", "Ctrl+Z"),
    ("redo", "Повторить", "Ctrl+Y"),
    ("copy_leds", "Копировать светодиоды", "Ctrl+C"),
    ("paste_leds", "Вставить светодиоды", "Ctrl+V"),
    ("delete", "Удалить фиксацию", "Del"),
    ("delete_points", "Удалить точки", "Ctrl+Del"),
    ("clear_all", "Удалить все", "Shift+Del"),
@ -44,7 +42,7 @@ SHORTCUT_DEFINITIONS: list[tuple[str, str, str]] = [
    ("brush", "Кисть", "B"),
 ]
 DEFAULT_SHORTCUTS = {key: shortcut for key, _title, shortcut in SHORTCUT_DEFINITIONS}
-SETTINGS_VERSION = 4
+SETTINGS_VERSION = 3
 SHORTCUT_DEFAULTS_MIGRATION_VERSION = 2
 DEFAULT_GRID_STEP_MM = 34.0
 MIN_GRID_STEP_MM = 1.0
@ -52,9 +50,6 @@ MAX_GRID_STEP_MM = 1000.0
 DEFAULT_LED_POINT_DIAMETER_PX = 9
 MIN_LED_POINT_DIAMETER_PX = 1
 MAX_LED_POINT_DIAMETER_PX = 64
 DEFAULT_LED_INDEX_FONT_SIZE_PX = 12
 MIN_LED_INDEX_FONT_SIZE_PX = 6
 MAX_LED_INDEX_FONT_SIZE_PX = 64
@dataclass
@ -66,7 +61,6 @@ class AppSettings:
    show_led_ids_by_default: bool = True
    grid_step_mm: float = DEFAULT_GRID_STEP_MM
    led_point_diameter_px: int = DEFAULT_LED_POINT_DIAMETER_PX
    led_index_font_size_px: int = DEFAULT_LED_INDEX_FONT_SIZE_PX
    zoom_focus_pull: int = 35
    pan_mode: str = "middle_space"
    instant_space_pan: bool = False
@ -103,12 +97,6 @@ class AppSettings:
            MAX_LED_POINT_DIAMETER_PX,
            DEFAULT_LED_POINT_DIAMETER_PX,
        )
        settings.led_index_font_size_px = clamp_int(
            settings.led_index_font_size_px,
            MIN_LED_INDEX_FONT_SIZE_PX,
            MAX_LED_INDEX_FONT_SIZE_PX,
            DEFAULT_LED_INDEX_FONT_SIZE_PX,
        )
        settings.zoom_focus_pull = clamp_int(settings.zoom_focus_pull, 0, 100, cls.zoom_focus_pull)
        settings.brush_radius = clamp_int(settings.brush_radius, 4, 80, cls.brush_radius)
        if settings.theme not in {"system", "light", "dark"}:
--- a/settings_dialog.py
+++ b/settings_dialog.py
@ -30,14 +30,11 @@ try:
    from .localization import localize_dialog_buttons, show_warning
    from .settings import (
        DEFAULT_GRID_STEP_MM,
        DEFAULT_LED_INDEX_FONT_SIZE_PX,
        DEFAULT_LED_POINT_DIAMETER_PX,
        DEFAULT_SHORTCUTS,
        MAX_GRID_STEP_MM,
        MAX_LED_INDEX_FONT_SIZE_PX,
        MAX_LED_POINT_DIAMETER_PX,
        MIN_GRID_STEP_MM,
        MIN_LED_INDEX_FONT_SIZE_PX,
        MIN_LED_POINT_DIAMETER_PX,
        SETTINGS_VERSION,
        SHORTCUT_DEFINITIONS,
@ -47,14 +44,11 @@ except ImportError:
    from localization import localize_dialog_buttons, show_warning
    from settings import (
        DEFAULT_GRID_STEP_MM,
        DEFAULT_LED_INDEX_FONT_SIZE_PX,
        DEFAULT_LED_POINT_DIAMETER_PX,
        DEFAULT_SHORTCUTS,
        MAX_GRID_STEP_MM,
        MAX_LED_INDEX_FONT_SIZE_PX,
        MAX_LED_POINT_DIAMETER_PX,
        MIN_GRID_STEP_MM,
        MIN_LED_INDEX_FONT_SIZE_PX,
        MIN_LED_POINT_DIAMETER_PX,
        SETTINGS_VERSION,
        SHORTCUT_DEFINITIONS,
@ -101,17 +95,6 @@ class SettingsDialog(QDialog):
        self.led_point_diameter_reset.clicked.connect(
            lambda: self.led_point_diameter.setValue(DEFAULT_LED_POINT_DIAMETER_PX)
        )
        self.led_index_font_size = QSpinBox()
        self.led_index_font_size.setRange(
            MIN_LED_INDEX_FONT_SIZE_PX,
            MAX_LED_INDEX_FONT_SIZE_PX,
        )
        self.led_index_font_size.setSuffix(" px")
        self.led_index_font_size.setValue(settings.led_index_font_size_px)
        self.led_index_font_size_reset = QPushButton("Сбросить")
        self.led_index_font_size_reset.clicked.connect(
            lambda: self.led_index_font_size.setValue(DEFAULT_LED_INDEX_FONT_SIZE_PX)
        )
        self.zoom_pull = QSpinBox()
        self.zoom_pull.setRange(0, 100)
        self.zoom_pull.setSuffix(" %")
@ -176,7 +159,6 @@ class SettingsDialog(QDialog):
            show_led_ids_by_default=self.show_led_ids.isChecked(),
            grid_step_mm=self.grid_step.value(),
            led_point_diameter_px=self.led_point_diameter.value(),
            led_index_font_size_px=self.led_index_font_size.value(),
            zoom_focus_pull=self.zoom_pull.value(),
            pan_mode=str(self.pan_mode.currentData()),
            instant_space_pan=self.instant_space_pan.isChecked(),
@ -198,10 +180,6 @@ class SettingsDialog(QDialog):
            "Диаметр LED-точек",
            self._setting_with_reset(self.led_point_diameter, self.led_point_diameter_reset),
        )
        layout.addRow(
            "Размер текста индексов LED",
            self._setting_with_reset(self.led_index_font_size, self.led_index_font_size_reset),
        )
        layout.addRow("Притяжение зума к курсору", self.zoom_pull)
        layout.addRow(QLabel("0% оставляет центр спокойнее, 100% сильнее тянет схему к курсору."))
        return page
--- a/update_service.py
+++ b/update_service.py
@ -1,348 +0,0 @@
 """Безопасная проверка и установка Windows-релизов LED Mapper."""
 from __future__ import annotations
 import json
 import os
 import platform
 import re
 import subprocess
 import sys
 import tempfile
 import uuid
 from dataclasses import dataclass
 from pathlib import Path
 from typing import BinaryIO, Callable
 from urllib.parse import urlparse
 from urllib.request import Request, urlopen
 try:
    from .version import __version__
 except ImportError:
    from version import __version__
 RELEASE_API_URL = "https://git.robotail.pro/api/v1/repos/Robotail/LED-mapper/releases/latest"
 RELEASE_PAGE_URL = "https://git.robotail.pro/Robotail/LED-mapper/releases"
 RELEASE_HOST = "git.robotail.pro"
 READY_ENV = "LEDMAPPER_UPDATE_READY_FILE"
 MAX_METADATA_BYTES = 1024 * 1024
 MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024
 CHUNK_BYTES = 1024 * 1024
 VERSION_RE = re.compile(r"v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\Z")
 EXECUTABLE_RE = re.compile(r"LEDMapper-(v\d+\.\d+\.\d+)\.exe\Z", re.IGNORECASE)
 class UpdateError(RuntimeError):
    """Проверка, загрузка или установка обновления не выполнена."""
 class UpdateCancelled(UpdateError):
    """Загрузка отменена пользователем."""
@dataclass(frozen=True)
 class UpdateInfo:
    tag: str
    version: str
    asset_name: str
    download_url: str
    size: int
 def parse_version(value: str) -> tuple[int, int, int]:
    match = VERSION_RE.fullmatch(value.strip())
    if match is None:
        raise UpdateError("Версия релиза должна иметь формат vX.Y.Z")
    return tuple(int(part) for part in match.groups())
 def current_version() -> str:
    if getattr(sys, "frozen", False):
        bundle_dir = getattr(sys, "_MEIPASS", None)
        if bundle_dir is not None:
            try:
                bundled_version = (Path(bundle_dir) / "ledmapper-build-version.txt").read_text(encoding="utf-8").strip()
                if VERSION_RE.fullmatch(bundled_version):
                    return bundled_version
            except OSError:
                pass
        match = EXECUTABLE_RE.fullmatch(Path(sys.executable).name)
        if match is not None:
            return match.group(1)
    return __version__
 def _trusted_url(value: str) -> bool:
    parsed = urlparse(value)
    return (
        parsed.scheme == "https"
        and parsed.hostname == RELEASE_HOST
        and parsed.port in (None, 443)
        and not parsed.username
        and not parsed.password
        and not parsed.fragment
    )
 def check_for_update(
    installed_version: str,
    *,
    opener: Callable[..., BinaryIO] | None = None,
    timeout: float = 10.0,
 ) -> UpdateInfo | None:
    """Возвращает только новый релиз с ровно одним подходящим Windows EXE."""
    installed = parse_version(installed_version)
    if platform.system() != "Windows":
        raise UpdateError("Автообновление доступно только в Windows")
    request = Request(
        RELEASE_API_URL,
        headers={"Accept": "application/json", "User-Agent": "LEDMapper-Updater"},
    )
    try:
        with (opener or urlopen)(request, timeout=timeout) as response:
            if not _trusted_url(response.geturl()):
                raise UpdateError("Сервер релизов перенаправил запрос на другой сайт")
            payload = response.read(MAX_METADATA_BYTES + 1)
        if len(payload) > MAX_METADATA_BYTES:
            raise UpdateError("Ответ сервера релизов слишком велик")
        release = json.loads(payload)
    except UpdateError:
        raise
    except (OSError, ValueError, TypeError) as exc:
        raise UpdateError(f"Не удалось проверить обновления: {exc}") from exc
    if not isinstance(release, dict) or release.get("draft") or release.get("prerelease"):
        raise UpdateError("Сервер не вернул опубликованный стабильный релиз")
    tag = release.get("tag_name")
    if not isinstance(tag, str) or not tag.startswith("v"):
        raise UpdateError("У релиза отсутствует корректный тег")
    remote = parse_version(tag)
    if remote <= installed:
        return None
    expected_name = f"LEDMapper-{tag}.exe"
    assets = release.get("assets")
    if not isinstance(assets, list):
        raise UpdateError("У релиза отсутствует список артефактов")
    matching = [asset for asset in assets if isinstance(asset, dict) and asset.get("name") == expected_name]
    if len(matching) != 1:
        raise UpdateError(f"Не найден Windows-артефакт {expected_name}")
    asset = matching[0]
    download_url = asset.get("browser_download_url")
    expected_path = f"/Robotail/LED-mapper/releases/download/{tag}/{expected_name}"
    if not isinstance(download_url, str) or not _trusted_url(download_url) or urlparse(download_url).path != expected_path:
        raise UpdateError("Релиз содержит неожиданный адрес артефакта")
    size = asset.get("size")
    if isinstance(size, bool) or not isinstance(size, int) or not 0 < size <= MAX_DOWNLOAD_BYTES:
        raise UpdateError("Релиз содержит недопустимый размер артефакта")
    return UpdateInfo(tag, tag.removeprefix("v"), expected_name, download_url, size)
 def _check_executable(path: Path) -> None:
    with path.open("rb") as source:
        header = source.read(64)
        if len(header) < 64 or header[:2] != b"MZ":
            raise UpdateError("Скачанный файл не является Windows EXE")
        pe_offset = int.from_bytes(header[0x3C:0x40], "little")
        if not 64 <= pe_offset <= 1024 * 1024:
            raise UpdateError("Некорректный заголовок Windows EXE")
        source.seek(pe_offset)
        if source.read(4) != b"PE\x00\x00":
            raise UpdateError("Некорректный заголовок Windows EXE")
        if source.read(2) != b"\x64\x86":
            raise UpdateError("Обновление не предназначено для Windows x64")
 def download_update(
    info: UpdateInfo,
    directory: Path,
    *,
    opener: Callable[..., BinaryIO] | None = None,
    progress: Callable[[int], None] | None = None,
    cancelled: Callable[[], bool] | None = None,
    timeout: float = 30.0,
 ) -> Path:
    """Скачивает артефакт в отдельный временный файл и проверяет размер/PE."""
    target_dir = directory.resolve()
    if not target_dir.is_dir():
        raise UpdateError("Каталог приложения не найден")
    if not os.access(target_dir, os.W_OK):
        raise UpdateError("Нет прав на запись в каталог приложения")
    if not _trusted_url(info.download_url) or urlparse(info.download_url).path != (
        f"/Robotail/LED-mapper/releases/download/{info.tag}/{info.asset_name}"
    ):
        raise UpdateError("Недопустимый адрес загрузки обновления")
    expected_path = f"/Robotail/LED-mapper/releases/download/{info.tag}/{info.asset_name}"
    path: Path | None = None
    received = 0
    request = Request(info.download_url, headers={"User-Agent": "LEDMapper-Updater"})
    try:
        with (opener or urlopen)(request, timeout=timeout) as response:
            if not _trusted_url(response.geturl()):
                raise UpdateError("Загрузка перенаправлена на другой сайт")
            final_path = urlparse(response.geturl()).path
            if final_path == "/user/login":
                raise UpdateError("Release-артефакты недоступны без авторизации")
            if final_path != expected_path:
                raise UpdateError("Загрузка перенаправлена на неожиданный адрес")
            content_length = getattr(response, "headers", {}).get("Content-Length")
            if content_length is not None:
                try:
                    declared_size = int(content_length)
                except (TypeError, ValueError) as exc:
                    raise UpdateError("Сервер вернул некорректный размер обновления") from exc
                if declared_size != info.size:
                    raise UpdateError("Размер обновления не совпадает с данными релиза")
            with tempfile.NamedTemporaryFile(
                mode="wb", dir=target_dir, prefix=".ledmapper-update-", suffix=".download", delete=False
            ) as output:
                path = Path(output.name)
                while True:
                    if cancelled is not None and cancelled():
                        raise UpdateCancelled("Загрузка обновления отменена")
                    chunk = response.read(CHUNK_BYTES)
                    if not chunk:
                        break
                    received += len(chunk)
                    if received > MAX_DOWNLOAD_BYTES or received > info.size:
                        raise UpdateError("Артефакт превышает объявленный размер")
                    output.write(chunk)
                    if progress is not None:
                        progress(min(received * 100 // info.size, 100))
                output.flush()
                os.fsync(output.fileno())
        if received != info.size:
            raise UpdateError("Артефакт скачан не полностью")
        _check_executable(path)
        if progress is not None:
            progress(100)
        return path
    except (UpdateError, OSError) as exc:
        if path is not None:
            path.unlink(missing_ok=True)
        if isinstance(exc, UpdateError):
            raise
        raise UpdateError(f"Не удалось скачать обновление: {exc}") from exc
 def current_executable() -> Path:
    if not getattr(sys, "frozen", False):
        raise UpdateError("Установка обновления доступна только в собранном EXE")
    return Path(sys.executable).resolve()
 def signal_update_ready() -> None:
    marker = os.environ.pop(READY_ENV, None)
    if marker is None:
        return
    try:
        path = Path(marker).resolve()
        if path.parent != current_executable().parent or not path.name.startswith(".ledmapper-ready-"):
            return
        path.write_text(str(os.getpid()), encoding="ascii")
    except (OSError, UpdateError):
        pass
 def _write_windows_updater(path: Path) -> None:
    script = r'''param(
    [int]$ApplicationProcessId,
    [string]$Source,
    [string]$OldTarget,
    [string]$NewTarget,
    [string]$Backup,
    [string]$ReadyFile
 )
 $ErrorActionPreference = "Stop"
 $applicationDirectory = Split-Path -Parent $OldTarget
 $errorLog = Join-Path $applicationDirectory "update-error.log"
 $restarted = $null
 $oldMoved = $false
 $newMoved = $false
 try {
    Wait-Process -Id $ApplicationProcessId -ErrorAction SilentlyContinue
    # Родительский процесс PyInstaller может ещё удерживать EXE при очистке.
    $moveDeadline = (Get-Date).AddSeconds(30)
    while (-not $oldMoved) {
        try {
            Move-Item -LiteralPath $OldTarget -Destination $Backup -ErrorAction Stop
            $oldMoved = $true
        } catch {
            if ((Get-Date) -ge $moveDeadline) { throw }
            Start-Sleep -Milliseconds 250
        }
    }
    if (Test-Path -LiteralPath $NewTarget) { throw "Целевой EXE уже существует" }
    Move-Item -LiteralPath $Source -Destination $NewTarget -ErrorAction Stop
    $newMoved = $true
    $env:LEDMAPPER_UPDATE_READY_FILE = $ReadyFile
    $env:PYINSTALLER_RESET_ENVIRONMENT = "1"
    $restarted = Start-Process -FilePath $NewTarget -WorkingDirectory $applicationDirectory -PassThru
    $deadline = (Get-Date).AddSeconds(60)
    while (-not (Test-Path -LiteralPath $ReadyFile -PathType Leaf)) {
        if ($restarted.HasExited) { throw "Новая версия завершилась до открытия окна" }
        if ((Get-Date) -ge $deadline) { throw "Новая версия не подтвердила запуск" }
        Start-Sleep -Milliseconds 250
    }
    if ($restarted.HasExited) { throw "Новая версия завершилась сразу после запуска" }
    Remove-Item -LiteralPath $ReadyFile -Force -ErrorAction SilentlyContinue
    Remove-Item -LiteralPath $Backup -Force -ErrorAction SilentlyContinue
    Remove-Item -LiteralPath $MyInvocation.MyCommand.Path -Force -ErrorAction SilentlyContinue
 } catch {
    $failure = $_.ToString()
    if ($restarted -and -not $restarted.HasExited) {
        & taskkill.exe /PID $restarted.Id /T /F *> $null
    }
    if ($newMoved -and (Test-Path -LiteralPath $NewTarget)) {
        Remove-Item -LiteralPath $NewTarget -Force -ErrorAction SilentlyContinue
    }
    if ($oldMoved -and (Test-Path -LiteralPath $Backup)) {
        Move-Item -LiteralPath $Backup -Destination $OldTarget -Force -ErrorAction SilentlyContinue
    }
    Remove-Item -LiteralPath $ReadyFile -Force -ErrorAction SilentlyContinue
    $failure | Out-File -LiteralPath $errorLog -Encoding utf8
    Remove-Item -LiteralPath $MyInvocation.MyCommand.Path -Force -ErrorAction SilentlyContinue
    exit 1
 }
 '''
    path.write_text(script, encoding="utf-8-sig", newline="\r\n")
 def launch_update(downloaded: Path, info: UpdateInfo, *, process_id: int | None = None) -> None:
    """Запускает отдельный helper; замену EXE он делает после выхода приложения."""
    old_target = current_executable()
    source = downloaded.resolve()
    if platform.system() != "Windows":
        raise UpdateError("Установка обновления доступна только в Windows")
    if not os.access(old_target.parent, os.W_OK):
        raise UpdateError("Нет прав на замену приложения")
    if source.parent != old_target.parent or not source.is_file() or not source.name.startswith(".ledmapper-update-"):
        raise UpdateError("Скачанный файл должен находиться рядом с приложением")
    if not EXECUTABLE_RE.fullmatch(info.asset_name):
        raise UpdateError("Недопустимое имя Windows-артефакта")
    new_target = old_target
    if source.stat().st_size != info.size:
        raise UpdateError("Размер скачанного артефакта изменился")
    _check_executable(source)
    token = uuid.uuid4().hex
    script_path = old_target.parent / f".ledmapper-updater-{token}.ps1"
    backup_path = old_target.parent / f".ledmapper-backup-{token}.exe"
    ready_path = old_target.parent / f".ledmapper-ready-{token}"
    try:
        _write_windows_updater(script_path)
        creation_flags = (
            getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
            | getattr(subprocess, "CREATE_NO_WINDOW", 0)
        )
        subprocess.Popen(
            [
                "powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File",
                str(script_path), str(process_id or os.getpid()), str(source), str(old_target),
                str(new_target), str(backup_path), str(ready_path),
            ],
            close_fds=True,
            creationflags=creation_flags,
        )
    except (OSError, UpdateError) as exc:
        script_path.unlink(missing_ok=True)
        if isinstance(exc, UpdateError):
            raise
        raise UpdateError(f"Не удалось запустить установщик: {exc}") from exc
--- a/version.py
+++ b/version.py
@ -1,3 +0,0 @@
 """Текущая версия приложения; обновляется при публикации релиза."""
 __version__ = "3.5.0"
`@ -1,3 +1 @@`
	`"""LED Mapper Editor application package."""`	`"""LED Mapper Editor application package."""`

	`from .version import __version__`
		`@ -1,3 +0,0 @@`
			`"""Текущая версия приложения; обновляется при публикации релиза."""`

			`__version__ = "3.5.0"`