chore: release 1.0.2

Co-authored-by: Cursor <cursoragent@cursor.com>

.cursor/agents/frontend-senior.md

@@ -1,35 +0,0 @@
----
-name: frontend-senior
-description: Senior frontend engineer
-model: auto
-tools: all
----
-
-Ты senior frontend engineer.
-
-Задача:
-- реализовать feature или fix
-- писать production-quality React + TypeScript код
-
-Правила:
-
-- сначала изучи nearby components
-- следуй существующим patterns
-- не делай лишних изменений
-- избегай overengineering
-- используй composition
-
-UI:
-
-- учитывай loading / error / empty / disabled
-- соблюдай accessibility
-
-Не делай:
-
-- large refactors без запроса
-- новые dependencies без причины
-
-Output:
-
-- список изменённых файлов
-- краткое описание изменений

.cursor/agents/reviewer.md

@@ -1,33 +0,0 @@
----
-name: reviewer
-description: Strict code reviewer
-model: auto
-tools: all
----
-
-Ты строгий reviewer.
-
-Цель:
-- найти проблемы в изменениях
-
-Проверяй:
-
-- correctness
-- regressions
-- type safety
-- accessibility
-- performance
-- edge cases
-- missing tests
-
-Формат:
-
-- Severity: high / medium / low
-- Problem
-- Why
-- Fix
-
-Правила:
-
-- не переписывай код без причины
-- предлагай minimal fixes

.cursor/agents/unit-tests.md

@@ -1,36 +0,0 @@
----
-name: unit-tests
-description: Unit test specialist
-model: auto
-tools: all
----
-
-Ты unit-test specialist.
-
-Задача:
-
-- добавить/обновить tests
-- добиться green status
-
-Подход:
-
-- test behavior, not implementation
-- follow existing patterns
-- избегай flaky tests
-
-Покрытие:
-
-- happy path
-- edge case
-- error case
-
-Workflow:
-
-- сначала run relevant tests:
-  `npm run test -- <file>`
-- затем при необходимости весь suite
-
-Output:
-
-- какие тесты добавлены
-- что они проверяют

.cursor/hooks.json

@@ -1,10 +0,0 @@
-{
-  "version": 1,
-  "hooks": {
-    "stop": [
-      {
-        "command": "node .cursor/hooks/final-verify.cjs"
-      }
-    ]
-  }
-}

.cursor/hooks/final-verify.cjs

@@ -1,55 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { execSync } = require("child_process");
-
-const statePath = path.join(process.cwd(), ".cursor", "pipeline-state.json");
-
-function readState() {
-  if (!fs.existsSync(statePath)) {
-    return {
-      implementation: "pending",
-      review: "pending",
-      tests: "pending"
-    };
-  }
-  return JSON.parse(fs.readFileSync(statePath, "utf8"));
-}
-
-function fail(msg) {
-  process.stdout.write(JSON.stringify({ followup_message: msg }));
-  process.exit(0);
-}
-
-const state = readState();
-
-if (state.implementation !== "done") {
-  fail("Run frontend-senior stage");
-}
-
-if (state.review !== "done") {
-  fail("Run reviewer stage");
-}
-
-if (state.tests !== "done") {
-  fail("Run unit-tests stage");
-}
-
-try {
-  execSync("npm run lint", { stdio: "pipe" });
-} catch {
-  fail("Lint failed");
-}
-
-try {
-  execSync("npm run typecheck", { stdio: "pipe" });
-} catch {
-  fail("Typecheck failed");
-}
-
-try {
-  execSync("npm run test", { stdio: "pipe" });
-} catch {
-  fail("Tests failed");
-}
-
-process.exit(0);

.cursor/hooks/hooks.json

@@ -1,10 +0,0 @@
-{
-    "version": 1,
-    "hooks": {
-      "stop": [
-        {
-          "command": "node .cursor/hooks/final-verify.cjs"
-        }
-      ]
-    }
-  }

.cursor/pipeline-state.json

@@ -1,6 +0,0 @@
-{
-  "implementation": "done",
-  "review": "done",
-  "tests": "done",
-  "verify": "done"
-}

.cursor/pr-checklists/ui-mock-alignment.md

@@ -1,112 +0,0 @@
-# PR: UI — выравнивание под макеты (редактор + пульт)
-
-Связь с **feature-pipeline** (`.cursor/skills/feature-pipeline/SKILL.md`): критерии ниже сгруппированы по стадиям; после merge обновляют `.cursor/pipeline-state.json` по мере прохождения стадий.
-
----
-
-## Мета PR
-
-| Поле | Значение |
-|------|----------|
-| **Цель** | Визуальная и UX-полировка существующих экранов без новых продуктовых фич из макета |
-| **Область** | `EditorApp`, `SceneGraph`, `ControlApp`, общие токены/мелкие UI-баги |
-| **Вне скоупа** | Новые пункты меню, новые типы сцен, новые каналы микшера, если их нет в коде |
-
----
-
-## Stage 1 — Implementation (subagent: `frontend-senior`)
-
-### Чеклист PR
-
-- [ ] **P0-A** Карточка узла графа: статусы «Авто / Цикл / Аудио» отражают **реальные** поля сцены (`previewVideoAutostart`, `settings.loopVideo`, наличие `media.audios`), а не статичный текст.
-- [ ] **P0-B** Пульт: для сцены с видео-превью явно подписано, что **кисть эффектов** недоступна (согласовано с `PresentationView`: эффекты только для image).
-- [ ] **P1-A** Пульт: порядок секций **Предпросмотр → Варианты ветвления → Музыка сцены → Быстрый микшер** (вертикальный поток как в референсе).
-- [ ] **P1-B** Сетка «Варианты ветвления» без «дыр»: `repeat(auto-fit, minmax(...))` **или** фиксированные слоты с disabled/placeholder **без новых сценариев** — только визуальная сетка.
-- [ ] **P2-A** Редактор: меню «Файл» — цвет текста пункта на валидном токене (`--text0` / `--text1`), без несуществующего `--text`.
-- [ ] **P2-B** Список сцен: убрать пустой статус-ряд у неактивных карточек (без лишнего вертикального зазора).
-
-### Критерии приёмки (Stage 1)
-
-1. На графе для сцены **без видео-превью** не отображаются вводящие в заблуждение чипы «Авто/Цикл» видео-превью; при наличии аудио — корректный индикатор аудио.
-2. Для сцены с **видео-превью** чипы «Авто»/«Цикл» совпадают с `previewVideoAutostart` и `scene.settings.loopVideo`.
-3. В пульте при `previewAssetType === 'video'` пользователь видит **одну строку-пояснение** (вторичный текст), почему нет панели эффектов.
-4. Визуальный порядок блоков пульта соответствует чеклисту P1-A; отступы между `Surface` единообразны (`gap` 16).
-5. Нет регрессий drag-and-drop сцен на граф и переключения веток.
-
-**Definition of Done (Stage 1):** все пункты чеклиста Stage 1 отмечены; `npm run build` успешен.
-
----
-
-## Stage 2 — Review (subagent: `reviewer`)
-
-### Чеклист PR
-
-- [ ] Нет «мёртвых» веток UI и ложных состояний (чипы/подписи соответствуют данным).
-- [ ] a11y: фокус/клавиатура на интерактивах не сломаны; `aria-*` не ухудшены.
-- [ ] Нет лишнего diff вне файлов задачи.
-
-### Критерии приёмки (Stage 2)
-
-1. Reviewer фиксирует замечания с **Severity**; все **high** устранены или явно отклонены с причиной в PR.
-2. После правок по review снова выполняется `npm run build`.
-
-**Definition of Done (Stage 2):** review-замечания закрыты; state `review: done`.
-
----
-
-## Stage 3 — Tests (subagent: `unit-tests`)
-
-### Чеклист PR
-
-- [ ] Добавлены или обновлены тесты на **чистую логику** (например, хелпер разметки чипов по `Scene`, если вынесен в `app/shared`).
-- [ ] Либо задокументировано в PR, что изменения только презентационные и покрыты smoke-тестом пайплайна.
-
-### Критерии приёмки (Stage 3)
-
-1. `npm run test` завершается с кодом 0.
-2. Новые тесты не flaky, не зависят от Electron UI.
-
-**Definition of Done (Stage 3):** `tests: done` в `.cursor/pipeline-state.json`.
-
----
-
-## Stage 4 — Verify (локально / hook `final-verify.cjs`)
-
-Выполнить подряд:
-
-```bash
-npm run lint
-npm run typecheck
-npm run test
-```
-
-**Если `npm run lint` падает на массовых `Delete ␍` (CRLF/LF) в файлах вне PR** — до отдельного chore-PR с нормализацией строк для этого чеклиста достаточно:
-
-```bash
-npx eslint app/renderer/control/ControlApp.tsx app/renderer/editor/graph/SceneGraph.tsx app/renderer/shared/ui/sceneGraphChips.ts app/renderer/shared/ui/sceneGraphChips.test.ts --max-warnings 0
-npm run typecheck
-npm run test
-npm run build
-```
-
-### Критерии приёмки (Stage 4)
-
-1. `npm run typecheck`, `npm run test`, `npm run build` — **exit 0**.
-2. Линт: либо полный `npm run lint` — **exit 0**, либо (при известном eol-долге репозитория) scoped-ESLint по файлам PR — **exit 0**, как в блоке выше.
-3. `node .cursor/hooks/final-verify.cjs` — успешное завершение пайплайна только когда полный `npm run lint` зелёный (хук вызывает полный lint; при падении lint хук пишет `followup_message` в stdout).
-
----
-
-## Синхронизация с `.cursor/pipeline-state.json`
-
-После каждой стадии обновлять файл:
-
-```json
-{
-  "implementation": "done",
-  "review": "done",
-  "tests": "done"
-}
-```
-
-До начала работы — все `"pending"`.

.cursor/rules/project.mdc

@@ -1,39 +0,0 @@
-# .cursor/rules/project.mdc
-
-# Project
-
-React + TypeScript frontend project.
-
-# Commands
-
-- install: `npm install`
-- dev: `npm run dev`
-- build: `npm run build`
-- lint: `npm run lint`
-- typecheck: `npm run typecheck`
-- test: `npm run test`
-- test single: `npm run test -- <file>`
-
-# Global rules
-
-- Всегда изучай existing code и nearby components перед изменениями
-- Делай minimal, review-friendly diff
-- Не добавляй new dependencies без явной причины
-- Следуй существующим patterns
-
-# Done criteria
-
-Перед завершением:
-
-- lint passes
-- typecheck passes
-- tests pass
-- нет regressions
-
-# UI checklist
-
-- loading state
-- error state
-- empty state
-- disabled state
-- accessibility

.cursor/skills/feature-pipeline/SKILL.md

@@ -1,80 +0,0 @@
----
-name: feature-pipeline
-description: Implementation → Review → Tests → Verify
----
-
-# Workflow
-
-## Stage 1 — Implementation
-
-Используй subagent: frontend-senior
-
-- реализуй задачу
-- сделай minimal diff
-
-Обнови state:
-
-{
-  "implementation": "done"
-}
-
----
-
-## Stage 2 — Review
-
-Используй subagent: reviewer
-
-- проверь изменения
-- найди проблемы
-- исправь минимально
-
-Обнови state:
-
-{
-  "implementation": "done",
-  "review": "done"
-}
-
----
-
-## Stage 3 — Tests
-
-Используй subagent: unit-tests
-
-- добавь/обнови tests
-- добейся green status
-
-Обнови state:
-
-{
-  "implementation": "done",
-  "review": "done",
-  "tests": "done"
-}
-
----
-
-## Stage 4 — Verify
-
-Выполни:
-
-- `npm run lint`
-- `npm run typecheck`
-- `npm run test`
-
-Если ошибка:
-- исправь
-- повтори
-
----
-
-## Final Output
-
-- implementation summary
-- review summary
-- test summary
-- verification status
-
-## PR-чеклисты (приёмка по задаче)
-
-Готовые чеклисты с критериями по стадиям лежат в `.cursor/pr-checklists/`. Для UI-выравнивания под макеты: `ui-mock-alignment.md`.

.gitea/workflows/release.yml

@@ -0,0 +1,118 @@
+# Сборка по тегу v* и выкладка в публичный репо (ветка updates).
+#
+# Метки runs-on = labels твоих act_runner (Админка Gitea → Действия → Раннеры).
+# Не используем windows-latest/macos-latest — это только GitHub-hosted.
+# По умолчанию: одна Linux-сборка Win+NSIS (Wine). macOS — когда будет раннер (см. комментарий в build-macos).
+#
+# Один job без actions/upload-artifact: официальный upload-artifact@v4 с GitHub на Gitea
+# падает (GHESNotSupportedError). Сборка и sync-update-feed идут в одном окружении.
+#
+# Secrets: DND_UPDATE_FEED_URL, DND_UPDATES_SERVER, UPDATES_REPO, DND_UPDATES_PUSH_TOKEN — docs/GITEA_AUTO_UPDATE.md
+
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+env:
+  CSC_IDENTITY_AUTO_DISCOVERY: 'false'
+
+jobs:
+  release:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      # Не включаем i386 / wine32: на Debian с репами только amd64 (nginx, sury, …)
+      # apt ломается на цепочке libgphoto2/libgd:i386. NSIS — нативный пакет `nsis`;
+      # electron-builder подхватывает makensis; wine64 — для win-утилит (rcedit и т.п.).
+      # Пакет `wine` (мета) тянет wine32 → снова i386. electron-builder ищет именно `wine` в PATH.
+      - name: Зависимости Win-сборки на Linux (amd64, без multiarch i386)
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+            ca-certificates \
+            nsis \
+            wine64
+          export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+          W64="$(command -v wine64 2>/dev/null || true)"
+          if [[ -z "$W64" || ! -x "$W64" ]]; then
+            for p in /usr/bin/wine64 /usr/lib/wine/wine64; do
+              if [[ -x "$p" ]]; then W64="$p"; break; fi
+            done
+          fi
+          if [[ -z "${W64:-}" || ! -x "$W64" ]]; then
+            echo "wine64 binary not found after apt install wine64" >&2
+            dpkg -L wine64 2>/dev/null | head -80 >&2 || true
+            exit 1
+          fi
+          printf '%s\n' '#!/bin/sh' "exec $W64 \"\$@\"" | sudo tee /usr/local/bin/wine >/dev/null
+          sudo chmod +x /usr/local/bin/wine
+          wine --version
+
+      - name: Версия из тега
+        shell: bash
+        run: |
+          TAG="${GITHUB_REF_NAME:-${GITEA_REF_NAME:-}}"
+          VERSION="${TAG#v}"
+          npm version "$VERSION" --allow-same-version --no-git-tag-version
+
+      - run: npm ci
+
+      - run: npm run build
+
+      - name: electron-builder (win)
+        shell: bash
+        env:
+          DND_UPDATE_FEED_URL: ${{ secrets.DND_UPDATE_FEED_URL }}
+        run: |
+          set -euo pipefail
+          if [[ -z "${DND_UPDATE_FEED_URL:-}" ]]; then
+            echo "Secret DND_UPDATE_FEED_URL is not set (URL со слэшем в конце)" >&2
+            exit 1
+          fi
+          npx electron-builder --win --publish never \
+            --config.publish.provider=generic \
+            --config.publish.url="${DND_UPDATE_FEED_URL}"
+
+      - name: Каталог артефактов для feed (_win)
+        shell: bash
+        run: |
+          mkdir -p _win
+          shopt -s nullglob || true
+          for f in release/*; do
+            [[ -f "$f" ]] || continue
+            base=$(basename "$f")
+            case "$base" in
+              *.yml|*.yaml|*.exe|*.blockmap|*.zip) cp -v "$f" _win/ ;;
+            esac
+          done
+          ls -la _win
+
+      - name: Пустой каталог mac (пока нет сборки mac в CI)
+        run: mkdir -p _mac
+
+      - name: Push в публичный репозиторий updates
+        env:
+          DND_UPDATES_SERVER: ${{ secrets.DND_UPDATES_SERVER }}
+          UPDATES_REPO: ${{ secrets.UPDATES_REPO }}
+          DND_UPDATES_PUSH_TOKEN: ${{ secrets.DND_UPDATES_PUSH_TOKEN }}
+          ARTIFACT_WIN: ${{ github.workspace }}/_win
+          ARTIFACT_MAC: ${{ github.workspace }}/_mac
+          GIT_COMMIT_TAG: ${{ github.ref_name }}
+        run: node scripts/sync-update-feed.mjs
+
+  # Когда появится macOS-раннер: отдельный job build-macos, копирование eb-mac в _mac перед sync
+  # или расширить шаг «Каталог артефактов»; сейчас всё в одном job `release`.
+  #
+  # build-macos:
+  #   runs-on: macos-14
+  #   steps: ...

.gitignore

@@ -1,3 +1,6 @@
+# Cursor: канонический `.cursor/` в репозитории cursorAi; локально — junction на ../cursorAi/.cursor
+.cursor/
+
 release/
 build/
 mcps/

app/main/index.ts

@@ -7,6 +7,7 @@ import { installIpcRouter, registerHandler, setLicenseAssert } from './ipc/route
 import { LicenseService } from './license/licenseService';
 import { ZipProjectStore } from './project/zipStore';
 import { registerDndAssetProtocol } from './protocol/dndAssetProtocol';
+import { installAutoUpdater } from './update/installAutoUpdater';
 import { getAppSemanticVersion, getOptionalBuildNumber } from './versionInfo';
 import { VideoPlaybackStore } from './video/videoPlaybackStore';
 import {
@@ -21,12 +22,27 @@ import {
   createEditorWindowDeferred,
   createWindows,
   focusEditorWindow,
+  isMultiWindowOpen,
   markAppQuitting,
   openMultiWindow,
   togglePresentationFullscreen,
   waitForEditorWindowReady,
 } from './windows/createWindows';
 
+function emitZipProgress(evt: {
+  kind: 'import' | 'export';
+  stage: string;
+  percent: number;
+  detail?: string;
+}): void {
+  for (const win of BrowserWindow.getAllWindows()) {
+    win.webContents.send(
+      evt.kind === 'import' ? ipcChannels.project.importZipProgress : ipcChannels.project.exportZipProgress,
+      evt,
+    );
+  }
+}
+
 /**
  * Отключение GPU ломает скорость вторичных окон (презентация/пульт — WebGL). По умолчанию не трогаем.
  * При чёрном экране в упакованной сборке: `DND_DISABLE_GPU=1`.
@@ -63,6 +79,35 @@ if (!gotTheLock) {
 }
 
 const projectStore = new ZipProjectStore();
+
+/** Без меню Electron не вешает горячие клавиши DevTools (Ctrl+Shift+I / F12). */
+function wantsDevToolsMenu(): boolean {
+  return (
+    process.env.NODE_ENV === 'development' ||
+    Boolean(process.env.VITE_DEV_SERVER_URL) ||
+    process.env.DND_OPEN_DEVTOOLS === '1'
+  );
+}
+
+function installAppMenuForSession(): void {
+  if (!wantsDevToolsMenu()) {
+    Menu.setApplicationMenu(null);
+    return;
+  }
+  const template: Electron.MenuItemConstructorOptions[] = [];
+  if (process.platform === 'darwin') {
+    template.push({
+      label: app.name,
+      submenu: [{ role: 'about' }, { type: 'separator' }, { role: 'quit' }],
+    });
+  }
+  template.push({
+    label: 'Вид',
+    submenu: [{ role: 'reload' }, { role: 'forceReload' }, { type: 'separator' }, { role: 'toggleDevTools' }],
+  });
+  Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+}
+
 const effectsStore = new EffectsStore();
 const videoStore = new VideoPlaybackStore();
 
@@ -172,11 +217,32 @@ async function runStartupAfterHandlers(licenseService: LicenseService): Promise<
 
 async function main() {
   await app.whenReady();
+  /**
+   * `ZipProjectStore` пишет `project.json` в кэш синхронно с мутациями, а упаковку `.dnd.zip`
+   * откладывает (`queueSave`, ~250 мс). Без финального `saveNow()` при выходе на диске
+   * остаётся старый zip — при следующем открытии кэш пересоздаётся из него и теряются
+   * недавние поля (в т.ч. `campaignAudios`).
+   */
+  let appQuittingAfterPendingSave = false;
+  app.on('before-quit', (e) => {
+    if (appQuittingAfterPendingSave) return;
+    e.preventDefault();
+    appQuittingAfterPendingSave = true;
+    void projectStore
+      .saveNow()
+      .catch((err: unknown) => {
+        console.error('[before-quit] saveNow failed', err);
+      })
+      .finally(() => {
+        app.quit();
+      });
+  });
+
   const licenseService = new LicenseService(app.getPath('userData'));
   setLicenseAssert(() => {
     licenseService.assertForIpc();
   });
-  Menu.setApplicationMenu(null);
+  installAppMenuForSession();
   registerDndAssetProtocol(projectStore);
   registerHandler(ipcChannels.app.quit, () => {
     markAppQuitting();
@@ -203,6 +269,9 @@ async function main() {
     const isFullScreen = togglePresentationFullscreen();
     return { ok: true, isFullScreen };
   });
+  registerHandler(ipcChannels.windows.getMultiWindowState, () => {
+    return { open: isMultiWindowOpen() };
+  });
 
   registerHandler(ipcChannels.project.list, async () => {
     const projects = await projectStore.listProjects();
@@ -286,6 +355,30 @@ async function main() {
     emitSessionState();
     return result;
   });
+  registerHandler(ipcChannels.project.importCampaignAudio, async () => {
+    const { canceled, filePaths } = await dialog.showOpenDialog({
+      properties: ['openFile', 'multiSelections'],
+      filters: [
+        {
+          name: 'Аудио',
+          extensions: ['mp3', 'wav', 'ogg', 'm4a', 'aac'],
+        },
+      ],
+    });
+    if (canceled || filePaths.length === 0) {
+      const project = projectStore.getOpenProject();
+      if (!project) throw new Error('No open project');
+      return { canceled: true as const, project, imported: [] };
+    }
+    const result = await projectStore.importCampaignAudioFiles(filePaths);
+    emitSessionState();
+    return { canceled: false as const, ...result };
+  });
+  registerHandler(ipcChannels.project.updateCampaignAudios, async ({ audios }) => {
+    const project = await projectStore.setCampaignAudios(audios);
+    emitSessionState();
+    return { project };
+  });
   registerHandler(ipcChannels.project.importScenePreview, async ({ sceneId }) => {
     const { canceled, filePaths } = await dialog.showOpenDialog({
       properties: ['openFile'],
@@ -358,7 +451,18 @@ async function main() {
     if (canceled || !filePaths[0]) {
       return { canceled: true as const };
     }
-    const project = await projectStore.importProjectFromExternalZip(filePaths[0]);
+    const srcPath = filePaths[0];
+    emitZipProgress({ kind: 'import', stage: 'copy', percent: 0, detail: 'Копирование…' });
+    // Let store import; progress for unzip is emitted from unzipToDir wrapper in store.
+    const project = await projectStore.importProjectFromExternalZip(srcPath, (p) => {
+      emitZipProgress({
+        kind: 'import',
+        stage: p.stage,
+        percent: p.percent,
+        ...(p.detail ? { detail: p.detail } : null),
+      });
+    });
+    emitZipProgress({ kind: 'import', stage: 'done', percent: 100, detail: 'Готово' });
     emitSessionState();
     return { canceled: false as const, project };
   });
@@ -383,7 +487,16 @@ async function main() {
     if (!lower.endsWith('.dnd.zip')) {
       dest = lower.endsWith('.zip') ? dest.replace(/\.zip$/iu, '.dnd.zip') : `${dest}.dnd.zip`;
     }
-    await projectStore.exportProjectZipToPath(projectId, dest);
+    emitZipProgress({ kind: 'export', stage: 'copy', percent: 0, detail: 'Экспорт…' });
+    await projectStore.exportProjectZipToPath(projectId, dest, (p) => {
+      emitZipProgress({
+        kind: 'export',
+        stage: p.stage,
+        percent: p.percent,
+        ...(p.detail ? { detail: p.detail } : null),
+      });
+    });
+    emitZipProgress({ kind: 'export', stage: 'done', percent: 100, detail: 'Готово' });
     return { canceled: false as const };
   });
   registerHandler(ipcChannels.project.deleteProject, async ({ projectId }) => {
@@ -415,6 +528,7 @@ async function main() {
 
   installIpcRouter();
   applyDockIconIfNeeded();
+  installAutoUpdater(licenseService);
   await runStartupAfterHandlers(licenseService);
 
   app.on('activate', () => {

app/main/ipc/router.ts

@@ -19,6 +19,8 @@ function channelRequiresLicense(channel: string): boolean {
   if (channel.startsWith('app.')) return false;
   if (channel === ipcChannels.windows.closeMultiWindow) return false;
   if (channel === ipcChannels.windows.togglePresentationFullscreen) return false;
+  // Список файлов в %userData%/projects — только чтение; без лицензии список не должен «пропадать».
+  if (channel === ipcChannels.project.list) return false;
   return true;
 }
 

app/main/license/licenseService.ts

@@ -17,6 +17,28 @@ type Preferences = {
   eulaAcceptedVersion?: number;
 };
 
+type LicenseChangeListener = () => void;
+
+const licenseChangeListeners = new Set<LicenseChangeListener>();
+
+/** Слушатели вызываются после смены состояния лицензии (сохранённый токен, EULA, отзыв). */
+export function addLicenseChangeListener(fn: LicenseChangeListener): () => void {
+  licenseChangeListeners.add(fn);
+  return () => {
+    licenseChangeListeners.delete(fn);
+  };
+}
+
+function notifyLicenseChangeListeners(): void {
+  for (const fn of licenseChangeListeners) {
+    try {
+      fn();
+    } catch (err) {
+      console.error('[license] change listener failed', err);
+    }
+  }
+}
+
 function readPreferences(userData: string): Preferences {
   try {
     const raw = fs.readFileSync(preferencesPath(userData), 'utf8');
@@ -35,6 +57,7 @@ function emitLicenseStatusChanged(): void {
   for (const win of BrowserWindow.getAllWindows()) {
     win.webContents.send(ipcChannels.license.statusChanged, {});
   }
+  notifyLicenseChangeListeners();
 }
 
 export class LicenseService {

app/main/project/assetPrune.test.ts

@@ -14,15 +14,17 @@ void test('collectReferencedAssetIds: превью, видео и аудио', (
     scenes: {
       s1: {
         previewAssetId: 'pr' as AssetId,
+        previewThumbAssetId: 'th' as AssetId,
         media: {
           videos: ['v1' as AssetId],
           audios: [{ assetId: 'a1' as AssetId, autoplay: true, loop: true }],
         },
       },
     },
+    campaignAudios: [{ assetId: 'ca1' as AssetId, autoplay: true, loop: true }],
   } as unknown as Project;
   const s = collectReferencedAssetIds(p);
-  assert.deepEqual([...s].sort(), ['a1', 'pr', 'v1'].sort());
+  assert.deepEqual([...s].sort(), ['a1', 'ca1', 'pr', 'th', 'v1'].sort());
 });
 
 void test('reconcileAssetFiles: снимает осиротевшие assets и удаляет файлы', async () => {
@@ -62,11 +64,13 @@ void test('reconcileAssetFiles: снимает осиротевшие assets и
   const prev: Project = {
     ...base,
     scenes: {},
+    campaignAudios: [],
     assets: { orphan: asset } as Project['assets'],
   };
   const next: Project = {
     ...base,
     scenes: {},
+    campaignAudios: [],
     assets: { orphan: asset } as Project['assets'],
   };
 
@@ -111,7 +115,7 @@ void test('reconcileAssetFiles: удаляет файл при исключен
   } as unknown as Project;
 
   const prev: Project = { ...base, assets: { gone: asset } as Project['assets'] };
-  const next: Project = { ...base, assets: {} as Project['assets'] };
+  const next: Project = { ...base, campaignAudios: [], assets: {} as Project['assets'] };
 
   const out = await reconcileAssetFiles(prev, next, tmp);
   assert.deepEqual(out.assets, {});

app/main/project/assetPrune.ts

@@ -9,9 +9,11 @@ export function collectReferencedAssetIds(p: Project): Set<AssetId> {
   const refs = new Set<AssetId>();
   for (const sc of Object.values(p.scenes)) {
     if (sc.previewAssetId) refs.add(sc.previewAssetId);
+    if (sc.previewThumbAssetId) refs.add(sc.previewThumbAssetId);
     for (const vid of sc.media.videos) refs.add(vid);
     for (const au of sc.media.audios) refs.add(au.assetId);
   }
+  for (const au of p.campaignAudios) refs.add(au.assetId);
   return refs;
 }
 

app/main/project/atomicReplace.ts

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { readProjectJsonFromZip } from './yauzlProjectZip';
+
+/**
+ * Подменяет файл `finalPath` готовым `completedSrc` (обычно `*.dnd.zip.tmp`).
+ * Нельзя сначала удалять `finalPath`: при сбое rename после rm проект теряется (Windows/антивирус).
+ */
+export async function replaceFileAtomic(completedSrc: string, finalPath: string): Promise<void> {
+  if (completedSrc === finalPath) return;
+
+  const stSrc = await fs.stat(completedSrc).catch(() => null);
+  if (!stSrc?.isFile() || stSrc.size === 0) {
+    throw new Error(`replaceFileAtomic: нет или пустой источник: ${completedSrc}`);
+  }
+
+  try {
+    await fs.rename(completedSrc, finalPath);
+    return;
+  } catch (first: unknown) {
+    const c = (first as NodeJS.ErrnoException).code;
+    if (c === 'EXDEV') {
+      await fs.copyFile(completedSrc, finalPath);
+      await fs.unlink(completedSrc).catch(() => undefined);
+      return;
+    }
+    // Windows: чаще всего EEXIST — целевой файл есть, rename не перезаписывает; идём через backup ниже.
+  }
+
+  const stFinal = await fs.stat(finalPath).catch(() => null);
+  if (!stFinal?.isFile()) {
+    try {
+      await fs.rename(completedSrc, finalPath);
+      return;
+    } catch (again: unknown) {
+      throw again instanceof Error ? again : new Error(String(again));
+    }
+  }
+
+  const backupPath = `${finalPath}.bak.${Date.now().toString(36)}_${crypto.randomBytes(4).toString('hex')}`;
+  await fs.rename(finalPath, backupPath);
+  try {
+    await fs.rename(completedSrc, finalPath);
+  } catch (place: unknown) {
+    await fs.rename(backupPath, finalPath).catch(() => undefined);
+    throw place instanceof Error ? place : new Error(String(place));
+  }
+  await fs.unlink(backupPath).catch(() => undefined);
+}
+
+/** Если сохранение оборвалось, остаётся только `*.dnd.zip.tmp` — восстанавливаем в `*.dnd.zip`. */
+export async function recoverOrphanDndZipTmpInRoot(root: string): Promise<void> {
+  let names: string[];
+  try {
+    names = await fs.readdir(root);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.endsWith('.dnd.zip.tmp')) continue;
+    const tmpPath = path.join(root, name);
+    const finalName = name.slice(0, -'.tmp'.length);
+    if (!finalName.endsWith('.dnd.zip')) continue;
+    const finalPath = path.join(root, finalName);
+    try {
+      await fs.access(finalPath);
+      continue;
+    } catch {
+      /* final отсутствует — пробуем поднять из tmp */
+    }
+    try {
+      const st = await fs.stat(tmpPath);
+      if (!st.isFile() || st.size < 22) continue;
+      await readProjectJsonFromZip(tmpPath);
+      await fs.rename(tmpPath, finalPath);
+    } catch {
+      /* битый tmp не трогаем */
+    }
+  }
+}

app/main/project/fsRetry.test.ts

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { rmWithRetries } from './fsRetry';
+
+void test('rmWithRetries: retries on EPERM and then succeeds', async () => {
+  let calls = 0;
+  const rm = () => {
+    calls += 1;
+    if (calls < 3) {
+      const err = new Error('nope') as Error & { code: string };
+      err.code = 'EPERM';
+      throw err;
+    }
+    return Promise.resolve();
+  };
+  await rmWithRetries(rm, 'x', { force: true }, 5);
+  assert.equal(calls, 3);
+});
+
+void test('rmWithRetries: does not retry on ENOENT', async () => {
+  let calls = 0;
+  const rm = () => {
+    calls += 1;
+    const err = new Error('missing') as Error & { code: string };
+    err.code = 'ENOENT';
+    return Promise.reject(err);
+  };
+  await assert.rejects(() => rmWithRetries(rm, 'x', { force: true }, 5), /missing/);
+  assert.equal(calls, 1);
+});

app/main/project/fsRetry.ts

@@ -0,0 +1,32 @@
+type RmLike = (path: string, opts: { recursive?: boolean; force?: boolean }) => Promise<void>;
+
+function isRetryableRmError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const code = (err as { code?: unknown }).code;
+  return code === 'EBUSY' || code === 'EPERM' || code === 'EACCES';
+}
+
+export async function rmWithRetries(
+  rm: RmLike,
+  targetPath: string,
+  opts: { recursive?: boolean; force?: boolean },
+  retries = 6,
+): Promise<void> {
+  let attempt = 0;
+  // Windows: file locks/antivirus/indexers can cause transient EPERM/EBUSY.
+  // We retry a few times before surfacing the error.
+  // Delays: 20, 40, 80, 160, 320, 640ms (capped by retries).
+  for (;;) {
+    try {
+      await rm(targetPath, opts);
+      return;
+    } catch (e) {
+      attempt += 1;
+      if (attempt > retries || !isRetryableRmError(e)) {
+        throw e;
+      }
+      const delayMs = Math.min(800, 20 * 2 ** (attempt - 1));
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+}

app/main/project/optimizeImageImport.lib.d.mts

@@ -0,0 +1,14 @@
+import type { Buffer } from 'node:buffer';
+
+export type OptimizeImageImportResult = {
+  buffer: Buffer;
+  mime: string;
+  ext: string;
+  width: number;
+  height: number;
+  passthrough: boolean;
+};
+
+export function optimizeImageBufferVisuallyLossless(
+  input: Buffer,
+): Promise<OptimizeImageImportResult>;

app/main/project/optimizeImageImport.lib.mjs

@@ -0,0 +1,218 @@
+/**
+ * Visually lossless re-encode for imported raster images (same pixel dimensions).
+ * Node-only; shared by the main app and ../project-converter (monorepo sibling).
+ */
+import sharp from 'sharp';
+
+/** @typedef {import('node:buffer').Buffer} Buffer */
+
+/**
+ * @typedef {Object} OptimizeImageImportResult
+ * @property {Buffer} buffer
+ * @property {string} mime
+ * @property {string} ext filename extension without dot (e.g. webp, jpg, png)
+ * @property {number} width
+ * @property {number} height
+ * @property {boolean} passthrough true if original bytes were kept
+ */
+
+const WEBP_EFFORT = 6;
+const RASTER_QUALITY = 95;
+
+/**
+ * @param {Buffer} buf
+ * @param {import('sharp').Metadata | null} meta
+ * @returns {OptimizeImageImportResult}
+ */
+function makePassthrough(buf, meta) {
+  const fmt = meta?.format;
+  if (fmt === 'jpeg' || fmt === 'jpg') {
+    return {
+      buffer: buf,
+      mime: 'image/jpeg',
+      ext: 'jpg',
+      width: meta?.width ?? 0,
+      height: meta?.height ?? 0,
+      passthrough: true,
+    };
+  }
+  if (fmt === 'png') {
+    return {
+      buffer: buf,
+      mime: 'image/png',
+      ext: 'png',
+      width: meta?.width ?? 0,
+      height: meta?.height ?? 0,
+      passthrough: true,
+    };
+  }
+  if (fmt === 'webp') {
+    return {
+      buffer: buf,
+      mime: 'image/webp',
+      ext: 'webp',
+      width: meta?.width ?? 0,
+      height: meta?.height ?? 0,
+      passthrough: true,
+    };
+  }
+  if (fmt === 'gif') {
+    return {
+      buffer: buf,
+      mime: 'image/gif',
+      ext: 'gif',
+      width: meta?.width ?? 0,
+      height: meta?.height ?? 0,
+      passthrough: true,
+    };
+  }
+  if (fmt === 'tiff' || fmt === 'tif') {
+    return {
+      buffer: buf,
+      mime: 'image/tiff',
+      ext: 'tiff',
+      width: meta?.width ?? 0,
+      height: meta?.height ?? 0,
+      passthrough: true,
+    };
+  }
+  if (fmt === 'bmp') {
+    return {
+      buffer: buf,
+      mime: 'image/bmp',
+      ext: 'bmp',
+      width: meta?.width ?? 0,
+      height: meta?.height ?? 0,
+      passthrough: true,
+    };
+  }
+  return {
+    buffer: buf,
+    mime: 'application/octet-stream',
+    ext: 'bin',
+    width: meta?.width ?? 0,
+    height: meta?.height ?? 0,
+    passthrough: true,
+  };
+}
+
+/**
+ * @param {Buffer} outBuf
+ * @param {number} w0
+ * @param {number} h0
+ */
+async function sameDimensionsOrThrow(outBuf, w0, h0) {
+  const m = await sharp(outBuf).metadata();
+  if ((m.width ?? 0) !== w0 || (m.height ?? 0) !== h0) {
+    const err = new Error('encode changed dimensions');
+    err.code = 'DIM';
+    throw err;
+  }
+}
+
+/**
+ * @param {Buffer} src
+ * @returns {Promise<OptimizeImageImportResult>}
+ */
+export async function optimizeImageBufferVisuallyLossless(src) {
+  const input = Buffer.isBuffer(src) ? src : Buffer.from(src);
+  if (input.length === 0) {
+    return makePassthrough(input, { width: 0, height: 0, format: 'png' });
+  }
+
+  let meta0;
+  try {
+    meta0 = await sharp(input, { failOn: 'error', unlimited: true }).metadata();
+  } catch {
+    return makePassthrough(input, null);
+  }
+
+  const width = meta0.width ?? 0;
+  const height = meta0.height ?? 0;
+  if (width <= 0 || height <= 0) {
+    return makePassthrough(input, meta0);
+  }
+
+  const pages = meta0.pages ?? 1;
+  if (pages > 1) {
+    return makePassthrough(input, meta0);
+  }
+
+  const rawFmt = meta0.format;
+  if (rawFmt === 'svg' || rawFmt === 'pdf' || rawFmt === 'heif' || rawFmt === 'jxl' || rawFmt === 'vips') {
+    return makePassthrough(input, meta0);
+  }
+
+  const hasAlpha = meta0.hasAlpha === true;
+
+  try {
+    if (hasAlpha) {
+      const webpLo = await sharp(input)
+        .rotate()
+        .ensureAlpha()
+        .webp({ lossless: true, effort: WEBP_EFFORT })
+        .toBuffer();
+      const pngOut = await sharp(input)
+        .rotate()
+        .ensureAlpha()
+        .png({ compressionLevel: 9, adaptiveFiltering: true })
+        .toBuffer();
+      await sameDimensionsOrThrow(webpLo, width, height);
+      await sameDimensionsOrThrow(pngOut, width, height);
+
+      const pickWebp = webpLo.length <= pngOut.length;
+      const outBuf = pickWebp ? webpLo : pngOut;
+      if (outBuf.length >= input.length) {
+        return makePassthrough(input, meta0);
+      }
+      return {
+        buffer: outBuf,
+        mime: pickWebp ? 'image/webp' : 'image/png',
+        ext: pickWebp ? 'webp' : 'png',
+        width,
+        height,
+        passthrough: false,
+      };
+    }
+
+    const webpColor = await sharp(input)
+      .rotate()
+      .webp({
+        quality: RASTER_QUALITY,
+        nearLossless: true,
+        effort: WEBP_EFFORT,
+        smartSubsample: false,
+      })
+      .toBuffer();
+    const jpegColor = await sharp(input)
+      .rotate()
+      .jpeg({
+        quality: RASTER_QUALITY,
+        chromaSubsampling: '4:4:4',
+        mozjpeg: true,
+        optimizeScans: true,
+      })
+      .toBuffer();
+    await sameDimensionsOrThrow(webpColor, width, height);
+    await sameDimensionsOrThrow(jpegColor, width, height);
+
+    const useWebp = webpColor.length <= jpegColor.length;
+    const outBuf = useWebp ? webpColor : jpegColor;
+    if (outBuf.length >= input.length) {
+      return makePassthrough(input, meta0);
+    }
+    return {
+      buffer: outBuf,
+      mime: useWebp ? 'image/webp' : 'image/jpeg',
+      ext: useWebp ? 'webp' : 'jpg',
+      width,
+      height,
+      passthrough: false,
+    };
+  } catch (e) {
+    if (e && typeof e === 'object' && /** @type {{ code?: string }} */ (e).code === 'DIM') {
+      return makePassthrough(input, meta0);
+    }
+    return makePassthrough(input, meta0);
+  }
+}

app/main/project/optimizeImageImport.test.ts

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import sharp from 'sharp';
+
+import { optimizeImageBufferVisuallyLossless } from './optimizeImageImport.lib.mjs';
+
+void test('optimizeImageBufferVisuallyLossless: preserves dimensions for opaque RGB', async () => {
+  const input = await sharp({
+    create: {
+      width: 400,
+      height: 300,
+      channels: 3,
+      background: { r: 10, g: 100, b: 200 },
+    },
+  })
+    .png({ compressionLevel: 0 })
+    .toBuffer();
+
+  const out = await optimizeImageBufferVisuallyLossless(input);
+  assert.equal(out.passthrough, false);
+  assert.ok(out.buffer.length > 0);
+  assert.ok(out.buffer.length < input.length);
+  const meta = await sharp(out.buffer).metadata();
+  assert.equal(meta.width, 400);
+  assert.equal(meta.height, 300);
+});
+
+void test('optimizeImageBufferVisuallyLossless: preserves dimensions for alpha', async () => {
+  const input = await sharp({
+    create: {
+      width: 200,
+      height: 200,
+      channels: 4,
+      background: { r: 255, g: 0, b: 0, alpha: 0.5 },
+    },
+  })
+    .png({ compressionLevel: 0 })
+    .toBuffer();
+
+  const out = await optimizeImageBufferVisuallyLossless(input);
+  assert.equal(out.passthrough, false);
+  assert.ok(out.mime === 'image/webp' || out.mime === 'image/png');
+  assert.ok(out.buffer.length < input.length);
+  const meta = await sharp(out.buffer).metadata();
+  assert.equal(meta.width, 200);
+  assert.equal(meta.height, 200);
+  assert.equal(meta.hasAlpha, true);
+});
+
+void test('optimizeImageBufferVisuallyLossless: non-image buffer is passthrough', async () => {
+  const out = await optimizeImageBufferVisuallyLossless(Buffer.from('not an image'));
+  assert.equal(out.passthrough, true);
+});

app/main/project/replaceFileAtomic.test.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { replaceFileAtomic } from './atomicReplace';
+
+void test('replaceFileAtomic: replaces existing file without deleting before rename succeeds', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dnd-replace-'));
+  const finalPath = path.join(dir, 'out.bin');
+  const tmpPath = path.join(dir, 'out.bin.tmp');
+  await fs.writeFile(finalPath, 'previous', 'utf8');
+  await fs.writeFile(tmpPath, 'updated-content', 'utf8');
+  await replaceFileAtomic(tmpPath, finalPath);
+  assert.equal(await fs.readFile(finalPath, 'utf8'), 'updated-content');
+  await assert.rejects(() => fs.stat(tmpPath));
+});
+
+void test('replaceFileAtomic: rejects empty source', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dnd-replace-'));
+  const finalPath = path.join(dir, 'out.bin');
+  const tmpPath = path.join(dir, 'out.bin.tmp');
+  await fs.writeFile(finalPath, 'x', 'utf8');
+  await fs.writeFile(tmpPath, '', 'utf8');
+  await assert.rejects(() => replaceFileAtomic(tmpPath, finalPath));
+  assert.equal(await fs.readFile(finalPath, 'utf8'), 'x');
+});

app/main/project/scenePreviewThumbnail.test.ts

@@ -0,0 +1,35 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import sharp from 'sharp';
+
+import { generateScenePreviewThumbnailBytes, SCENE_PREVIEW_THUMB_MAX_PX } from './scenePreviewThumbnail';
+
+void test('generateScenePreviewThumbnailBytes: image scales to max edge', async () => {
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dnd-thumb-test-'));
+  const src = path.join(tmp, 'wide.png');
+  await sharp({
+    create: {
+      width: 800,
+      height: 400,
+      channels: 3,
+      background: { r: 200, g: 40, b: 40 },
+    },
+  })
+    .png()
+    .toFile(src);
+
+  const buf = await generateScenePreviewThumbnailBytes(src, 'image');
+  assert.ok(buf !== null);
+  assert.ok(buf.length > 0);
+  const meta = await sharp(buf).metadata();
+  assert.equal(typeof meta.width, 'number');
+  assert.equal(typeof meta.height, 'number');
+  assert.ok(meta.width > 0 && meta.height > 0);
+  assert.ok(Math.max(meta.width, meta.height) <= SCENE_PREVIEW_THUMB_MAX_PX);
+
+  await fs.rm(tmp, { recursive: true, force: true });
+});

app/main/project/scenePreviewThumbnail.ts

@@ -0,0 +1,86 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import ffmpegStatic from 'ffmpeg-static';
+import sharp from 'sharp';
+
+const execFileAsync = promisify(execFile);
+
+/** Longest edge; presentation uses the original asset. */
+export const SCENE_PREVIEW_THUMB_MAX_PX = 320;
+
+/**
+ * Builds a small WebP still for graph/list previews. Returns null if generation fails (import still succeeds).
+ */
+export async function generateScenePreviewThumbnailBytes(
+  sourceAbsPath: string,
+  kind: 'image' | 'video',
+): Promise<Buffer | null> {
+  try {
+    if (kind === 'image') {
+      return await sharp(sourceAbsPath)
+        .rotate()
+        .resize(SCENE_PREVIEW_THUMB_MAX_PX, SCENE_PREVIEW_THUMB_MAX_PX, {
+          fit: 'inside',
+          withoutEnlargement: true,
+        })
+        .webp({ quality: 82 })
+        .toBuffer();
+    }
+
+    const ffmpegPath = ffmpegStatic;
+    if (!ffmpegPath) return null;
+
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dnd-thumb-'));
+    const tmpPng = path.join(tmpDir, 'frame.png');
+    try {
+      const seekSeconds = ['0.5', '0.25', '0'];
+      let extracted = false;
+      for (const ss of seekSeconds) {
+        await fs.rm(tmpPng, { force: true }).catch(() => undefined);
+        try {
+          await execFileAsync(
+            ffmpegPath,
+            [
+              '-hide_banner',
+              '-loglevel',
+              'error',
+              '-y',
+              '-ss',
+              ss,
+              '-i',
+              sourceAbsPath,
+              '-frames:v',
+              '1',
+              tmpPng,
+            ],
+            { maxBuffer: 16 * 1024 * 1024 },
+          );
+          const st = await fs.stat(tmpPng).catch(() => null);
+          if (st !== null && st.isFile() && st.size > 0) {
+            extracted = true;
+            break;
+          }
+        } catch {
+          /* try next seek */
+        }
+      }
+      if (!extracted) return null;
+
+      return await sharp(tmpPng)
+        .resize(SCENE_PREVIEW_THUMB_MAX_PX, SCENE_PREVIEW_THUMB_MAX_PX, {
+          fit: 'inside',
+          withoutEnlargement: true,
+        })
+        .webp({ quality: 82 })
+        .toBuffer();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+  } catch {
+    return null;
+  }
+}

app/main/project/yauzlProjectZip.ts

@@ -5,12 +5,18 @@ import yauzl from 'yauzl';
 
 import type { Project } from '../../shared/types';
 
-export function unzipToDir(zipPath: string, outDir: string): Promise<void> {
+export function unzipToDir(
+  zipPath: string,
+  outDir: string,
+  onProgress?: (done: number, total: number) => void,
+): Promise<void> {
   return new Promise((resolve, reject) => {
     yauzl.open(zipPath, { lazyEntries: true }, (err, zip) => {
       if (err) return reject(err);
       const zipFile = zip;
       let settled = false;
+      const total = zipFile.entryCount || 0;
+      let done = 0;
 
       const safeClose = (): void => {
         try {
@@ -37,6 +43,14 @@ export function unzipToDir(zipPath: string, outDir: string): Promise<void> {
       zipFile.readEntry();
       zipFile.on('entry', (entry: yauzl.Entry) => {
         if (settled) return;
+        done += 1;
+        if (onProgress && total > 0) {
+          try {
+            onProgress(done, total);
+          } catch {
+            // ignore
+          }
+        }
         const filePath = path.join(outDir, entry.fileName);
         if (entry.fileName.endsWith('/')) {
           fssync.mkdirSync(filePath, { recursive: true });

app/main/project/zipRead.test.ts

@@ -51,3 +51,48 @@ void test('readProjectJsonFromZip: sequential reads close yauzl (no EMFILE)', as
 
   await fs.rm(tmp, { recursive: true, force: true });
 });
+
+void test('readProjectJsonFromZip: campaignAudios round-trips inside project.json', async () => {
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dnd-zip-campaign-'));
+  const zipPath = path.join(tmp, 'test.dnd.zip');
+  const assetId = 'audio_asset_1';
+  const minimal = {
+    id: 'p1',
+    meta: {
+      name: 'n',
+      fileBaseName: 'f',
+      createdAt: '2020-01-01',
+      updatedAt: '2020-01-01',
+      createdWithAppVersion: '1',
+      appVersion: '1',
+      schemaVersion: PROJECT_SCHEMA_VERSION,
+    },
+    scenes: {},
+    assets: {},
+    campaignAudios: [{ assetId, autoplay: true, loop: false }],
+    currentSceneId: null,
+    currentGraphNodeId: null,
+    sceneGraphNodes: [],
+    sceneGraphEdges: [],
+  };
+
+  const zipfile = new ZipFile();
+  zipfile.addBuffer(Buffer.from(JSON.stringify(minimal), 'utf8'), 'project.json', { compressionLevel: 9 });
+  const out = fssync.createWriteStream(zipPath);
+  const done = new Promise<void>((resolve, reject) => {
+    out.on('close', resolve);
+    out.on('error', reject);
+  });
+  zipfile.outputStream.pipe(out);
+  zipfile.end();
+  await done;
+
+  const p = await readProjectJsonFromZip(zipPath);
+  assert.ok(Array.isArray((p as { campaignAudios?: unknown }).campaignAudios));
+  assert.deepEqual(
+    (p as { campaignAudios: typeof minimal.campaignAudios }).campaignAudios,
+    minimal.campaignAudios,
+  );
+
+  await fs.rm(tmp, { recursive: true, force: true });
+});

app/main/project/zipStore.legacyContract.test.ts

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+void test('zipStore: deleteProjectById removes legacy sibling copies by entry.fileName', () => {
+  const src = fs.readFileSync(path.join(here, 'zipStore.ts'), 'utf8');
+  assert.match(src, /async deleteProjectById/);
+  assert.match(src, /for \(const legacyRoot of getLegacyProjectsRootDirs\(\)\)/);
+  assert.match(src, /path\.join\(legacyRoot, entry\.fileName\)/);
+  assert.match(src, /rmWithRetries\(fs\.rm, legacyZipPath, \{ force: true \}\)/);
+});
+
+void test('zipStore: legacy migration moves or copy\\+rm so deleted projects are not resurrected', () => {
+  const src = fs.readFileSync(path.join(here, 'zipStore.ts'), 'utf8');
+  assert.match(src, /migrateLegacyProjectZipsIfNeeded/);
+  assert.match(src, /if \(destZips\.has\(name\)\) continue/);
+  assert.match(src, /await fs\.rename\(from, to\)/);
+  assert.match(src, /await fs\.copyFile\(from, to\)/);
+  assert.match(src, /rmWithRetries\(fs\.rm, from, \{ force: true \}\)/);
+  assert.match(src, /не «возрождались»/);
+});
+
+void test('zipStore: openProjectById flushes pending saveNow before cache reset', () => {
+  const src = fs.readFileSync(path.join(here, 'zipStore.ts'), 'utf8');
+  // When switching projects we rm cacheDir and unzip zip; ensure pending debounced pack is flushed first.
+  assert.match(src, /async openProjectById/);
+  assert.match(src, /if \(this\.openProject\)\s*\{\s*await this\.saveNow\(\);\s*\}/);
+  assert.match(src, /await fs\.rm\(cacheDir, \{ recursive: true, force: true \}\)/);
+  assert.match(src, /await unzipToDir\(zipPath, cacheDir\)/);
+});
+
+void test('zipStore: exportProjectZipToPath flushes saveNow for currently open project', () => {
+  const src = fs.readFileSync(path.join(here, 'zipStore.ts'), 'utf8');
+  assert.match(src, /async exportProjectZipToPath/);
+  assert.match(src, /if \(this\.openProject\?\.id === projectId\)\s*\{\s*await this\.saveNow\(\);\s*\}/);
+  assert.match(src, /await fs\.copyFile\(src, dest\)/);
+});
+
+void test('zipStore: normalizeScene defaults previewThumbAssetId for older projects', () => {
+  const src = fs.readFileSync(path.join(here, 'zipStore.ts'), 'utf8');
+  assert.match(src, /previewThumbAssetId/);
+  assert.match(src, /function normalizeScene\(/);
+});
+
+void test('zipStore: listProjects skips unreadable archives', () => {
+  const src = fs.readFileSync(path.join(here, 'zipStore.ts'), 'utf8');
+  assert.match(
+    src,
+    /async listProjects[\s\S]+?for \(const filePath of files\)[\s\S]+?try \{[\s\S]+?readProjectJsonFromZip/,
+  );
+});
+
+void test('atomicReplace: replaceFileAtomic must not rm destination before successful commit', () => {
+  const src = fs.readFileSync(path.join(here, 'atomicReplace.ts'), 'utf8');
+  const i = src.indexOf('export async function replaceFileAtomic');
+  assert.ok(i >= 0);
+  const j = src.indexOf('export async function recoverOrphanDndZipTmpInRoot', i);
+  assert.ok(j > i);
+  const block = src.slice(i, j);
+  assert.match(block, /rename\(finalPath, backupPath\)/);
+  assert.doesNotMatch(block, /\.rm\(\s*finalPath/);
+});

app/main/project/zipStore.ts

@@ -24,7 +24,11 @@ import { asAssetId, asGraphNodeId, asProjectId } from '../../shared/types/ids';
 import { getAppSemanticVersion } from '../versionInfo';
 
 import { reconcileAssetFiles } from './assetPrune';
+import { recoverOrphanDndZipTmpInRoot, replaceFileAtomic } from './atomicReplace';
+import { rmWithRetries } from './fsRetry';
+import { optimizeImageBufferVisuallyLossless } from './optimizeImageImport.lib.mjs';
 import { getLegacyProjectsRootDirs, getProjectsCacheRootDir, getProjectsRootDir } from './paths';
+import { generateScenePreviewThumbnailBytes } from './scenePreviewThumbnail';
 import { readProjectJsonFromZip, unzipToDir } from './yauzlProjectZip';
 
 type ProjectIndexEntry = {
@@ -72,6 +76,7 @@ export class ZipProjectStore {
     await fs.mkdir(getProjectsRootDir(), { recursive: true });
     await fs.mkdir(getProjectsCacheRootDir(), { recursive: true });
     await this.migrateLegacyProjectZipsIfNeeded();
+    await recoverOrphanDndZipTmpInRoot(getProjectsRootDir());
   }
 
   /** Копирует .dnd.zip из каталогов с «чужим» app name, если в текущем каталоге такого файла ещё нет. */
@@ -99,7 +104,21 @@ export class ZipProjectStore {
         try {
           const st = await fs.stat(from);
           if (!st.isFile()) continue;
+          // Переносим (а не копируем), чтобы:
+          // - не было дублей между разными appName
+          // - удалённые пользователем проекты не «возрождались» при следующем ensureRoots()
+          try {
+            await fs.rename(from, to);
+          } catch {
             await fs.copyFile(from, to);
+            try {
+              await rmWithRetries(fs.rm, from, { force: true });
+            } catch {
+              // best effort: если zip уже скопирован в dest, миграцию считаем успешной;
+              // legacy-копия может остаться (например из-за lock/AV), но удаление проекта
+              // затем чистит legacy по fileName.
+            }
+          }
           destZips.add(name);
         } catch {
           /* ignore */
@@ -118,6 +137,7 @@ export class ZipProjectStore {
 
     const out: ProjectIndexEntry[] = [];
     for (const filePath of files) {
+      try {
         const project = await readProjectJsonFromZip(filePath);
         out.push({
           id: project.id,
@@ -125,6 +145,9 @@ export class ZipProjectStore {
           updatedAt: project.meta.updatedAt,
           fileName: path.basename(filePath),
         });
+      } catch {
+        // Один битый архив не должен скрывать остальные проекты в списке.
+      }
     }
     out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     return out;
@@ -150,6 +173,7 @@ export class ZipProjectStore {
       },
       scenes: {},
       assets: {},
+      campaignAudios: [],
       currentSceneId: null,
       currentGraphNodeId: null,
       sceneGraphNodes: [],
@@ -167,6 +191,11 @@ export class ZipProjectStore {
 
   async openProjectById(projectId: ProjectId): Promise<Project> {
     await this.ensureRoots();
+    // Mutations are persisted to cache immediately, but zip packing is debounced (queueSave).
+    // When switching projects we delete the cache and restore it from the zip, so flush pending saves first.
+    if (this.openProject) {
+      await this.saveNow();
+    }
     this.projectSession += 1;
     const list = await this.listProjects();
     const entry = list.find((p) => p.id === projectId);
@@ -192,6 +221,44 @@ export class ZipProjectStore {
     return project;
   }
 
+  private async openProjectByIdWithProgress(
+    projectId: ProjectId,
+    onUnzipPercent: (pct: number) => void,
+  ): Promise<Project> {
+    await this.ensureRoots();
+    // Mutations are persisted to cache immediately, but zip packing is debounced (queueSave).
+    // When switching projects we delete the cache and restore it from the zip, so flush pending saves first.
+    if (this.openProject) {
+      await this.saveNow();
+    }
+    this.projectSession += 1;
+    const list = await this.listProjects();
+    const entry = list.find((p) => p.id === projectId);
+    if (!entry) {
+      throw new Error('Project not found');
+    }
+    const zipPath = path.join(getProjectsRootDir(), entry.fileName);
+    const cacheDir = path.join(getProjectsCacheRootDir(), projectId);
+
+    await fs.rm(cacheDir, { recursive: true, force: true });
+    await fs.mkdir(cacheDir, { recursive: true });
+    await unzipToDir(zipPath, cacheDir, (done, total) => {
+      const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+      onUnzipPercent(Math.max(0, Math.min(100, pct)));
+    });
+
+    const projectPath = path.join(cacheDir, 'project.json');
+    const projectRaw = await fs.readFile(projectPath, 'utf8');
+    const parsed = JSON.parse(projectRaw) as unknown as Project;
+    const project = normalizeProject(parsed);
+    const fileBaseName = entry.fileName.replace(/\.dnd\.zip$/iu, '');
+    project.meta.fileBaseName = project.meta.fileBaseName.trim().length
+      ? project.meta.fileBaseName
+      : fileBaseName;
+    this.openProject = { id: projectId, zipPath, cacheDir, projectPath, project };
+    return project;
+  }
+
   getOpenProject(): Project | null {
     return this.openProject?.project ?? null;
   }
@@ -224,35 +291,78 @@ export class ZipProjectStore {
     const sc = open.project.scenes[sceneId];
     if (!sc) throw new Error('Scene not found');
 
-    const kind = classifyMediaPath(filePath);
-    if (kind?.type !== 'image' && kind?.type !== 'video') {
+    const kind0 = classifyMediaPath(filePath);
+    if (!kind0 || (kind0.type !== 'image' && kind0.type !== 'video')) {
       throw new Error('Файл превью должен быть изображением или видео');
     }
+    let kind: MediaKind = kind0;
 
     const buf = await fs.readFile(filePath);
-    const sha256 = crypto.createHash('sha256').update(buf).digest('hex');
     const id = asAssetId(this.randomId());
     const orig = path.basename(filePath);
-    const safeOrig = sanitizeFileName(orig);
-    const relPath = `assets/${id}_${safeOrig}`;
-    const abs = path.join(open.cacheDir, relPath);
+    let safeOrig = sanitizeFileName(orig);
+    let relPath = `assets/${id}_${safeOrig}`;
+    let abs = path.join(open.cacheDir, relPath);
+    let writeBuf = buf;
+    let storedOrig = orig;
+
+    if (kind.type === 'image') {
+      const opt = await optimizeImageBufferVisuallyLossless(buf);
+      if (!opt.passthrough) {
+        writeBuf = Buffer.from(opt.buffer);
+        kind = { type: 'image', mime: opt.mime };
+        safeOrig = sanitizeFileName(`${path.parse(orig).name}.${opt.ext}`);
+        relPath = `assets/${id}_${safeOrig}`;
+        abs = path.join(open.cacheDir, relPath);
+        storedOrig = `${path.parse(orig).name}.${opt.ext}`;
+      }
+    }
+
+    const sha256 = crypto.createHash('sha256').update(writeBuf).digest('hex');
     await fs.mkdir(path.dirname(abs), { recursive: true });
-    await fs.copyFile(filePath, abs);
-    const asset = buildMediaAsset(id, kind, orig, relPath, sha256, buf.length);
+    await fs.writeFile(abs, writeBuf);
+    const asset = buildMediaAsset(id, kind, storedOrig, relPath, sha256, writeBuf.length);
+
+    const thumbKind = kind.type === 'image' ? 'image' : 'video';
+    const thumbBytes = await generateScenePreviewThumbnailBytes(abs, thumbKind);
+    let thumbAsset: MediaAsset | null = null;
+    let thumbId: AssetId | null = null;
+    if (thumbBytes !== null && thumbBytes.length > 0) {
+      thumbId = asAssetId(this.randomId());
+      const thumbRelPath = `assets/${thumbId}_preview_thumb.webp`;
+      const thumbAbs = path.join(open.cacheDir, thumbRelPath);
+      await fs.writeFile(thumbAbs, thumbBytes);
+      const thumbSha = crypto.createHash('sha256').update(thumbBytes).digest('hex');
+      const thumbOrigName = `${path.parse(safeOrig).name}_preview_thumb.webp`;
+      thumbAsset = buildMediaAsset(
+        thumbId,
+        { type: 'image', mime: 'image/webp' },
+        thumbOrigName,
+        thumbRelPath,
+        thumbSha,
+        thumbBytes.length,
+      );
+    }
 
     const oldPreviewId = sc.previewAssetId;
+    const oldThumbId = sc.previewThumbAssetId ?? null;
 
     await this.updateProject((p) => {
       const scene = p.scenes[sceneId];
       if (!scene) throw new Error('Scene not found');
       let assets: Record<AssetId, MediaAsset> = { ...p.assets };
-      if (oldPreviewId) {
-        assets = Object.fromEntries(Object.entries(assets).filter(([k]) => k !== oldPreviewId)) as Record<
-          AssetId,
-          MediaAsset
-        >;
+      const drop = new Set<AssetId>();
+      if (oldPreviewId) drop.add(oldPreviewId);
+      if (oldThumbId) drop.add(oldThumbId);
+      if (drop.size > 0) {
+        assets = Object.fromEntries(
+          Object.entries(assets).filter(([k]) => !drop.has(k as AssetId)),
+        ) as Record<AssetId, MediaAsset>;
       }
       assets[id] = asset;
+      if (thumbAsset !== null && thumbId !== null) {
+        assets[thumbId] = thumbAsset;
+      }
       return {
         ...p,
         assets,
@@ -262,6 +372,7 @@ export class ZipProjectStore {
             ...scene,
             previewAssetId: id,
             previewAssetType: kind.type,
+            previewThumbAssetId: thumbId,
             previewVideoAutostart: kind.type === 'video' ? scene.previewVideoAutostart : false,
           },
         },
@@ -279,14 +390,17 @@ export class ZipProjectStore {
     const sc = open.project.scenes[sceneId];
     if (!sc) throw new Error('Scene not found');
     const oldId = sc.previewAssetId;
-    if (!oldId) {
+    const oldThumbId = sc.previewThumbAssetId ?? null;
+    if (!oldId && !oldThumbId) {
       return open.project;
     }
     await this.updateProject((p) => {
-      const assets = Object.fromEntries(Object.entries(p.assets).filter(([k]) => k !== oldId)) as Record<
-        AssetId,
-        MediaAsset
-      >;
+      const drop = new Set<AssetId>();
+      if (oldId) drop.add(oldId);
+      if (oldThumbId) drop.add(oldThumbId);
+      const assets = Object.fromEntries(
+        Object.entries(p.assets).filter(([k]) => !drop.has(k as AssetId)),
+      ) as Record<AssetId, MediaAsset>;
       return {
         ...p,
         assets,
@@ -296,6 +410,7 @@ export class ZipProjectStore {
             ...p.scenes[sceneId],
             previewAssetId: null,
             previewAssetType: null,
+            previewThumbAssetId: null,
             previewVideoAutostart: false,
           },
         },
@@ -334,6 +449,7 @@ export class ZipProjectStore {
         layout: { x: 0, y: 0 },
         previewAssetId: null,
         previewAssetType: null,
+        previewThumbAssetId: null,
         previewVideoAutostart: false,
         previewRotationDeg: 0,
       } satisfies Scene);
@@ -344,6 +460,9 @@ export class ZipProjectStore {
       ...(patch.description !== undefined ? { description: patch.description } : null),
       ...(patch.previewAssetId !== undefined ? { previewAssetId: patch.previewAssetId } : null),
       ...(patch.previewAssetType !== undefined ? { previewAssetType: patch.previewAssetType } : null),
+      ...(patch.previewThumbAssetId !== undefined
+        ? { previewThumbAssetId: patch.previewThumbAssetId }
+        : null),
       ...(patch.previewVideoAutostart !== undefined
         ? { previewVideoAutostart: patch.previewVideoAutostart }
         : null),
@@ -574,6 +693,61 @@ export class ZipProjectStore {
     return { project: latest, imported: staged };
   }
 
+  /**
+   * Copies audio files into cache `assets/` and registers them on the project as campaign audio.
+   */
+  async importCampaignAudioFiles(filePaths: string[]): Promise<{ project: Project; imported: MediaAsset[] }> {
+    const open = this.openProject;
+    if (!open) throw new Error('No open project');
+    if (filePaths.length === 0) {
+      return { project: open.project, imported: [] };
+    }
+
+    const staged: MediaAsset[] = [];
+    for (const filePath of filePaths) {
+      const kind = classifyMediaPath(filePath);
+      if (kind?.type !== 'audio') continue;
+      const buf = await fs.readFile(filePath);
+      const sha256 = crypto.createHash('sha256').update(buf).digest('hex');
+      const id = asAssetId(this.randomId());
+      const orig = path.basename(filePath);
+      const safeOrig = sanitizeFileName(orig);
+      const relPath = `assets/${id}_${safeOrig}`;
+      const abs = path.join(open.cacheDir, relPath);
+      await fs.mkdir(path.dirname(abs), { recursive: true });
+      await fs.copyFile(filePath, abs);
+      staged.push(buildMediaAsset(id, kind, orig, relPath, sha256, buf.length));
+    }
+
+    if (staged.length === 0) {
+      return { project: open.project, imported: [] };
+    }
+
+    await this.updateProject((p) => {
+      const assets = { ...p.assets };
+      const campaignAudios = [...p.campaignAudios];
+      for (const asset of staged) {
+        assets[asset.id] = asset;
+        if (asset.type !== 'audio') continue;
+        campaignAudios.push({ assetId: asset.id, autoplay: true, loop: true });
+      }
+      return { ...p, assets, campaignAudios };
+    });
+
+    const latest = this.getOpenProject();
+    if (!latest) throw new Error('No open project');
+    return { project: latest, imported: staged };
+  }
+
+  async setCampaignAudios(audios: Project['campaignAudios']): Promise<Project> {
+    const open = this.openProject;
+    if (!open) throw new Error('No open project');
+    await this.updateProject((p) => ({ ...p, campaignAudios: Array.isArray(audios) ? audios : [] }));
+    const latest = this.getOpenProject();
+    if (!latest) throw new Error('No open project');
+    return latest;
+  }
+
   async saveNow(): Promise<void> {
     const open = this.openProject;
     if (!open) return;
@@ -700,6 +874,11 @@ export class ZipProjectStore {
     const tmpPath = `${zipPath}.tmp`;
     await fs.mkdir(path.dirname(zipPath), { recursive: true });
     await zipDir(cacheDir, tmpPath);
+    const st = await fs.stat(tmpPath).catch(() => null);
+    if (!st?.isFile() || st.size < 22) {
+      await fs.unlink(tmpPath).catch(() => undefined);
+      throw new Error('Сборка архива проекта не удалась (пустой или повреждённый временный файл)');
+    }
     await replaceFileAtomic(tmpPath, zipPath);
   }
 
@@ -708,7 +887,10 @@ export class ZipProjectStore {
    * Если архив уже лежит в `projects`, только открывает.
    * При конфликте `id` с другим файлом перезаписывает `project.json` в копии с новым id.
    */
-  async importProjectFromExternalZip(sourcePath: string): Promise<Project> {
+  async importProjectFromExternalZip(
+    sourcePath: string,
+    onProgress?: (p: { stage: 'copy' | 'unzip' | 'done'; percent: number; detail?: string }) => void,
+  ): Promise<Project> {
     await this.ensureRoots();
     const resolved = path.resolve(sourcePath);
     const st = await fs.stat(resolved).catch(() => null);
@@ -733,7 +915,12 @@ export class ZipProjectStore {
     } else {
       destFileName = await uniqueDndZipFileName(root, baseName);
       destPath = path.join(root, destFileName);
-      await fs.copyFile(resolved, destPath);
+      if (onProgress) onProgress({ stage: 'copy', percent: 1, detail: 'Копирование…' });
+      await copyFileWithProgress(resolved, destPath, (pct) => {
+        if (!onProgress) return;
+        // Copy is ~70% of the operation; unzip/open happens after.
+        onProgress({ stage: 'copy', percent: Math.max(1, Math.min(70, pct)), detail: 'Копирование…' });
+      });
     }
 
     let project = await readProjectJsonFromZip(destPath);
@@ -756,12 +943,24 @@ export class ZipProjectStore {
     }
 
     this.projectSession += 1;
-    return this.openProjectById(project.id);
+    const opened = await this.openProjectByIdWithProgress(project.id, (pct) => {
+      if (onProgress) onProgress({ stage: 'unzip', percent: pct, detail: 'Распаковка…' });
+    });
+    if (onProgress) onProgress({ stage: 'done', percent: 100, detail: 'Готово' });
+    return opened;
   }
 
   /** Копия файла проекта в указанный путь (полный путь к `.dnd.zip`). */
-  async exportProjectZipToPath(projectId: ProjectId, destinationPath: string): Promise<void> {
+  async exportProjectZipToPath(
+    projectId: ProjectId,
+    destinationPath: string,
+    onProgress?: (p: { stage: 'copy' | 'done'; percent: number; detail?: string }) => void,
+  ): Promise<void> {
     await this.ensureRoots();
+    // If exporting the currently open project, make sure pending debounced pack is flushed.
+    if (this.openProject?.id === projectId) {
+      await this.saveNow();
+    }
     const list = await this.listProjects();
     const entry = list.find((p) => p.id === projectId);
     if (!entry) {
@@ -770,7 +969,11 @@ export class ZipProjectStore {
     const src = path.join(getProjectsRootDir(), entry.fileName);
     const dest = path.resolve(destinationPath);
     await fs.mkdir(path.dirname(dest), { recursive: true });
-    await fs.copyFile(src, dest);
+    if (onProgress) onProgress({ stage: 'copy', percent: 1, detail: 'Копирование…' });
+    await copyFileWithProgress(src, dest, (pct) => {
+      if (onProgress) onProgress({ stage: 'copy', percent: pct, detail: 'Копирование…' });
+    });
+    if (onProgress) onProgress({ stage: 'done', percent: 100, detail: 'Готово' });
   }
 
   /** Удаляет архив проекта и кэш распаковки с диска. Если проект открыт — сбрасывает сессию. */
@@ -792,8 +995,20 @@ export class ZipProjectStore {
       this.projectSession += 1;
     }
 
-    await fs.rm(zipPath, { force: true }).catch(() => undefined);
-    await fs.rm(cacheDir, { recursive: true, force: true }).catch(() => undefined);
+    await rmWithRetries(fs.rm, zipPath, { force: true });
+    await rmWithRetries(fs.rm, cacheDir, { recursive: true, force: true });
+
+    // Если проект подтянулся миграцией из legacy userData (другое имя приложения),
+    // то после удаления из текущей папки он может снова появиться при следующем ensureRoots().
+    // Поэтому удаляем и legacy-копии архива.
+    for (const legacyRoot of getLegacyProjectsRootDirs()) {
+      const legacyZipPath = path.join(legacyRoot, entry.fileName);
+      try {
+        await rmWithRetries(fs.rm, legacyZipPath, { force: true });
+      } catch {
+        /* ignore */
+      }
+    }
   }
 
   private randomId(): string {
@@ -901,6 +1116,8 @@ function normalizeScene(s: Scene): Scene {
     (s as unknown as { previewVideoAutostostart?: boolean; previewVideoAutostart?: boolean })
       .previewVideoAutostart,
   );
+  const previewThumbAssetId =
+    (s as unknown as { previewThumbAssetId?: AssetId | null }).previewThumbAssetId ?? null;
 
   const rawAudios = Array.isArray(raw.audios) ? raw.audios : [];
   const audios = rawAudios
@@ -925,6 +1142,7 @@ function normalizeScene(s: Scene): Scene {
     ...s,
     previewAssetId: previewAssetId ?? null,
     previewAssetType,
+    previewThumbAssetId,
     previewVideoAutostart,
     previewRotationDeg,
     layout: layoutIn ?? { x: 0, y: 0 },
@@ -955,6 +1173,18 @@ function normalizeProject(p: Project): Project {
   }
   sceneGraphNodes = normalizeSceneGraphNodeFlags(sceneGraphNodes);
   const currentGraphNodeId = (p as { currentGraphNodeId?: GraphNodeId | null }).currentGraphNodeId ?? null;
+  const rawCampaignAudios = (p as unknown as { campaignAudios?: unknown[] }).campaignAudios;
+  const campaignAudios = (Array.isArray(rawCampaignAudios) ? rawCampaignAudios : [])
+    .map((a) => {
+      if (typeof a === 'string') return { assetId: a as AssetId, autoplay: false, loop: false };
+      if (a && typeof a === 'object') {
+        const obj = a as { assetId?: AssetId; autoplay?: boolean; loop?: boolean };
+        if (!obj.assetId) return null;
+        return { assetId: obj.assetId, autoplay: Boolean(obj.autoplay), loop: Boolean(obj.loop) };
+      }
+      return null;
+    })
+    .filter((x): x is { assetId: AssetId; autoplay: boolean; loop: boolean } => Boolean(x));
   const metaRaw = p.meta as unknown as { createdWithAppVersion?: string; appVersion?: string };
   const createdWithAppVersion = (() => {
     const c = metaRaw.createdWithAppVersion?.trim();
@@ -974,6 +1204,7 @@ function normalizeProject(p: Project): Project {
       schemaVersion: PROJECT_SCHEMA_VERSION,
     },
     scenes,
+    campaignAudios,
     sceneGraphNodes,
     sceneGraphEdges,
     currentGraphNodeId,
@@ -1006,18 +1237,38 @@ async function uniqueDndZipFileName(root: string, preferredBaseFileName: string)
   }
 }
 
-async function replaceFileAtomic(srcPath: string, destPath: string): Promise<void> {
+async function copyFileWithProgress(
+  src: string,
+  dest: string,
+  onPercent: (pct: number) => void,
+): Promise<void> {
+  const st = await fs.stat(src);
+  const total = st.size || 0;
+  if (total <= 0) {
+    await fs.copyFile(src, dest);
+    onPercent(100);
+    return;
+  }
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await new Promise<void>((resolve, reject) => {
+    let done = 0;
+    const rs = fssync.createReadStream(src);
+    const ws = fssync.createWriteStream(dest);
+    const onErr = (e: unknown) => reject(e instanceof Error ? e : new Error(String(e)));
+    rs.on('error', onErr);
+    ws.on('error', onErr);
+    rs.on('data', (chunk: Buffer) => {
+      done += chunk.length;
+      const pct = Math.round((done / total) * 100);
       try {
-    await fs.rename(srcPath, destPath);
+        onPercent(Math.max(0, Math.min(100, pct)));
       } catch {
-    try {
-      await fs.rm(destPath, { force: true });
-      await fs.rename(srcPath, destPath);
-    } catch (second: unknown) {
-      await fs.unlink(srcPath).catch(() => undefined);
-      throw second instanceof Error ? second : new Error(String(second));
-    }
+        // ignore
       }
+    });
+    ws.on('close', () => resolve());
+    rs.pipe(ws);
+  });
 }
 
 type MediaKind = { type: MediaAssetType; mime: string };
@@ -1034,6 +1285,8 @@ function classifyMediaPath(filePath: string): MediaKind | null {
       return { type: 'image', mime: 'image/webp' };
     case '.gif':
       return { type: 'image', mime: 'image/gif' };
+    case '.bmp':
+      return { type: 'image', mime: 'image/bmp' };
     case '.mp4':
       return { type: 'video', mime: 'video/mp4' };
     case '.webm':
@@ -1083,17 +1336,7 @@ async function atomicWriteFile(filePath: string, contents: string): Promise<void
   await fs.mkdir(dir, { recursive: true });
   const tmp = path.join(dir, `.tmp_${path.basename(filePath)}_${crypto.randomBytes(8).toString('hex')}`);
   await fs.writeFile(tmp, contents, 'utf8');
-  try {
-    await fs.rename(tmp, filePath);
-  } catch {
-    try {
-      await fs.rm(filePath, { force: true });
-      await fs.rename(tmp, filePath);
-    } catch (second: unknown) {
-      await fs.unlink(tmp).catch(() => undefined);
-      throw second instanceof Error ? second : new Error(String(second));
-    }
-  }
+  await replaceFileAtomic(tmp, filePath);
 }
 
 /** Уже сжатые контейнеры/кодеки — в ZIP кладём без deflate, качество не трогаем; project.json и сырьё — deflate 9. */

app/main/update/installAutoUpdater.ts

@@ -0,0 +1,71 @@
+import { app, dialog } from 'electron';
+import { autoUpdater } from 'electron-updater';
+
+import { addLicenseChangeListener } from '../license/licenseService';
+import type { LicenseService } from '../license/licenseService';
+
+const STARTUP_CHECK_DELAY_MS = 12_000;
+/** Не дёргать сервер чаще (смена лицензии / повторные emit). */
+const RE_CHECK_COOLDOWN_MS = 30_000;
+
+let lastCheckAt = 0;
+
+function isLicensedForUpdates(licenseService: LicenseService): boolean {
+  const snap = licenseService.getStatusSync();
+  return snap.active;
+}
+
+function maybeCheckForUpdates(licenseService: LicenseService, ignoreCooldown: boolean): void {
+  if (!app.isPackaged) return;
+  if (!isLicensedForUpdates(licenseService)) return;
+  const now = Date.now();
+  if (!ignoreCooldown && now - lastCheckAt < RE_CHECK_COOLDOWN_MS) return;
+  lastCheckAt = now;
+  void autoUpdater.checkForUpdates().catch(() => undefined);
+}
+
+/**
+ * Проверка обновлений: только упакованное приложение, только при активной лицензии.
+ * Канал и URL задаются при сборке (`publish` → `app-update.yml` внутри установки).
+ */
+export function installAutoUpdater(licenseService: LicenseService): void {
+  if (!app.isPackaged) return;
+
+  const feedOverride = process.env.DND_UPDATE_FEED_URL?.trim();
+  if (feedOverride) {
+    const url = feedOverride.endsWith('/') ? feedOverride : `${feedOverride}/`;
+    autoUpdater.setFeedURL({ provider: 'generic', url });
+  }
+
+  autoUpdater.autoDownload = true;
+  autoUpdater.autoInstallOnAppQuit = true;
+
+  autoUpdater.on('update-downloaded', (info) => {
+    void dialog
+      .showMessageBox({
+        type: 'info',
+        title: 'DNDGamePlayer',
+        message: `Доступна новая версия ${info.version}. Установить и перезапустить?`,
+        buttons: ['Перезапустить сейчас', 'Позже'],
+        defaultId: 0,
+        cancelId: 1,
+      })
+      .then((r) => {
+        if (r.response === 0) {
+          autoUpdater.quitAndInstall(false, true);
+        }
+      });
+  });
+
+  autoUpdater.on('error', () => {
+    /* без console: в production main минифицируется с drop console */
+  });
+
+  addLicenseChangeListener(() => {
+    maybeCheckForUpdates(licenseService, false);
+  });
+
+  setTimeout(() => {
+    maybeCheckForUpdates(licenseService, true);
+  }, STARTUP_CHECK_DELAY_MS);
+}

app/main/windows/createWindows.ts

@@ -3,6 +3,8 @@ import path from 'node:path';
 
 import { app, BrowserWindow, nativeImage, screen } from 'electron';
 
+import { ipcChannels } from '../../shared/ipc/contracts';
+
 import { getBootSplashWindow } from './bootWindow';
 
 type WindowKind = 'editor' | 'presentation' | 'control';
@@ -11,6 +13,19 @@ const windows = new Map<WindowKind, BrowserWindow>();
 
 let appQuitting = false;
 
+/** Учитываем окна, которые уже уничтожены при каскадном закрытии (родитель → дочернее). */
+function broadcastMultiWindowStateChanged(open: boolean): void {
+  for (const w of BrowserWindow.getAllWindows()) {
+    if (w.isDestroyed()) continue;
+    if (w.webContents.isDestroyed()) continue;
+    try {
+      w.webContents.send(ipcChannels.windows.multiWindowStateChanged, { open });
+    } catch {
+      /* окно могло закрыться между проверкой и send */
+    }
+  }
+}
+
 /** Разрешает реальное закрытие окна редактора (выход из приложения). */
 export function markAppQuitting(): void {
   appQuitting = true;
@@ -207,6 +222,11 @@ function createWindow(kind: WindowKind, opts?: CreateWindowOpts): BrowserWindow
     });
   }
   win.on('closed', () => windows.delete(kind));
+  win.on('closed', () => {
+    if (kind !== 'presentation' && kind !== 'control') return;
+    const open = windows.has('presentation') || windows.has('control');
+    broadcastMultiWindowStateChanged(open);
+  });
   windows.set(kind, win);
   return win;
 }
@@ -279,8 +299,11 @@ export function openMultiWindow() {
     presentation.maximize();
   }
   if (!windows.has('control')) {
-    createWindow('control', { parent: presentation });
+    // macOS: parent-child window binding moves child with the parent (unlike Windows behavior we want).
+    // Keep control window independent on darwin.
+    createWindow('control', process.platform === 'darwin' ? undefined : { parent: presentation });
   }
+  broadcastMultiWindowStateChanged(true);
 }
 
 export function closeMultiWindow(): void {
@@ -290,6 +313,10 @@ export function closeMultiWindow(): void {
   if (ctrl) ctrl.close();
 }
 
+export function isMultiWindowOpen(): boolean {
+  return windows.has('presentation') || windows.has('control');
+}
+
 export function togglePresentationFullscreen(): boolean {
   const pres = windows.get('presentation');
   if (!pres) return false;

app/renderer/control/ControlApp.tsx

@@ -4,6 +4,7 @@ import { pickEraseTargetId } from '../../shared/effectEraserHitTest';
 import { ipcChannels } from '../../shared/ipc/contracts';
 import type { SessionState } from '../../shared/ipc/contracts';
 import type { GraphNodeId, Scene, SceneId } from '../../shared/types';
+import { useEditorI18n } from '../editor/i18n/EditorI18nContext';
 import { getDndApi } from '../shared/dndApi';
 import { PixiEffectsOverlay } from '../shared/effects/PxiEffectsOverlay';
 import { useEffectsState } from '../shared/effects/useEffectsState';
@@ -44,15 +45,26 @@ function playLightningEffectSound(): void {
 
 export function ControlApp() {
   const api = getDndApi();
+  const { t } = useEditorI18n();
+  const tRef = useRef(t);
+  tRef.current = t;
   const [fxState, fx] = useEffectsState();
   const [session, setSession] = useState<SessionState | null>(null);
   const historyRef = useRef<GraphNodeId[]>([]);
   const suppressNextHistoryPushRef = useRef(false);
   const [history, setHistory] = useState<GraphNodeId[]>([]);
-  const audioElsRef = useRef<Map<string, HTMLAudioElement>>(new Map());
-  const audioMetaRef = useRef<Map<string, { lastPlayError: string | null }>>(new Map());
-  const [audioStateTick, setAudioStateTick] = useState(0);
-  const audioLoadRunRef = useRef(0);
+  const sceneAudioElsRef = useRef<Map<string, HTMLAudioElement>>(new Map());
+  const sceneAudioMetaRef = useRef<Map<string, { lastPlayError: string | null }>>(new Map());
+  const [sceneAudioStateTick, setSceneAudioStateTick] = useState(0);
+  const sceneAudioLoadRunRef = useRef(0);
+
+  const campaignAudioElsRef = useRef<Map<string, HTMLAudioElement>>(new Map());
+  const campaignAudioMetaRef = useRef<Map<string, { lastPlayError: string | null }>>(new Map());
+  const [campaignAudioStateTick, setCampaignAudioStateTick] = useState(0);
+  const campaignAudioLoadRunRef = useRef(0);
+  /** Snapshot of `!el.paused` per assetId when scene music takes over; used to resume when `allowCampaignAudio` is true again. */
+  const campaignResumeAfterSceneRef = useRef<Map<string, boolean> | null>(null);
+  const allowCampaignAudioRef = useRef<boolean>(true);
   const audioUnmountRef = useRef(false);
   const previewHostRef = useRef<HTMLDivElement | null>(null);
   const previewVideoRef = useRef<HTMLVideoElement | null>(null);
@@ -137,6 +149,17 @@ export function ControlApp() {
     project && session?.currentSceneId ? project.scenes[session.currentSceneId] : undefined;
   const isVideoPreviewScene = currentScene?.previewAssetType === 'video';
   const sceneAudioRefs = useMemo(() => currentScene?.media.audios ?? [], [currentScene]);
+  // Keep this memo as narrow as possible: project changes on scene switch,
+  // but campaign audio list/config often does not.
+  const campaignAudioRefs = useMemo(() => project?.campaignAudios ?? [], [project?.campaignAudios]);
+  const allowCampaignAudio = !sceneAudioRefs.some((a) => a.autoplay);
+  allowCampaignAudioRef.current = allowCampaignAudio;
+
+  const campaignAudioSpecKey = useMemo(
+    () =>
+      campaignAudioRefs.map((r) => `${r.assetId}:${r.loop ? '1' : '0'}:${r.autoplay ? '1' : '0'}`).join('|'),
+    [campaignAudioRefs],
+  );
 
   const sceneAudios = useMemo(() => {
     if (!project) return [];
@@ -150,14 +173,26 @@ export function ControlApp() {
       );
   }, [project, sceneAudioRefs]);
 
-  useEffect(() => {
-    audioLoadRunRef.current += 1;
-    const runId = audioLoadRunRef.current;
+  const campaignAudios = useMemo(() => {
+    if (!project) return [];
+    return campaignAudioRefs
+      .map((r) => {
+        const a = project.assets[r.assetId];
+        return a?.type === 'audio' ? { ref: r, asset: a } : null;
+      })
+      .filter((x): x is { ref: (typeof campaignAudioRefs)[number]; asset: NonNullable<typeof x>['asset'] } =>
+        Boolean(x),
+      );
+  }, [campaignAudioRefs, project]);
 
-    const oldEls = new Map(audioElsRef.current);
-    audioElsRef.current = new Map();
-    audioMetaRef.current.clear();
-    setAudioStateTick((x) => x + 1);
+  useEffect(() => {
+    sceneAudioLoadRunRef.current += 1;
+    const runId = sceneAudioLoadRunRef.current;
+
+    const oldEls = new Map(sceneAudioElsRef.current);
+    sceneAudioElsRef.current = new Map();
+    sceneAudioMetaRef.current.clear();
+    setSceneAudioStateTick((x) => x + 1);
 
     const FADE_OUT_MS = 450;
     const fadeOutCtl = { raf: 0, cancelled: false };
@@ -213,24 +248,24 @@ export function ControlApp() {
       const loaded: { ref: (typeof sceneAudioRefs)[number]; el: HTMLAudioElement }[] = [];
       for (const item of sceneAudioRefs) {
         const r = await api.invoke(ipcChannels.project.assetFileUrl, { assetId: item.assetId });
-        if (audioLoadRunRef.current !== runId) return;
+        if (sceneAudioLoadRunRef.current !== runId) return;
         if (!r.url) continue;
         const el = new Audio(r.url);
         el.loop = item.loop;
         el.preload = 'auto';
         el.volume = item.autoplay ? 0 : 1;
-        audioMetaRef.current.set(item.assetId, { lastPlayError: null });
-        el.addEventListener('play', () => setAudioStateTick((x) => x + 1));
-        el.addEventListener('pause', () => setAudioStateTick((x) => x + 1));
-        el.addEventListener('ended', () => setAudioStateTick((x) => x + 1));
-        el.addEventListener('canplay', () => setAudioStateTick((x) => x + 1));
-        el.addEventListener('error', () => setAudioStateTick((x) => x + 1));
+        sceneAudioMetaRef.current.set(item.assetId, { lastPlayError: null });
+        el.addEventListener('play', () => setSceneAudioStateTick((x) => x + 1));
+        el.addEventListener('pause', () => setSceneAudioStateTick((x) => x + 1));
+        el.addEventListener('ended', () => setSceneAudioStateTick((x) => x + 1));
+        el.addEventListener('canplay', () => setSceneAudioStateTick((x) => x + 1));
+        el.addEventListener('error', () => setSceneAudioStateTick((x) => x + 1));
         loaded.push({ ref: item, el });
-        audioElsRef.current.set(item.assetId, el);
+        sceneAudioElsRef.current.set(item.assetId, el);
       }
-      setAudioStateTick((x) => x + 1);
+      setSceneAudioStateTick((x) => x + 1);
       for (const { ref, el } of loaded) {
-        if (audioLoadRunRef.current !== runId) {
+        if (sceneAudioLoadRunRef.current !== runId) {
           try {
             el.pause();
             el.currentTime = 0;
@@ -244,13 +279,12 @@ export function ControlApp() {
         try {
           await el.play();
         } catch {
-          const m = audioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
-          audioMetaRef.current.set(ref.assetId, {
+          const m = sceneAudioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
+          sceneAudioMetaRef.current.set(ref.assetId, {
             ...m,
-            lastPlayError:
-              'Автозапуск заблокирован (нужно действие пользователя) или ошибка воспроизведения.',
+            lastPlayError: tRef.current('control.audioAutoplayBlocked'),
           });
-          setAudioStateTick((x) => x + 1);
+          setSceneAudioStateTick((x) => x + 1);
           try {
             el.volume = 1;
           } catch {
@@ -258,7 +292,7 @@ export function ControlApp() {
           }
           continue;
         }
-        if (audioLoadRunRef.current !== runId || audioUnmountRef.current) {
+        if (sceneAudioLoadRunRef.current !== runId || audioUnmountRef.current) {
           try {
             el.volume = 1;
           } catch {
@@ -268,7 +302,7 @@ export function ControlApp() {
         }
         const tIn0 = performance.now();
         const tickIn = (now: number): void => {
-          if (audioLoadRunRef.current !== runId || audioUnmountRef.current) {
+          if (sceneAudioLoadRunRef.current !== runId || audioUnmountRef.current) {
             try {
               el.volume = 1;
             } catch {
@@ -294,19 +328,202 @@ export function ControlApp() {
     };
   }, [api, currentScene, project, sceneAudioRefs]);
 
+  // Campaign elements: lifecycle depends only on campaign track list/config, not scene or allowCampaignAudio
+  // (scene music uses allowCampaignAudioRef + separate pause/resume effect).
+  // Spec is encoded in campaignAudioSpecKey; campaignAudioRefs is intentionally omitted to avoid scene-switch churn.
+  useEffect(() => {
+    campaignAudioLoadRunRef.current += 1;
+    const runId = campaignAudioLoadRunRef.current;
+
+    const oldEls = new Map(campaignAudioElsRef.current);
+    campaignAudioElsRef.current = new Map();
+    campaignAudioMetaRef.current.clear();
+    setCampaignAudioStateTick((x) => x + 1);
+
+    for (const el of oldEls.values()) {
+      try {
+        el.pause();
+        el.volume = 1;
+      } catch {
+        // ignore
+      }
+    }
+
+    if (campaignAudioSpecKey === '') {
+      return;
+    }
+
+    void (async () => {
+      const loaded: { ref: (typeof campaignAudioRefs)[number]; el: HTMLAudioElement }[] = [];
+      for (const item of campaignAudioRefs) {
+        const r = await api.invoke(ipcChannels.project.assetFileUrl, { assetId: item.assetId });
+        if (campaignAudioLoadRunRef.current !== runId) return;
+        if (!r.url) continue;
+        const el = new Audio(r.url);
+        el.loop = item.loop;
+        el.preload = 'auto';
+        el.volume = item.autoplay ? 0 : 1;
+        campaignAudioMetaRef.current.set(item.assetId, { lastPlayError: null });
+        el.addEventListener('play', () => setCampaignAudioStateTick((x) => x + 1));
+        el.addEventListener('pause', () => setCampaignAudioStateTick((x) => x + 1));
+        el.addEventListener('ended', () => setCampaignAudioStateTick((x) => x + 1));
+        el.addEventListener('canplay', () => setCampaignAudioStateTick((x) => x + 1));
+        el.addEventListener('error', () => setCampaignAudioStateTick((x) => x + 1));
+        loaded.push({ ref: item, el });
+        campaignAudioElsRef.current.set(item.assetId, el);
+      }
+      setCampaignAudioStateTick((x) => x + 1);
+
+      if (!allowCampaignAudioRef.current) return;
+
+      for (const { ref, el } of loaded) {
+        if (campaignAudioLoadRunRef.current !== runId) return;
+        if (!ref.autoplay) continue;
+        try {
+          await el.play();
+        } catch {
+          const m = campaignAudioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
+          campaignAudioMetaRef.current.set(ref.assetId, {
+            ...m,
+            lastPlayError: tRef.current('control.audioAutoplayBlocked'),
+          });
+          setCampaignAudioStateTick((x) => x + 1);
+          try {
+            el.volume = 1;
+          } catch {
+            // ignore
+          }
+          continue;
+        }
+        if (campaignAudioLoadRunRef.current !== runId || audioUnmountRef.current) {
+          try {
+            el.volume = 1;
+          } catch {
+            // ignore
+          }
+          continue;
+        }
+        const tIn0 = performance.now();
+        const tickIn = (now: number): void => {
+          if (campaignAudioLoadRunRef.current !== runId || audioUnmountRef.current) {
+            try {
+              el.volume = 1;
+            } catch {
+              // ignore
+            }
+            return;
+          }
+          const u = Math.min(1, (now - tIn0) / 550);
+          try {
+            el.volume = u;
+          } catch {
+            // ignore
+          }
+          if (u < 1) window.requestAnimationFrame(tickIn);
+        };
+        window.requestAnimationFrame(tickIn);
+      }
+    })();
+    // Deps: api + campaignAudioSpecKey only; list iteration uses current campaignAudioRefs (stable while spec is stable).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [api, campaignAudioSpecKey]);
+
+  useEffect(() => {
+    if (allowCampaignAudio) {
+      const snap = campaignResumeAfterSceneRef.current;
+      campaignResumeAfterSceneRef.current = null;
+      if (snap && snap.size > 0) {
+        void (async () => {
+          for (const [assetId, wasPlaying] of snap) {
+            if (!wasPlaying) continue;
+            const el = campaignAudioElsRef.current.get(assetId) ?? null;
+            if (!el) continue;
+            try {
+              // If a track was created with autoplay volume ramp but never started yet,
+              // ensure it is audible on resume.
+              if (el.volume === 0) el.volume = 1;
+              await el.play();
+            } catch {
+              // ignore; user can press play
+            }
+          }
+          setCampaignAudioStateTick((x) => x + 1);
+        })();
+      }
+      // If we entered a scene that allows campaign audio and there was no "resume snapshot"
+      // (e.g. first scene had autoplay scene music so campaign autoplay was blocked),
+      // start campaign tracks that have autoplay enabled.
+      if (!snap || snap.size === 0) {
+        void (async () => {
+          for (const ref of campaignAudioRefs) {
+            if (!ref.autoplay) continue;
+            const el = campaignAudioElsRef.current.get(ref.assetId) ?? null;
+            if (!el) continue;
+            if (!el.paused) continue;
+            try {
+              el.volume = 0;
+            } catch {
+              // ignore
+            }
+            try {
+              await el.play();
+            } catch {
+              // ignore; user can press play
+              continue;
+            }
+            const tIn0 = performance.now();
+            const tickIn = (now: number): void => {
+              if (!allowCampaignAudioRef.current || audioUnmountRef.current) return;
+              const u = Math.min(1, (now - tIn0) / 550);
+              try {
+                el.volume = u;
+              } catch {
+                // ignore
+              }
+              if (u < 1) window.requestAnimationFrame(tickIn);
+            };
+            window.requestAnimationFrame(tickIn);
+          }
+          setCampaignAudioStateTick((x) => x + 1);
+        })();
+      }
+      return;
+    }
+    // Scene has its own audio: remember what was playing, then pause campaign. (keep currentTime)
+    const snap = new Map<string, boolean>();
+    for (const [assetId, el] of campaignAudioElsRef.current) {
+      snap.set(assetId, !el.paused);
+    }
+    campaignResumeAfterSceneRef.current = snap;
+    for (const el of campaignAudioElsRef.current.values()) {
+      try {
+        el.pause();
+      } catch {
+        // ignore
+      }
+    }
+    setCampaignAudioStateTick((x) => x + 1);
+    // Intentionally not depending on campaignAudioRefs: this effect is about scene-driven pausing/resuming.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [allowCampaignAudio]);
+
   const anyPlaying = useMemo(() => {
-    for (const el of audioElsRef.current.values()) {
+    for (const el of sceneAudioElsRef.current.values()) {
+      if (!el.paused) return true;
+    }
+    for (const el of campaignAudioElsRef.current.values()) {
       if (!el.paused) return true;
     }
     return false;
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [audioStateTick]);
+  }, [campaignAudioStateTick, sceneAudioStateTick]);
 
   useEffect(() => {
     if (!anyPlaying) return;
     let raf = 0;
     const tick = () => {
-      setAudioStateTick((x) => x + 1);
+      setSceneAudioStateTick((x) => x + 1);
+      setCampaignAudioStateTick((x) => x + 1);
       raf = window.requestAnimationFrame(tick);
     };
     raf = window.requestAnimationFrame(tick);
@@ -326,20 +543,26 @@ export function ControlApp() {
     return () => ro.disconnect();
   }, []);
 
-  function audioStatus(assetId: string): { label: string; detail?: string } {
-    const el = audioElsRef.current.get(assetId) ?? null;
-    if (!el) return { label: 'URL не получен', detail: 'Не удалось получить dnd://asset URL для аудио.' };
-    const meta = audioMetaRef.current.get(assetId) ?? { lastPlayError: null };
-    if (meta.lastPlayError) return { label: 'Ошибка/блок', detail: meta.lastPlayError };
+  function audioStatus(group: 'scene' | 'campaign', assetId: string): { label: string; detail?: string } {
+    const el =
+      group === 'scene'
+        ? (sceneAudioElsRef.current.get(assetId) ?? null)
+        : (campaignAudioElsRef.current.get(assetId) ?? null);
+    if (!el) return { label: t('control.audioNoUrl'), detail: t('control.audioNoUrlDetail') };
+    const meta =
+      group === 'scene'
+        ? (sceneAudioMetaRef.current.get(assetId) ?? { lastPlayError: null })
+        : (campaignAudioMetaRef.current.get(assetId) ?? { lastPlayError: null });
+    if (meta.lastPlayError) return { label: t('control.audioBlocked'), detail: meta.lastPlayError };
     if (el.error)
       return {
-        label: 'Ошибка',
-        detail: `MediaError code=${String(el.error.code)} (1=ABORTED, 2=NETWORK, 3=DECODE, 4=SRC_NOT_SUPPORTED)`,
+        label: t('control.audioError'),
+        detail: t('control.audioMediaError', { code: String(el.error.code) }),
       };
-    if (el.readyState < 2) return { label: 'Загрузка…' };
-    if (!el.paused) return { label: 'Играет' };
-    if (el.currentTime > 0) return { label: 'Пауза' };
-    return { label: 'Остановлено' };
+    if (el.readyState < 2) return { label: t('control.audioLoading') };
+    if (!el.paused) return { label: t('control.audioPlaying') };
+    if (el.currentTime > 0) return { label: t('control.audioPaused') };
+    return { label: t('control.audioStopped') };
   }
   const nextScenes = useMemo(() => {
     if (!project) return [];
@@ -734,21 +957,21 @@ export function ControlApp() {
   return (
     <div className={styles.page}>
       <Surface className={styles.remote}>
-        <div className={styles.remoteTitle}>ПУЛЬТ УПРАВЛЕНИЯ</div>
+        <div className={styles.remoteTitle}>{t('control.remoteTitle')}</div>
         <div className={styles.spacer12} />
         {!isVideoPreviewScene ? (
           <>
-            <div className={styles.sectionLabel}>ЭФФЕКТЫ</div>
+            <div className={styles.sectionLabel}>{t('control.effects')}</div>
             <div className={styles.spacer8} />
             <div className={styles.effectsStack}>
               <div className={styles.effectsGroup}>
-                <div className={styles.subsectionLabel}>Инструменты</div>
+                <div className={styles.subsectionLabel}>{t('control.tools')}</div>
                 <div className={styles.iconRow}>
                   <Button
                     variant={tool.tool === 'eraser' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Ластик"
-                    ariaLabel="Ластик"
+                    title={t('control.eraser')}
+                    ariaLabel={t('control.eraser')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'eraser' } })}
                   >
                     <span className={styles.iconGlyph}>🧹</span>
@@ -756,8 +979,8 @@ export function ControlApp() {
                   <Button
                     variant="ghost"
                     iconOnly
-                    title="Очистить эффекты"
-                    ariaLabel="Очистить эффекты"
+                    title={t('control.clearEffects')}
+                    ariaLabel={t('control.clearEffects')}
                     onClick={() => void fx.dispatch({ kind: 'instances.clear' })}
                   >
                     <span className={styles.clearIcon}>
@@ -778,13 +1001,13 @@ export function ControlApp() {
                 </div>
               </div>
               <div className={styles.effectsGroup}>
-                <div className={styles.subsectionLabel}>Эффекты поля</div>
+                <div className={styles.subsectionLabel}>{t('control.fieldEffects')}</div>
                 <div className={styles.iconRow}>
                   <Button
                     variant={tool.tool === 'fog' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Туман"
-                    ariaLabel="Туман"
+                    title={t('control.fog')}
+                    ariaLabel={t('control.fog')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'fog' } })}
                   >
                     <span className={styles.iconGlyph}>🌫️</span>
@@ -792,8 +1015,8 @@ export function ControlApp() {
                   <Button
                     variant={tool.tool === 'rain' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Дождь"
-                    ariaLabel="Дождь"
+                    title={t('control.rain')}
+                    ariaLabel={t('control.rain')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'rain' } })}
                   >
                     <span className={styles.iconGlyph}>🌧️</span>
@@ -801,8 +1024,8 @@ export function ControlApp() {
                   <Button
                     variant={tool.tool === 'fire' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Огонь"
-                    ariaLabel="Огонь"
+                    title={t('control.fire')}
+                    ariaLabel={t('control.fire')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'fire' } })}
                   >
                     <span className={styles.iconGlyph}>🔥</span>
@@ -810,8 +1033,8 @@ export function ControlApp() {
                   <Button
                     variant={tool.tool === 'water' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Вода"
-                    ariaLabel="Вода"
+                    title={t('control.water')}
+                    ariaLabel={t('control.water')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'water' } })}
                   >
                     <span className={styles.iconGlyph}>💧</span>
@@ -819,13 +1042,13 @@ export function ControlApp() {
                 </div>
               </div>
               <div className={styles.effectsGroup}>
-                <div className={styles.subsectionLabel}>Эффекты действий</div>
+                <div className={styles.subsectionLabel}>{t('control.actionEffects')}</div>
                 <div className={styles.iconRow}>
                   <Button
                     variant={tool.tool === 'lightning' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Молния"
-                    ariaLabel="Молния"
+                    title={t('control.lightning')}
+                    ariaLabel={t('control.lightning')}
                     onClick={() =>
                       void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'lightning' } })
                     }
@@ -835,8 +1058,8 @@ export function ControlApp() {
                   <Button
                     variant={tool.tool === 'sunbeam' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Луч света"
-                    ariaLabel="Луч света"
+                    title={t('control.sunbeam')}
+                    ariaLabel={t('control.sunbeam')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'sunbeam' } })}
                   >
                     <span className={styles.iconGlyph}>☀️</span>
@@ -844,8 +1067,8 @@ export function ControlApp() {
                   <Button
                     variant={tool.tool === 'freeze' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Заморозка"
-                    ariaLabel="Заморозка"
+                    title={t('control.freeze')}
+                    ariaLabel={t('control.freeze')}
                     onClick={() => void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'freeze' } })}
                   >
                     <span className={styles.iconGlyph}>❄️</span>
@@ -853,8 +1076,8 @@ export function ControlApp() {
                   <Button
                     variant={tool.tool === 'poisonCloud' ? 'primary' : 'ghost'}
                     iconOnly
-                    title="Облако яда"
-                    ariaLabel="Облако яда"
+                    title={t('control.poisonCloud')}
+                    ariaLabel={t('control.poisonCloud')}
                     onClick={() =>
                       void fx.dispatch({ kind: 'tool.set', tool: { ...tool, tool: 'poisonCloud' } })
                     }
@@ -864,7 +1087,7 @@ export function ControlApp() {
                 </div>
               </div>
               <div className={styles.radiusRow}>
-                <div className={styles.radiusLabel}>Радиус кисти</div>
+                <div className={styles.radiusLabel}>{t('control.brushRadius')}</div>
                 <input
                   type="range"
                   min={0.015}
@@ -877,7 +1100,7 @@ export function ControlApp() {
                     void fx.dispatch({ kind: 'tool.set', tool: { ...tool, radiusN: next } });
                   }}
                   className={styles.range}
-                  aria-label="Радиус кисти"
+                  aria-label={t('control.brushRadius')}
                 />
                 <div className={styles.radiusValue}>{Math.round(tool.radiusN * 100)}</div>
               </div>
@@ -886,7 +1109,7 @@ export function ControlApp() {
           </>
         ) : null}
         <div className={styles.storyWrap}>
-          <div className={styles.sectionLabel}>СЮЖЕТНАЯ ЛИНИЯ</div>
+          <div className={styles.sectionLabel}>{t('control.storyLine')}</div>
           <div className={styles.spacer10} />
           <div className={styles.storyScroll}>
             {history.map((gnId, idx) => {
@@ -901,7 +1124,7 @@ export function ControlApp() {
                   className={[styles.historyBtn, isCurrent ? styles.historyBtnCurrent : '']
                     .filter(Boolean)
                     .join(' ')}
-                  title={project && !isCurrent ? 'Перейти к этой сцене' : undefined}
+                  title={project && !isCurrent ? t('control.gotoScene') : undefined}
                   onClick={() => {
                     if (!project) return;
                     if (isCurrent) return;
@@ -911,15 +1134,17 @@ export function ControlApp() {
                   }}
                 >
                   {isCurrent ? (
-                    <div className={styles.historyBadge}>ТЕКУЩАЯ СЦЕНА</div>
+                    <div className={styles.historyBadge}>{t('control.currentSceneBadge')}</div>
                   ) : (
-                    <div className={styles.historyMuted}>Пройдено</div>
+                    <div className={styles.historyMuted}>{t('control.passed')}</div>
                   )}
                   <div className={styles.historyTitle}>{s?.title ?? (gn ? String(gn.sceneId) : gnId)}</div>
                 </button>
               );
             })}
-            {history.length === 0 ? <div className={styles.emptyStory}>Нет активной сцены.</div> : null}
+            {history.length === 0 ? (
+              <div className={styles.emptyStory}>{t('control.noActiveScene')}</div>
+            ) : null}
           </div>
         </div>
       </Surface>
@@ -927,20 +1152,15 @@ export function ControlApp() {
       <div className={styles.rightStack}>
         <Surface className={styles.surfacePad}>
           <div className={styles.previewHeader}>
-            <div className={styles.previewTitle}>Предпросмотр экрана</div>
+            <div className={styles.previewTitle}>{t('control.screenPreview')}</div>
             <div className={styles.previewActions}>
               <Button onClick={() => void api.invoke(ipcChannels.windows.closeMultiWindow, {})}>
-                Выключить демонстрацию
+                {t('control.stopPresentation')}
               </Button>
             </div>
           </div>
           <div className={styles.spacer10} />
-          {isVideoPreviewScene ? (
-            <div className={styles.videoHint}>
-              Видео-превью: кисть эффектов отключена (как на экране демонстрации — оверлей только для
-              изображения).
-            </div>
-          ) : null}
+          {isVideoPreviewScene ? <div className={styles.videoHint}>{t('control.videoBrushHint')}</div> : null}
           <div className={styles.spacer10} />
           <div className={styles.previewFrame}>
             <div ref={previewHostRef} className={styles.previewHost}>
@@ -1037,33 +1257,33 @@ export function ControlApp() {
         </Surface>
 
         <Surface className={styles.surfacePad}>
-          <div className={styles.branchTitle}>Варианты ветвления</div>
+          <div className={styles.branchTitle}>{t('control.branches')}</div>
           <div className={styles.branchGrid}>
             {nextScenes.map((o, i) => (
               <div key={o.graphNodeId} className={styles.branchCard}>
                 <div className={styles.branchCardHeader}>
-                  <div className={styles.branchOption}>ОПЦИЯ {String(i + 1)}</div>
+                  <div className={styles.branchOption}>{t('control.option', { n: String(i + 1) })}</div>
                 </div>
-                <div className={styles.branchName}>{o.scene.title || 'Без названия'}</div>
+                <div className={styles.branchName}>{o.scene.title || t('control.unnamed')}</div>
                 <Button
                   variant="primary"
                   onClick={() =>
                     void api.invoke(ipcChannels.project.setCurrentGraphNode, { graphNodeId: o.graphNodeId })
                   }
                 >
-                  Переключить
+                  {t('control.switchScene')}
                 </Button>
               </div>
             ))}
             {nextScenes.length === 0 ? (
               <div className={styles.branchEmpty}>
-                <div>Нет вариантов перехода.</div>
+                <div>{t('control.noBranches')}</div>
                 <Button
                   variant="primary"
                   disabled={!session?.project?.currentGraphNodeId}
                   onClick={() => void api.invoke(ipcChannels.windows.closeMultiWindow, {})}
                 >
-                  Завершить показ
+                  {t('control.endPresentation')}
                 </Button>
               </div>
             ) : null}
@@ -1072,16 +1292,19 @@ export function ControlApp() {
 
         <Surface className={styles.surfacePad}>
           <div className={styles.musicHeader}>
-            <div className={styles.previewTitle}>Музыка</div>
+            <div className={styles.previewTitle}>{t('control.music')}</div>
           </div>
           <div className={styles.spacer10} />
+          <div className={styles.sectionLabel}>{t('control.sceneMusic')}</div>
+          <div className={styles.spacer10} />
           {sceneAudios.length === 0 ? (
-            <div className={styles.musicEmpty}>В текущей сцене нет аудио.</div>
-          ) : (
+            <div className={styles.musicEmpty}>{t('control.noSceneAudio')}</div>
+          ) : null}
+          {sceneAudios.length > 0 ? (
             <div className={styles.audioList}>
               {sceneAudios.map(({ ref, asset }) => {
-                const el = audioElsRef.current.get(ref.assetId) ?? null;
-                const st = audioStatus(ref.assetId);
+                const el = sceneAudioElsRef.current.get(ref.assetId) ?? null;
+                const st = audioStatus('scene', ref.assetId);
                 const dur = el?.duration && Number.isFinite(el.duration) ? el.duration : 0;
                 const cur = el?.currentTime && Number.isFinite(el.currentTime) ? el.currentTime : 0;
                 const pct = dur > 0 ? Math.max(0, Math.min(1, cur / dur)) : 0;
@@ -1090,8 +1313,8 @@ export function ControlApp() {
                     <div className={styles.audioMeta}>
                       <div className={styles.audioName}>{asset.originalName}</div>
                       <div className={styles.audioBadges}>
-                        <div>{ref.autoplay ? 'Авто' : 'Ручн.'}</div>
-                        <div>{ref.loop ? 'Цикл' : 'Один раз'}</div>
+                        <div>{ref.autoplay ? t('control.modeAuto') : t('control.modeManual')}</div>
+                        <div>{ref.loop ? t('control.loop') : t('control.once')}</div>
                         <div title={st.detail}>{st.label}</div>
                       </div>
                       <div className={styles.spacer10} />
@@ -1106,7 +1329,7 @@ export function ControlApp() {
                           if (!dur) return;
                           if (e.key === 'ArrowLeft') el.currentTime = Math.max(0, el.currentTime - 5);
                           if (e.key === 'ArrowRight') el.currentTime = Math.min(dur, el.currentTime + 5);
-                          setAudioStateTick((x) => x + 1);
+                          setSceneAudioStateTick((x) => x + 1);
                         }}
                         onClick={(e) => {
                           if (!el) return;
@@ -1114,13 +1337,13 @@ export function ControlApp() {
                           const rect = (e.currentTarget as HTMLDivElement).getBoundingClientRect();
                           const next = (e.clientX - rect.left) / rect.width;
                           el.currentTime = Math.max(0, Math.min(dur, next * dur));
-                          setAudioStateTick((x) => x + 1);
+                          setSceneAudioStateTick((x) => x + 1);
                         }}
                         className={[
                           styles.audioScrub,
                           dur > 0 ? styles.audioScrubPointer : styles.audioScrubDefault,
                         ].join(' ')}
-                        title={dur > 0 ? 'Клик — перемотка' : 'Длительность неизвестна'}
+                        title={dur > 0 ? t('control.scrubSeek') : t('control.durationUnknown')}
                       >
                         <div
                           className={styles.scrubFill}
@@ -1137,15 +1360,17 @@ export function ControlApp() {
                         variant="primary"
                         onClick={() => {
                           if (!el) return;
-                          const m = audioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
-                          audioMetaRef.current.set(ref.assetId, { ...m, lastPlayError: null });
+                          const m = sceneAudioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
+                          sceneAudioMetaRef.current.set(ref.assetId, { ...m, lastPlayError: null });
                           void el.play().catch(() => {
-                            const mm = audioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
-                            audioMetaRef.current.set(ref.assetId, {
+                            const mm =
+                              sceneAudioMetaRef.current.get(ref.assetId) ??
+                              ({ lastPlayError: null } as const);
+                            sceneAudioMetaRef.current.set(ref.assetId, {
                               ...mm,
-                              lastPlayError: 'Не удалось запустить.',
+                              lastPlayError: t('control.playFailed'),
                             });
-                            setAudioStateTick((x) => x + 1);
+                            setSceneAudioStateTick((x) => x + 1);
                           });
                         }}
                       >
@@ -1164,7 +1389,124 @@ export function ControlApp() {
                           if (!el) return;
                           el.pause();
                           el.currentTime = 0;
-                          setAudioStateTick((x) => x + 1);
+                          setSceneAudioStateTick((x) => x + 1);
+                        }}
+                      >
+                        ■
+                      </Button>
+                    </div>
+                  </div>
+                );
+              })}
+            </div>
+          ) : null}
+
+          <div className={styles.spacer12} />
+          <div className={styles.sectionLabel}>{t('control.gameMusic')}</div>
+          <div className={styles.spacer10} />
+          {campaignAudios.length === 0 ? (
+            <div className={styles.musicEmpty}>{t('control.noGameAudio')}</div>
+          ) : (
+            <div className={styles.audioList}>
+              {campaignAudios.map(({ ref, asset }) => {
+                const el = campaignAudioElsRef.current.get(ref.assetId) ?? null;
+                const st = audioStatus('campaign', ref.assetId);
+                const dur = el?.duration && Number.isFinite(el.duration) ? el.duration : 0;
+                const cur = el?.currentTime && Number.isFinite(el.currentTime) ? el.currentTime : 0;
+                const pct = dur > 0 ? Math.max(0, Math.min(1, cur / dur)) : 0;
+                return (
+                  <div key={ref.assetId} className={styles.audioCard}>
+                    <div className={styles.audioMeta}>
+                      <div className={styles.audioName}>{asset.originalName}</div>
+                      <div className={styles.audioBadges}>
+                        <div>{ref.autoplay ? t('control.modeAuto') : t('control.modeManual')}</div>
+                        <div>{ref.loop ? t('control.loop') : t('control.once')}</div>
+                        <div title={st.detail}>{st.label}</div>
+                        {!allowCampaignAudio ? (
+                          <div title={t('control.pauseSceneMusicTitle')}>{t('control.pauseSceneMusic')}</div>
+                        ) : null}
+                      </div>
+                      <div className={styles.spacer10} />
+                      <div
+                        role="slider"
+                        aria-valuemin={0}
+                        aria-valuemax={dur > 0 ? Math.round(dur) : 0}
+                        aria-valuenow={Math.round(cur)}
+                        tabIndex={0}
+                        onKeyDown={(e) => {
+                          if (!el) return;
+                          if (!dur) return;
+                          if (e.key === 'ArrowLeft') el.currentTime = Math.max(0, el.currentTime - 5);
+                          if (e.key === 'ArrowRight') el.currentTime = Math.min(dur, el.currentTime + 5);
+                          setCampaignAudioStateTick((x) => x + 1);
+                        }}
+                        onClick={(e) => {
+                          if (!el) return;
+                          if (!dur) return;
+                          const rect = (e.currentTarget as HTMLDivElement).getBoundingClientRect();
+                          const next = (e.clientX - rect.left) / rect.width;
+                          el.currentTime = Math.max(0, Math.min(dur, next * dur));
+                          setCampaignAudioStateTick((x) => x + 1);
+                        }}
+                        className={[
+                          styles.audioScrub,
+                          dur > 0 ? styles.audioScrubPointer : styles.audioScrubDefault,
+                        ].join(' ')}
+                        title={dur > 0 ? t('control.scrubSeek') : t('control.durationUnknown')}
+                      >
+                        <div
+                          className={styles.scrubFill}
+                          style={{ width: `${String(Math.round(pct * 100))}%` }}
+                        />
+                      </div>
+                      <div className={styles.timeRow}>
+                        <div>{formatTime(cur)}</div>
+                        <div>{dur ? formatTime(dur) : '—:—'}</div>
+                      </div>
+                    </div>
+                    <div className={styles.audioTransport}>
+                      <Button
+                        variant="primary"
+                        title={!allowCampaignAudio ? t('control.pauseCampaignTitle') : undefined}
+                        onClick={() => {
+                          if (!el) return;
+                          const m = campaignAudioMetaRef.current.get(ref.assetId) ?? { lastPlayError: null };
+                          campaignAudioMetaRef.current.set(ref.assetId, { ...m, lastPlayError: null });
+                          // If this track was created for autoplay but autoplay was blocked (e.g. scene music),
+                          // it might still be at volume 0. Ensure manual play is audible.
+                          try {
+                            if (el.volume === 0) el.volume = 1;
+                          } catch {
+                            // ignore
+                          }
+                          void el.play().catch(() => {
+                            const mm =
+                              campaignAudioMetaRef.current.get(ref.assetId) ??
+                              ({ lastPlayError: null } as const);
+                            campaignAudioMetaRef.current.set(ref.assetId, {
+                              ...mm,
+                              lastPlayError: t('control.playFailed'),
+                            });
+                            setCampaignAudioStateTick((x) => x + 1);
+                          });
+                        }}
+                      >
+                        ▶
+                      </Button>
+                      <Button
+                        onClick={() => {
+                          if (!el) return;
+                          el.pause();
+                        }}
+                      >
+                        ❚❚
+                      </Button>
+                      <Button
+                        onClick={() => {
+                          if (!el) return;
+                          el.pause();
+                          el.currentTime = 0;
+                          setCampaignAudioStateTick((x) => x + 1);
                         }}
                       >
                         ■

app/renderer/control/ControlScenePreview.tsx

@@ -2,6 +2,7 @@ import React, { useEffect, useMemo, useState } from 'react';
 
 import { computeTimeSec } from '../../main/video/videoPlaybackStore';
 import type { SessionState } from '../../shared/ipc/contracts';
+import { useEditorI18n } from '../editor/i18n/EditorI18nContext';
 import { RotatedImage } from '../shared/RotatedImage';
 import { useAssetUrl } from '../shared/useAssetImageUrl';
 import { useVideoPlaybackState } from '../shared/video/useVideoPlaybackState';
@@ -23,6 +24,7 @@ function fmt(sec: number): string {
 }
 
 export function ControlScenePreview({ session, videoRef, onContentRectChange }: Props) {
+  const { t } = useEditorI18n();
   const [vp, video] = useVideoPlaybackState();
   const scene =
     session?.project && session.currentSceneId ? session.project.scenes[session.currentSceneId] : undefined;
@@ -30,6 +32,7 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
   const rot = scene?.previewRotationDeg ?? 0;
   const isVideo = scene?.previewAssetType === 'video';
   const assetId = scene?.previewAssetType === 'video' ? scene.previewAssetId : null;
+  const autostart = scene?.previewVideoAutostart ?? false;
 
   const [tick, setTick] = useState(0);
   const dur = useMemo(
@@ -38,7 +41,7 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
       if (!v) return 0;
       return Number.isFinite(v.duration) ? v.duration : 0;
     },
-    // tick: перечитываем duration из video ref на каждом кадре RAF
+    // tick: timeupdate / loadedmetadata перечитывают duration и currentTime
     // eslint-disable-next-line react-hooks/exhaustive-deps -- намеренно
     [tick, videoRef],
   );
@@ -55,23 +58,15 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
 
   useEffect(() => {
     if (!isVideo) return;
-    let raf = 0;
-    const loop = () => {
-      setTick((x) => x + 1);
-      raf = window.requestAnimationFrame(loop);
-    };
-    raf = window.requestAnimationFrame(loop);
-    return () => window.cancelAnimationFrame(raf);
-  }, [isVideo]);
-
-  useEffect(() => {
-    if (!isVideo) return;
+    if (!assetId) return;
+    // `target.set` bumps revision and resets anchors; avoid firing on every render.
+    if (vp?.targetAssetId === assetId) return;
     void video.dispatch({
       kind: 'target.set',
       assetId,
-      autostart: scene.previewVideoAutostart,
+      autostart,
     });
-  }, [assetId, isVideo, scene, video]);
+  }, [assetId, isVideo, autostart, vp?.targetAssetId, video]);
 
   useEffect(() => {
     const v = videoRef.current;
@@ -88,7 +83,8 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
     } else {
       v.pause();
     }
-  }, [assetId, vp, videoRef]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- avoid reruns on 500ms heartbeats (serverNowMs-only updates)
+  }, [assetId, url, vp?.revision, vp?.targetAssetId, vp?.playing, vp?.playbackRate, videoRef]);
 
   const scrubClass = [styles.scrub, dur ? styles.scrubPointer : styles.scrubDefault].join(' ');
 
@@ -105,8 +101,10 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
           src={url}
           playsInline
           preload="auto"
+          onTimeUpdate={() => setTick((x) => x + 1)}
+          onLoadedMetadata={() => setTick((x) => x + 1)}
         >
-          <track kind="captions" srcLang="ru" label="Превью без субтитров" />
+          <track kind="captions" srcLang="ru" label={t('control.previewTrackLabel')} />
         </video>
       ) : (
         <div className={styles.placeholder} />
@@ -136,7 +134,7 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
                 void video.dispatch({ kind: 'seek', timeSec: Math.min(dur, cur + 5) });
               if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') setTick((x) => x + 1);
             }}
-            title="Клик — перемотка"
+            title={t('control.scrubSeek')}
           >
             <div className={styles.scrubFill} style={{ width: `${String(Math.round(pct * 100))}%` }} />
           </div>
@@ -146,7 +144,7 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
                 type="button"
                 className={styles.transportBtn}
                 onClick={() => void video.dispatch({ kind: 'play' })}
-                title="Play"
+                title={t('control.transportPlay')}
               >
                 ▶
               </button>
@@ -154,7 +152,7 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
                 type="button"
                 className={styles.transportBtn}
                 onClick={() => void video.dispatch({ kind: 'pause' })}
-                title="Pause"
+                title={t('control.transportPause')}
               >
                 ❚❚
               </button>
@@ -165,7 +163,7 @@ export function ControlScenePreview({ session, videoRef, onContentRectChange }:
                   void video.dispatch({ kind: 'stop' });
                   setTick((x) => x + 1);
                 }}
-                title="Stop"
+                title={t('control.transportStop')}
               >
                 ■
               </button>

app/renderer/control/controlApp.effectsPanel.test.ts

@@ -47,28 +47,28 @@ void test('ControlApp: звук облака яда (public/oblako-yada.mp3)', (
 
 void test('ControlApp: эффекты в пульте, иконки с тултипами и подписью для a11y', () => {
   const src = readControlApp();
-  assert.ok(src.includes('ЭФФЕКТЫ'));
-  assert.ok(src.includes('Инструменты'));
-  assert.ok(src.includes('Эффекты поля'));
-  assert.ok(src.includes('Эффекты действий'));
-  assert.ok(src.includes('Луч света'));
-  assert.ok(src.includes('title="Вода"'));
-  assert.ok(src.includes('title="Облако яда"'));
-  assert.ok(src.includes('title="Туман"'));
-  assert.ok(src.includes('ariaLabel="Туман"'));
+  assert.ok(src.includes("t('control.effects')"));
+  assert.ok(src.includes("t('control.tools')"));
+  assert.ok(src.includes("t('control.fieldEffects')"));
+  assert.ok(src.includes("t('control.actionEffects')"));
+  assert.ok(src.includes("t('control.sunbeam')"));
+  assert.ok(src.includes("title={t('control.water')}"));
+  assert.ok(src.includes("title={t('control.poisonCloud')}"));
+  assert.ok(src.includes("title={t('control.fog')}"));
+  assert.ok(src.includes("ariaLabel={t('control.fog')}"));
   assert.ok(src.includes('iconOnly'));
-  assert.ok(src.includes('title="Очистить эффекты"'));
-  assert.ok(src.includes('ariaLabel="Очистить эффекты"'));
+  assert.ok(src.includes("title={t('control.clearEffects')}"));
+  assert.ok(src.includes("ariaLabel={t('control.clearEffects')}"));
   assert.ok(src.includes('#e5484d'));
-  const fx = src.indexOf('ЭФФЕКТЫ');
-  const story = src.indexOf('СЮЖЕТНАЯ ЛИНИЯ');
+  const fx = src.indexOf("t('control.effects')");
+  const story = src.indexOf("t('control.storyLine')");
   assert.ok(fx !== -1 && story !== -1 && fx < story, 'Блок эффектов должен быть выше сюжетной линии');
 });
 
 void test('ControlApp: сюжетная линия — колонка сверху вниз и фон как у карточек ветвления', () => {
   const src = readControlApp();
   const css = readControlAppCss();
-  const story = src.indexOf('СЮЖЕТНАЯ ЛИНИЯ');
+  const story = src.indexOf("t('control.storyLine')");
   assert.ok(story !== -1);
   assert.ok(src.includes('className={styles.storyScroll}'));
   assert.match(css, /\.storyScroll[\s\S]*?justify-content:\s*flex-start/);
@@ -86,11 +86,46 @@ void test('ControlApp: слой кисти не использует курсо
 
 void test('ControlApp: радиус кисти не в блоке предпросмотра', () => {
   const src = readControlApp();
-  const previewLabel = src.indexOf('Предпросмотр экрана');
-  const radius = src.indexOf('Радиус кисти');
+  const previewLabel = src.indexOf("t('control.screenPreview')");
+  const radius = src.indexOf("t('control.brushRadius')");
   assert.ok(previewLabel !== -1 && radius !== -1);
   assert.ok(
     radius < previewLabel,
     'Слайдер радиуса должен быть в пульте (файл: выше заголовка предпросмотра)',
   );
 });
+
+void test('ControlApp: музыка разделена на сцену и кампанию', () => {
+  const src = readControlApp();
+  assert.ok(src.includes("t('control.sceneMusic')"));
+  assert.ok(src.includes("t('control.gameMusic')"));
+  // при музыке сцены — кампанию ставим на паузу
+  assert.ok(src.includes('allowCampaignAudio'));
+  assert.ok(
+    src.includes('campaignAudioSpecKey'),
+    'кампания: перезагрузка аудио привязана к списку треков, не к смене сцены',
+  );
+  assert.match(src, /pause campaign\./i);
+});
+
+void test('ControlApp: загрузка камп. аудио — useEffect зависит только от api и campaignAudioSpecKey', () => {
+  const src = readControlApp();
+  const re = /\/\/ Campaign elements:[\s\S]*?useEffect\(\(\) => \{[\s\S]*?\}\s*,\s*\[([^\]]*)\]\s*\)\s*;/;
+  const m = re.exec(src);
+  assert.ok(m, 'ожидается useEffect загрузки кампании после комментария Campaign elements');
+  const depList = m[1];
+  assert.ok(depList !== undefined);
+  const deps = depList
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+  assert.deepEqual(
+    deps,
+    ['api', 'campaignAudioSpecKey'],
+    'смена сцены / allowCampaignAudio / campaignAudioRefs не должны перезапускать загрузку кампании',
+  );
+  assert.ok(!/\ballowCampaignAudio\b/.test(depList));
+  assert.ok(!/\bcurrentScene\b/.test(depList));
+  assert.ok(!/\bproject\b/.test(depList));
+  assert.ok(!/\bcampaignAudioRefs\b/.test(depList));
+});

app/renderer/control/main.tsx

@@ -2,6 +2,8 @@ import React from 'react';
 import { createRoot } from 'react-dom/client';
 
 import '../shared/ui/globals.css';
+import { EditorI18nProvider } from '../editor/i18n/EditorI18nContext';
+
 import { ControlApp } from './ControlApp';
 
 const rootEl = document.getElementById('root');
@@ -11,6 +13,8 @@ if (!rootEl) {
 
 createRoot(rootEl).render(
   <React.StrictMode>
+    <EditorI18nProvider>
       <ControlApp />
+    </EditorI18nProvider>
   </React.StrictMode>,
 );

app/renderer/editor/EditorApp.module.css

@@ -100,6 +100,10 @@
   height: 14px;
 }
 
+.spacer18 {
+  height: 18px;
+}
+
 .sidebarScroll {
   overflow: auto;
   padding-right: 2px;
@@ -120,6 +124,84 @@
   background: var(--bg0);
 }
 
+.progressOverlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.55);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 10000;
+}
+
+.editorLockOverlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.35);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 11000;
+}
+
+.editorLockModal {
+  width: min(520px, calc(100vw - 32px));
+  border-radius: 12px;
+  padding: 14px;
+  background: rgba(25, 28, 38, 0.92);
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  box-shadow: 0 10px 40px rgba(0, 0, 0, 0.55);
+  display: grid;
+  gap: 8px;
+}
+
+.editorLockTitle {
+  font-weight: 800;
+  opacity: 0.95;
+}
+
+.editorLockText {
+  opacity: 0.85;
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.progressModal {
+  width: min(520px, calc(100vw - 32px));
+  border-radius: 12px;
+  padding: 14px;
+  background: rgba(25, 28, 38, 0.92);
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  box-shadow: 0 10px 40px rgba(0, 0, 0, 0.55);
+}
+
+.progressTitle {
+  font-weight: 700;
+  margin-bottom: 10px;
+}
+
+.progressBar {
+  height: 10px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: rgba(255, 255, 255, 0.08);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.progressFill {
+  height: 100%;
+  width: 0%;
+  background: rgba(167, 139, 250, 0.85);
+}
+
+.progressMeta {
+  margin-top: 10px;
+  display: flex;
+  justify-content: space-between;
+  opacity: 0.9;
+  font-size: 12px;
+}
+
 .inspectorTitle {
   font-weight: 800;
   margin-bottom: 12px;
@@ -161,6 +243,33 @@
   font: inherit;
 }
 
+.fileMenuSubHost {
+  position: relative;
+}
+
+.fileMenuItemExpand {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  width: 100%;
+}
+
+.fileMenuSub {
+  position: absolute;
+  left: calc(100% + 6px);
+  top: 0;
+  min-width: 200px;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--stroke);
+  background: var(--color-surface-elevated-2);
+  box-shadow: var(--shadow-lg);
+  padding: 6px;
+  display: grid;
+  gap: 4px;
+  z-index: calc(var(--z-file-menu) + 1);
+}
+
 .modalBackdrop {
   position: fixed;
   inset: 0;
@@ -408,10 +517,55 @@
   overflow: hidden;
   background: var(--color-overlay-dark-3);
   aspect-ratio: 16 / 9;
-  max-height: 140px;
+  width: 100%;
   display: flex;
   align-items: center;
   justify-content: center;
+  position: relative;
+}
+
+.previewFill {
+  position: absolute;
+  inset: 0;
+}
+
+.previewBusyOverlay {
+  position: absolute;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.55);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 12px;
+}
+
+.previewBusyModal {
+  display: grid;
+  justify-items: center;
+  gap: 10px;
+  color: var(--text1);
+  text-align: center;
+}
+
+.previewBusyText {
+  font-size: var(--text-xs);
+  font-weight: 700;
+  color: rgba(255, 255, 255, 0.92);
+}
+
+.previewSpinner {
+  width: 26px;
+  height: 26px;
+  border-radius: 999px;
+  border: 3px solid rgba(255, 255, 255, 0.25);
+  border-top-color: rgba(255, 255, 255, 0.9);
+  animation: previewSpin 0.9s linear infinite;
+}
+
+@keyframes previewSpin {
+  to {
+    transform: rotate(360deg);
+  }
 }
 
 .videoCover {

app/renderer/editor/graph/SceneGraph.module.css

@@ -20,8 +20,10 @@
 }
 
 .cardActive {
-  border-color: var(--graph-node-active-border);
-  box-shadow: 0 25px 50px -12px rgba(139, 92, 246, 0.1);
+  border-color: rgba(167, 139, 250, 0.95);
+  box-shadow:
+    0 0 0 2px rgba(167, 139, 250, 0.35),
+    0 25px 50px -12px rgba(167, 139, 250, 0.12);
 }
 
 .previewShell {

app/renderer/editor/graph/SceneGraph.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
 import { createPortal } from 'react-dom';
 import ReactFlow, {
   Background,
@@ -19,19 +19,30 @@ import ReactFlow, {
 import 'reactflow/dist/style.css';
 
 import { isSceneGraphEdgeRejected } from '../../../shared/graph/sceneGraphEdgeRules';
-import type {
-  AssetId,
-  GraphNodeId,
-  Scene,
-  SceneGraphEdge,
-  SceneGraphNode,
-  SceneId,
-} from '../../../shared/types';
+import type { AssetId, GraphNodeId, SceneGraphEdge, SceneGraphNode, SceneId } from '../../../shared/types';
 import { RotatedImage } from '../../shared/RotatedImage';
 import { useAssetUrl } from '../../shared/useAssetImageUrl';
 
 import styles from './SceneGraph.module.css';
 
+/** Поля сцены, нужные только для карточки узла графа (без описания и прочего). */
+export type SceneGraphSceneAudioSummary = {
+  assetId: AssetId;
+  loop: boolean;
+  autoplay: boolean;
+};
+
+export type SceneGraphSceneCard = {
+  title: string;
+  previewAssetId: AssetId | null;
+  previewThumbAssetId: AssetId | null;
+  previewAssetType: 'image' | 'video' | null;
+  previewVideoAutostart: boolean;
+  previewRotationDeg: 0 | 90 | 180 | 270;
+  loopVideo: boolean;
+  audios: readonly SceneGraphSceneAudioSummary[];
+};
+
 /** MIME для перетаскивания сцены из списка на граф (см. EditorApp). */
 export const DND_SCENE_ID_MIME = 'application/x-dnd-scene-id';
 
@@ -39,11 +50,53 @@ export const DND_SCENE_ID_MIME = 'application/x-dnd-scene-id';
 const SCENE_CARD_W = 220;
 const SCENE_CARD_H = 248;
 
+/** UI strings for the scene graph (passed from editor i18n). */
+export type SceneGraphUiStrings = {
+  badgeStart: string;
+  untitled: string;
+  videoBadge: string;
+  audioBadge: string;
+  loop: string;
+  autoplay: string;
+  previewAutostart: string;
+  videoLoop: string;
+  zoomBar: string;
+  zoomIn: string;
+  zoomOut: string;
+  fitAll: string;
+  closeMenu: string;
+  startScene: string;
+  unsetStartScene: string;
+  delete: string;
+};
+
+const DEFAULT_SCENE_GRAPH_UI: SceneGraphUiStrings = {
+  badgeStart: 'НАЧАЛО',
+  untitled: 'Без названия',
+  videoBadge: 'Видео',
+  audioBadge: 'Аудио',
+  loop: 'Цикл',
+  autoplay: 'Автостарт',
+  previewAutostart: 'Авто превью',
+  videoLoop: 'Цикл видео',
+  zoomBar: 'Масштаб графа',
+  zoomIn: 'Увеличить',
+  zoomOut: 'Уменьшить',
+  fitAll: 'Показать всё',
+  closeMenu: 'Закрыть меню',
+  startScene: 'Начальная сцена',
+  unsetStartScene: 'Снять метку «Начальная сцена»',
+  delete: 'Удалить',
+};
+
+const GraphUiContext = createContext<SceneGraphUiStrings>(DEFAULT_SCENE_GRAPH_UI);
+
 export type SceneGraphProps = {
   sceneGraphNodes: SceneGraphNode[];
   sceneGraphEdges: SceneGraphEdge[];
-  sceneById: Record<SceneId, Scene>;
+  sceneCardById: Record<SceneId, SceneGraphSceneCard>;
   currentSceneId: SceneId | null;
+  graphUi?: SceneGraphUiStrings;
   onCurrentSceneChange: (id: SceneId) => void;
   onConnect: (sourceGraphNodeId: GraphNodeId, targetGraphNodeId: GraphNodeId) => void;
   onDisconnect: (edgeId: string) => void;
@@ -59,6 +112,7 @@ type SceneCardData = {
   title: string;
   active: boolean;
   previewAssetId: AssetId | null;
+  previewThumbAssetId: AssetId | null;
   previewAssetType: 'image' | 'video' | null;
   previewVideoAutostart: boolean;
   previewRotationDeg: 0 | 90 | 180 | 270;
@@ -119,7 +173,9 @@ function IconVideoPreviewAutostart() {
 }
 
 function SceneCardNode({ data }: NodeProps<SceneCardData>) {
-  const url = useAssetUrl(data.previewAssetId);
+  const ui = useContext(GraphUiContext);
+  const thumbUrl = useAssetUrl(data.previewThumbAssetId);
+  const previewUrl = useAssetUrl(data.previewAssetId);
   const cardClass = [styles.card, data.active ? styles.cardActive : ''].filter(Boolean).join(' ');
   const showCornerVideo = data.previewIsVideo;
   const showCornerAudio = data.hasSceneAudio;
@@ -128,23 +184,54 @@ function SceneCardNode({ data }: NodeProps<SceneCardData>) {
       <Handle type="target" position={Position.Top} className={styles.handle} />
       <div className={cardClass}>
         <div className={styles.previewShell}>
-          {data.isStartScene ? <div className={styles.badgeStart}>НАЧАЛО</div> : null}
-          {url && data.previewAssetType === 'image' ? (
+          {data.isStartScene ? <div className={styles.badgeStart}>{ui.badgeStart}</div> : null}
+          {thumbUrl ? (
             <div className={styles.previewFill}>
               {data.previewRotationDeg === 0 ? (
-                <img src={url} alt="" className={styles.imageCover} draggable={false} />
+                <img
+                  src={thumbUrl}
+                  alt=""
+                  className={styles.imageCover}
+                  draggable={false}
+                  loading="lazy"
+                  decoding="async"
+                />
               ) : (
                 <RotatedImage
-                  url={url}
+                  url={thumbUrl}
                   rotationDeg={data.previewRotationDeg}
                   mode="cover"
+                  loading="lazy"
+                  decoding="async"
                   style={{ width: '100%', height: '100%' }}
                 />
               )}
             </div>
-          ) : url && data.previewAssetType === 'video' ? (
+          ) : previewUrl && data.previewAssetType === 'image' ? (
+            <div className={styles.previewFill}>
+              {data.previewRotationDeg === 0 ? (
+                <img
+                  src={previewUrl}
+                  alt=""
+                  className={styles.imageCover}
+                  draggable={false}
+                  loading="lazy"
+                  decoding="async"
+                />
+              ) : (
+                <RotatedImage
+                  url={previewUrl}
+                  rotationDeg={data.previewRotationDeg}
+                  mode="cover"
+                  loading="lazy"
+                  decoding="async"
+                  style={{ width: '100%', height: '100%' }}
+                />
+              )}
+            </div>
+          ) : previewUrl && data.previewAssetType === 'video' ? (
             <video
-              src={url}
+              src={previewUrl}
               muted
               playsInline
               preload="metadata"
@@ -165,12 +252,12 @@ function SceneCardNode({ data }: NodeProps<SceneCardData>) {
           {showCornerVideo || showCornerAudio ? (
             <div className={styles.cornerBadges}>
               {showCornerVideo ? (
-                <span className={styles.mediaBadge} title="Видео">
+                <span className={styles.mediaBadge} title={ui.videoBadge}>
                   <IconVideoBadge />
                 </span>
               ) : null}
               {showCornerAudio ? (
-                <span className={styles.mediaBadge} title="Аудио">
+                <span className={styles.mediaBadge} title={ui.audioBadge}>
                   <IconAudioBadge />
                 </span>
               ) : null}
@@ -178,19 +265,19 @@ function SceneCardNode({ data }: NodeProps<SceneCardData>) {
           ) : null}
         </div>
         <div className={styles.nodeBody}>
-          <div className={styles.title}>{data.title || 'Без названия'}</div>
+          <div className={styles.title}>{data.title || ui.untitled}</div>
           {data.hasAnyAudioLoop || data.hasAnyAudioAutoplay ? (
             <div className={styles.musicParams}>
               {data.hasAnyAudioLoop ? (
                 <div className={styles.musicParam}>
                   <IconLoopParam />
-                  <span>Цикл</span>
+                  <span>{ui.loop}</span>
                 </div>
               ) : null}
               {data.hasAnyAudioAutoplay ? (
                 <div className={styles.musicParam}>
                   <IconAutoplayParam />
-                  <span>Автостарт</span>
+                  <span>{ui.autoplay}</span>
                 </div>
               ) : null}
             </div>
@@ -200,13 +287,13 @@ function SceneCardNode({ data }: NodeProps<SceneCardData>) {
               {data.showPreviewVideoAutostart ? (
                 <div className={styles.musicParam}>
                   <IconVideoPreviewAutostart />
-                  <span>Авто превью</span>
+                  <span>{ui.previewAutostart}</span>
                 </div>
               ) : null}
               {data.showPreviewVideoLoop ? (
                 <div className={styles.musicParam}>
                   <IconLoopParam />
-                  <span>Цикл видео</span>
+                  <span>{ui.videoLoop}</span>
                 </div>
               ) : null}
             </div>
@@ -221,18 +308,19 @@ function SceneCardNode({ data }: NodeProps<SceneCardData>) {
 const nodeTypes = { sceneCard: SceneCardNode };
 
 function GraphZoomToolbar() {
+  const ui = useContext(GraphUiContext);
   const { zoomIn, zoomOut, fitView } = useReactFlow();
   const zoom = useStore((s) => s.transform[2]);
   const pct = Math.max(1, Math.round(zoom * 100));
 
   return (
     <Panel position="bottom-center" className={styles.zoomPanel}>
-      <div className={styles.zoomBar} role="toolbar" aria-label="Масштаб графа">
-        <button type="button" className={styles.zoomBtn} onClick={() => zoomIn()} aria-label="Увеличить">
+      <div className={styles.zoomBar} role="toolbar" aria-label={ui.zoomBar}>
+        <button type="button" className={styles.zoomBtn} onClick={() => zoomIn()} aria-label={ui.zoomIn}>
           +
         </button>
         <span className={styles.zoomPct}>{pct}%</span>
-        <button type="button" className={styles.zoomBtn} onClick={() => zoomOut()} aria-label="Уменьшить">
+        <button type="button" className={styles.zoomBtn} onClick={() => zoomOut()} aria-label={ui.zoomOut}>
           −
         </button>
         <span className={styles.zoomDivider} aria-hidden />
@@ -240,8 +328,8 @@ function GraphZoomToolbar() {
           type="button"
           className={styles.zoomBtn}
           onClick={() => fitView({ padding: 0.25 })}
-          aria-label="Показать всё"
-          title="Показать всё"
+          aria-label={ui.fitAll}
+          title={ui.fitAll}
         >
           <svg className={styles.zoomFitIcon} viewBox="0 0 24 24" width={18} height={18} aria-hidden>
             <path
@@ -261,8 +349,9 @@ function GraphZoomToolbar() {
 function SceneGraphCanvas({
   sceneGraphNodes,
   sceneGraphEdges,
-  sceneById,
+  sceneCardById,
   currentSceneId,
+  graphUi,
   onCurrentSceneChange,
   onConnect,
   onDisconnect,
@@ -272,6 +361,7 @@ function SceneGraphCanvas({
   onSetGraphNodeStart,
   onDropSceneFromList,
 }: SceneGraphProps) {
+  const ui = graphUi ?? DEFAULT_SCENE_GRAPH_UI;
   const { screenToFlowPosition } = useReactFlow();
   const [menu, setMenu] = useState<{ x: number; y: number; graphNodeId: GraphNodeId } | null>(null);
 
@@ -291,45 +381,66 @@ function SceneGraphCanvas({
 
   const desiredNodes = useMemo<Node<SceneCardData>[]>(() => {
     return sceneGraphNodes.map((gn) => {
-      const s = sceneById[gn.sceneId];
+      const c = sceneCardById[gn.sceneId];
       const active = gn.sceneId === currentSceneId;
-      const audios = s?.media.audios ?? [];
+      const audios = c?.audios ?? [];
       return {
         id: gn.id,
         type: 'sceneCard',
         position: { x: gn.x, y: gn.y },
         data: {
           sceneId: gn.sceneId,
-          title: s?.title ?? '',
+          title: c?.title ?? '',
           active,
-          previewAssetId: s?.previewAssetId ?? null,
-          previewAssetType: s?.previewAssetType ?? null,
-          previewVideoAutostart: s?.previewVideoAutostart ?? false,
-          previewRotationDeg: s?.previewRotationDeg ?? 0,
+          previewAssetId: c?.previewAssetId ?? null,
+          previewThumbAssetId: c?.previewThumbAssetId ?? null,
+          previewAssetType: c?.previewAssetType ?? null,
+          previewVideoAutostart: c?.previewVideoAutostart ?? false,
+          previewRotationDeg: c?.previewRotationDeg ?? 0,
           isStartScene: gn.isStartScene,
           hasSceneAudio: audios.length >= 1,
-          previewIsVideo: s?.previewAssetType === 'video',
+          previewIsVideo: c?.previewAssetType === 'video',
           hasAnyAudioLoop: audios.some((a) => a.loop),
           hasAnyAudioAutoplay: audios.some((a) => a.autoplay),
-          showPreviewVideoAutostart: s?.previewAssetType === 'video' ? s.previewVideoAutostart : false,
-          showPreviewVideoLoop: s?.previewAssetType === 'video' ? s.settings.loopVideo : false,
+          showPreviewVideoAutostart: c?.previewAssetType === 'video' ? c.previewVideoAutostart : false,
+          showPreviewVideoLoop: c?.previewAssetType === 'video' ? c.loopVideo : false,
         },
         style: { padding: 0, background: 'transparent', border: 'none' },
       };
     });
-  }, [currentSceneId, sceneById, sceneGraphNodes]);
+  }, [currentSceneId, sceneCardById, sceneGraphNodes]);
 
   const desiredEdges = useMemo<Edge[]>(() => {
+    const selectedGraphNodeIds = new Set<GraphNodeId>();
+    if (currentSceneId) {
+      for (const gn of sceneGraphNodes) {
+        if (gn.sceneId === currentSceneId) selectedGraphNodeIds.add(gn.id);
+      }
+    }
+    const hasSelection = selectedGraphNodeIds.size > 0;
     return sceneGraphEdges.map((e) => ({
+      ...(hasSelection
+        ? {
+            style:
+              selectedGraphNodeIds.has(e.sourceGraphNodeId) || selectedGraphNodeIds.has(e.targetGraphNodeId)
+                ? { stroke: 'rgba(167,139,250,0.95)', strokeWidth: 3 }
+                : { stroke: 'rgba(255,255,255,0.10)', strokeWidth: 2 },
+            markerEnd:
+              selectedGraphNodeIds.has(e.sourceGraphNodeId) || selectedGraphNodeIds.has(e.targetGraphNodeId)
+                ? { type: MarkerType.ArrowClosed, color: 'rgba(167,139,250,0.95)', strokeWidth: 2 }
+                : { type: MarkerType.ArrowClosed, color: 'rgba(255,255,255,0.18)', strokeWidth: 2 },
+          }
+        : {
+            style: { stroke: 'rgba(167,139,250,0.55)', strokeWidth: 2 },
+            markerEnd: { type: MarkerType.ArrowClosed, color: 'rgba(167,139,250,0.85)', strokeWidth: 2 },
+          }),
       id: e.id,
       source: e.sourceGraphNodeId,
       target: e.targetGraphNodeId,
       type: 'smoothstep',
       animated: false,
-      style: { stroke: 'rgba(167,139,250,0.55)', strokeWidth: 2 },
-      markerEnd: { type: MarkerType.ArrowClosed, color: 'rgba(167,139,250,0.85)', strokeWidth: 2 },
     }));
-  }, [sceneGraphEdges]);
+  }, [currentSceneId, sceneGraphEdges, sceneGraphNodes]);
 
   const [nodes, setNodes, onNodesChange] = useNodesState<Node<SceneCardData>>([]);
   const [edges, setEdges, onEdgesChange] = useEdgesState<Edge>([]);
@@ -381,6 +492,7 @@ function SceneGraphCanvas({
   }, [menu]);
 
   return (
+    <GraphUiContext.Provider value={ui}>
       <div className={styles.canvasWrap}>
         <ReactFlow
           nodes={nodes}
@@ -438,7 +550,7 @@ function SceneGraphCanvas({
               <>
                 <button
                   type="button"
-                aria-label="Закрыть меню"
+                  aria-label={ui.closeMenu}
                   className={styles.menuBackdrop}
                   onClick={() => setMenu(null)}
                 />
@@ -465,7 +577,7 @@ function SceneGraphCanvas({
                       setMenu(null);
                     }}
                   >
-                  {menuNodeIsStart ? 'Снять метку «Начальная сцена»' : 'Начальная сцена'}
+                    {menuNodeIsStart ? ui.unsetStartScene : ui.startScene}
                   </button>
                   <button
                     type="button"
@@ -476,7 +588,7 @@ function SceneGraphCanvas({
                       setMenu(null);
                     }}
                   >
-                  Удалить
+                    {ui.delete}
                   </button>
                 </div>
               </>,
@@ -484,6 +596,7 @@ function SceneGraphCanvas({
             )
           : null}
       </div>
+    </GraphUiContext.Provider>
   );
 }
 

app/renderer/editor/graph/sceneCardById.test.ts

@@ -0,0 +1,103 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import type { Project } from '../../../shared/types';
+import type { AssetId, SceneId } from '../../../shared/types/ids';
+
+import { buildNextSceneCardById } from './sceneCardById';
+
+function minimalProject(overrides: Partial<Project>): Project {
+  return {
+    id: 'p1' as unknown as Project['id'],
+    meta: {
+      name: 'n',
+      fileBaseName: 'f',
+      createdAt: '',
+      updatedAt: '',
+      createdWithAppVersion: '1',
+      appVersion: '1',
+      schemaVersion: 1 as unknown as Project['meta']['schemaVersion'],
+    },
+    scenes: {},
+    assets: {},
+    campaignAudios: [],
+    currentSceneId: null,
+    currentGraphNodeId: null,
+    sceneGraphNodes: [],
+    sceneGraphEdges: [],
+    ...overrides,
+  } as unknown as Project;
+}
+
+void test('buildNextSceneCardById: does not change refs when irrelevant fields change', () => {
+  const sid = 's1' as SceneId;
+  const base = minimalProject({
+    scenes: {
+      [sid]: {
+        id: sid,
+        title: 'T',
+        description: 'A',
+        media: { videos: [], audios: [{ assetId: 'a1' as AssetId, autoplay: false, loop: true }] },
+        settings: { autoplayVideo: false, autoplayAudio: false, loopVideo: false, loopAudio: false },
+        connections: [],
+        layout: { x: 0, y: 0 },
+        previewAssetId: null,
+        previewThumbAssetId: null,
+        previewAssetType: null,
+        previewVideoAutostart: false,
+        previewRotationDeg: 0,
+      },
+    } as unknown as Project['scenes'],
+  });
+
+  const first = buildNextSceneCardById({}, base);
+  const card1 = first[sid];
+  assert.ok(card1);
+
+  const changedOnlyDescription = minimalProject({
+    ...base,
+    scenes: {
+      ...base.scenes,
+      [sid]: { ...base.scenes[sid], description: 'B' },
+    },
+  });
+  const second = buildNextSceneCardById(first, changedOnlyDescription);
+
+  assert.equal(second, first, 'record identity should be reused');
+  assert.equal(second[sid], card1, 'card identity should be reused');
+});
+
+void test('buildNextSceneCardById: changes card when title changes', () => {
+  const sid = 's1' as SceneId;
+  const base = minimalProject({
+    scenes: {
+      [sid]: {
+        id: sid,
+        title: 'T',
+        description: '',
+        media: { videos: [], audios: [] },
+        settings: { autoplayVideo: false, autoplayAudio: false, loopVideo: false, loopAudio: false },
+        connections: [],
+        layout: { x: 0, y: 0 },
+        previewAssetId: null,
+        previewThumbAssetId: null,
+        previewAssetType: null,
+        previewVideoAutostart: false,
+        previewRotationDeg: 0,
+      },
+    } as unknown as Project['scenes'],
+  });
+  const first = buildNextSceneCardById({}, base);
+  const card1 = first[sid];
+
+  const changedTitle = minimalProject({
+    ...base,
+    scenes: {
+      ...base.scenes,
+      [sid]: { ...base.scenes[sid], title: 'T2' },
+    },
+  });
+  const second = buildNextSceneCardById(first, changedTitle);
+
+  assert.notEqual(second[sid], card1);
+});

app/renderer/editor/graph/sceneCardById.ts

@@ -0,0 +1,70 @@
+import type { Project } from '../../../shared/types';
+import type { SceneId } from '../../../shared/types/ids';
+
+import type { SceneGraphSceneAudioSummary, SceneGraphSceneCard } from './SceneGraph';
+
+export function stableSceneGraphAudios(
+  prevCard: SceneGraphSceneCard | undefined,
+  nextRaw: SceneGraphSceneAudioSummary[],
+): readonly SceneGraphSceneAudioSummary[] {
+  if (!prevCard) return nextRaw;
+  const pa = prevCard.audios;
+  if (pa.length !== nextRaw.length) return nextRaw;
+  for (let i = 0; i < nextRaw.length; i++) {
+    const p = pa[i];
+    const n = nextRaw[i];
+    if (p?.assetId !== n?.assetId || p?.loop !== n?.loop || p?.autoplay !== n?.autoplay) return nextRaw;
+  }
+  return pa;
+}
+
+export function buildNextSceneCardById(
+  prevRecord: Record<SceneId, SceneGraphSceneCard>,
+  project: Project,
+): Record<SceneId, SceneGraphSceneCard> {
+  const nextMap: Record<SceneId, SceneGraphSceneCard> = {};
+
+  for (const id of Object.keys(project.scenes) as SceneId[]) {
+    const s = project.scenes[id];
+    if (!s) continue;
+    const prevCard = prevRecord[id];
+    const nextAudiosRaw: SceneGraphSceneAudioSummary[] = s.media.audios.map((a) => ({
+      assetId: a.assetId,
+      loop: a.loop,
+      autoplay: a.autoplay,
+    }));
+    const audios = stableSceneGraphAudios(prevCard, nextAudiosRaw);
+    const loopVideo = s.settings.loopVideo;
+    if (
+      prevCard?.title === s.title &&
+      prevCard.previewAssetId === s.previewAssetId &&
+      prevCard.previewThumbAssetId === s.previewThumbAssetId &&
+      prevCard.previewAssetType === s.previewAssetType &&
+      prevCard.previewVideoAutostart === s.previewVideoAutostart &&
+      prevCard.previewRotationDeg === s.previewRotationDeg &&
+      prevCard.loopVideo === loopVideo &&
+      prevCard.audios === audios
+    ) {
+      nextMap[id] = prevCard;
+    } else {
+      nextMap[id] = {
+        title: s.title,
+        previewAssetId: s.previewAssetId,
+        previewThumbAssetId: s.previewThumbAssetId,
+        previewAssetType: s.previewAssetType,
+        previewVideoAutostart: s.previewVideoAutostart,
+        previewRotationDeg: s.previewRotationDeg,
+        loopVideo,
+        audios,
+      };
+    }
+  }
+
+  const prevKeys = Object.keys(prevRecord);
+  const nextKeys = Object.keys(nextMap);
+  const reuseRecord =
+    prevKeys.length === nextKeys.length &&
+    nextKeys.every((k) => prevRecord[k as SceneId] === nextMap[k as SceneId]);
+
+  return reuseRecord ? prevRecord : nextMap;
+}

app/renderer/editor/i18n/EditorI18nContext.tsx

@@ -0,0 +1,55 @@
+import React, { createContext, useCallback, useContext, useMemo, useState } from 'react';
+
+import {
+  EDITOR_LOCALE_STORAGE_KEY,
+  inferEditorLocaleFromSystem,
+  normalizeEditorLocale,
+  translateEditorMessage,
+  type EditorLocale,
+} from './editorMessages';
+
+type EditorI18nContextValue = {
+  locale: EditorLocale;
+  setLocale: (next: EditorLocale) => void;
+  t: (key: string, vars?: Record<string, string | number>) => string;
+};
+
+const EditorI18nContext = createContext<EditorI18nContextValue | null>(null);
+
+function readInitialLocale(): EditorLocale {
+  try {
+    return normalizeEditorLocale(localStorage.getItem(EDITOR_LOCALE_STORAGE_KEY));
+  } catch {
+    return inferEditorLocaleFromSystem();
+  }
+}
+
+export function EditorI18nProvider({ children }: { children: React.ReactNode }) {
+  const [locale, setLocaleState] = useState<EditorLocale>(readInitialLocale);
+
+  const setLocale = useCallback((next: EditorLocale) => {
+    setLocaleState(next);
+    try {
+      localStorage.setItem(EDITOR_LOCALE_STORAGE_KEY, next);
+    } catch {
+      // ignore
+    }
+  }, []);
+
+  const t = useCallback(
+    (key: string, vars?: Record<string, string | number>) => translateEditorMessage(locale, key, vars),
+    [locale],
+  );
+
+  const value = useMemo<EditorI18nContextValue>(() => ({ locale, setLocale, t }), [locale, setLocale, t]);
+
+  return <EditorI18nContext.Provider value={value}>{children}</EditorI18nContext.Provider>;
+}
+
+export function useEditorI18n(): EditorI18nContextValue {
+  const ctx = useContext(EditorI18nContext);
+  if (!ctx) {
+    throw new Error('useEditorI18n must be used within EditorI18nProvider');
+  }
+  return ctx;
+}

app/renderer/editor/i18n/editorMessages.locale.test.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { inferEditorLocaleFromSystem, normalizeEditorLocale } from './editorMessages';
+
+void test('inferEditorLocaleFromSystem: en-* wins when listed first', () => {
+  assert.equal(inferEditorLocaleFromSystem(['en-GB', 'ru-RU']), 'en');
+});
+
+void test('inferEditorLocaleFromSystem: ru-* wins when listed first', () => {
+  assert.equal(inferEditorLocaleFromSystem(['ru-RU', 'en-US']), 'ru');
+});
+
+void test('inferEditorLocaleFromSystem: unknown tags fall back to ru', () => {
+  assert.equal(inferEditorLocaleFromSystem(['de-DE', 'fr']), 'ru');
+});
+
+void test('inferEditorLocaleFromSystem: empty list → ru', () => {
+  assert.equal(inferEditorLocaleFromSystem([]), 'ru');
+});
+
+void test('normalizeEditorLocale: trims stored en/ru', () => {
+  assert.equal(normalizeEditorLocale(' EN '), 'en');
+  assert.equal(normalizeEditorLocale('ru '), 'ru');
+});
+
+void test('normalizeEditorLocale: blank or invalid defers to infer (explicit list)', () => {
+  assert.equal(normalizeEditorLocale(''), inferEditorLocaleFromSystem([]));
+  assert.equal(normalizeEditorLocale('xx'), inferEditorLocaleFromSystem([]));
+});

app/renderer/editor/i18n/editorMessages.ts

@@ -0,0 +1,500 @@
+export type EditorLocale = 'ru' | 'en';
+
+export const EDITOR_LOCALE_STORAGE_KEY = 'dnd_editor_locale';
+
+function primaryLanguageTag(lang: string): string {
+  const trimmed = lang.trim().toLowerCase();
+  if (!trimmed) return '';
+  const sep = trimmed.search(/[-_]/);
+  return sep === -1 ? trimmed : trimmed.slice(0, sep);
+}
+
+/**
+ * Выбор `ru` / `en` по языку ОС/браузера, если пользователь ещё не сохранил язык в `localStorage`.
+ * В Electron совпадает с локалью системы (Chromium подставляет `navigator.languages`).
+ */
+export function inferEditorLocaleFromSystem(languages?: readonly string[]): EditorLocale {
+  let list: string[];
+  if (languages !== undefined) {
+    list = [...languages];
+  } else if (typeof navigator !== 'undefined') {
+    list = [...navigator.languages];
+    if (navigator.language) {
+      list.push(navigator.language);
+    }
+    list = list.filter((x) => x.trim() !== '');
+  } else {
+    list = [];
+  }
+  for (const lang of list) {
+    const tag = primaryLanguageTag(lang);
+    if (tag === 'en') return 'en';
+    if (tag === 'ru') return 'ru';
+  }
+  return 'ru';
+}
+
+export function normalizeEditorLocale(raw: string | null | undefined): EditorLocale {
+  if (raw == null) {
+    return inferEditorLocaleFromSystem();
+  }
+  const trimmed = raw.trim();
+  if (trimmed === '') {
+    return inferEditorLocaleFromSystem();
+  }
+  const s = trimmed.toLowerCase();
+  if (s === 'en') return 'en';
+  if (s === 'ru') return 'ru';
+  return inferEditorLocaleFromSystem();
+}
+
+/** Flat message table; `{name}` placeholders supported in `translate`. */
+export const EDITOR_MESSAGES: Record<EditorLocale, Record<string, string>> = {
+  ru: {
+    'common.close': 'Закрыть',
+    'common.cancel': 'Отмена',
+    'common.save': 'Сохранить',
+    'common.understood': 'Понятно',
+    'common.message': 'Сообщение',
+    'common.error': 'Ошибка',
+    'common.delete': 'Удалить',
+    'common.closeMenu': 'Закрыть меню',
+
+    'notice.campaignAudioEmpty': 'Аудио не добавлено. Проверьте формат файла.',
+
+    'license.checkingTitle': 'Проверка лицензии…',
+    'license.checkingWait': 'Подождите.',
+    'license.requiredTitle': 'Требуется лицензия',
+    'license.requiredHint':
+      'Укажите ключ в меню «Настройки» → «Указать ключ». До активации доступно только меню «Настройки».',
+    'license.tokenTitle': 'Указать ключ',
+    'license.tokenKey': 'КЛЮЧ',
+    'license.tokenPlaceholder': 'Продуктовый ключ DND-...',
+    'license.tokenSaving': 'Сохранение…',
+    'license.eulaTitle': 'Лицензионное соглашение',
+    'license.eulaReject': 'Не принимаю',
+    'license.eulaAccept': 'Принимаю условия',
+    'license.eulaNoteEn':
+      'The binding legal text below is in Russian. If you need an English summary, contact support.',
+    'license.aboutTitle': 'О лицензии',
+    'license.aboutDevSkip': 'Режим разработки: проверка лицензии отключена (DND_SKIP_LICENSE).',
+    'license.aboutStatus': 'СТАТУС',
+    'license.aboutProduct': 'ПРОДУКТ',
+    'license.aboutLicenseId': 'ID ЛИЦЕНЗИИ',
+    'license.aboutExpiry': 'ОКОНЧАНИЕ',
+    'license.aboutDevice': 'УСТРОЙСТВО',
+    'license.aboutNoData': 'Нет данных лицензии.',
+    'license.reason.ok': 'Активна',
+    'license.reason.none': 'Ключ не указан',
+    'license.reason.expired': 'Срок действия истёк',
+    'license.reason.bad_signature': 'Недействительная подпись',
+    'license.reason.bad_payload': 'Неверный формат токена',
+    'license.reason.malformed': 'Повреждённый токен',
+    'license.reason.not_yet_valid': 'Ещё не действует',
+    'license.reason.wrong_device': 'Другой привязанный компьютер',
+    'license.reason.revoked_remote': 'Отозвана на сервере',
+
+    'presentation.overlay': 'Презентация запущена',
+    'presentation.title': 'Презентация запущена',
+    'presentation.body':
+      'Редактор заблокирован. Закройте окна «Презентация» и «Панель управления», чтобы продолжить.',
+
+    'zip.progress': 'Прогресс операции',
+    'zip.importTitle': 'Импорт проекта',
+    'zip.exportTitle': 'Экспорт проекта',
+
+    'top.settings': 'Настройки',
+    'top.project': 'Проект',
+    'top.file': 'Файл',
+    'top.backToProjects': 'К списку проектов',
+    'top.appVersion': 'Версия приложения',
+    'top.run': 'Запустить',
+    'top.afterLicense': 'Доступно после активации лицензии',
+    'top.setStartScene': 'Назначьте начальную сцену на графе (ПКМ по узлу)',
+
+    'menu.enterKey': 'Указать ключ',
+    'menu.aboutLicense': 'О лицензии',
+    'menu.language': 'Язык',
+    'menu.langRu': 'Русский',
+    'menu.langEn': 'English',
+
+    'projectMenu.home': 'Начальный экран',
+    'projectMenu.import': 'Импорт',
+    'projectMenu.export': 'Экспорт',
+    'projectMenu.noProjects': 'Нет сохранённых проектов',
+
+    'fileMenu.rename': 'Переименовать проект',
+
+    'scenes.search': 'Поиск сцен…',
+    'scenes.new': '+ Новая сцена',
+    'scenes.inspectorGame': 'Свойства игры',
+    'scenes.inspectorScene': 'Свойства сцены',
+    'scenes.selectHint': 'Выберите сцену слева, чтобы редактировать её свойства.',
+    'scenes.openProjectHint': 'Откройте проект, чтобы редактировать кампанию и сцены.',
+
+    'rename.title': 'Переименовать проект',
+    'rename.projectName': 'НАЗВАНИЕ ПРОЕКТА',
+    'rename.projectPlaceholder': 'Название проекта…',
+    'rename.projectMin': 'Минимум 3 символа.',
+    'rename.projectDup': 'Проект с таким названием уже существует.',
+    'rename.fileName': 'НАЗВАНИЕ ФАЙЛА ПРОЕКТА',
+    'rename.fileInvalid': 'Минимум 3 символа, без символов <>:"/\\|?*',
+    'rename.fileDup': 'Файл проекта с таким названием уже существует.',
+    'rename.saving': 'Сохранение…',
+
+    'export.title': 'Экспорт проекта',
+    'export.project': 'ПРОЕКТ',
+    'export.hint':
+      'Далее откроется окно сохранения: укажите имя и папку для файла .dnd.zip — будет создана копия архива проекта.',
+    'export.exporting': 'Экспорт…',
+    'export.saveAs': 'Сохранить как…',
+
+    'confirmDelete.title': 'Удаление проекта',
+    'confirmDelete.body': 'Удалить проект «{name}» безвозвратно? Файл и кэш будут стёрты с диска.',
+    'confirmDelete.failedTitle': 'Не удалось удалить',
+
+    'picker.title': 'Проекты',
+    'picker.newPlaceholder': 'Название нового проекта…',
+    'picker.create': 'Создать проект',
+    'picker.existing': 'СУЩЕСТВУЮЩИЕ',
+    'picker.lockedHint':
+      'Открытие и создание — после активации лицензии. Список показывает файлы в папке приложения.',
+    'picker.empty': 'Пока нет проектов.',
+    'picker.projectMenu': 'Меню проекта',
+    'picker.openDisabled': 'Открытие проекта — после активации лицензии',
+    'picker.defaultName': 'Моя кампания',
+
+    'campaign.label': 'АУДИО ИГРЫ',
+    'campaign.noFiles': 'Файлов пока нет. Добавьте аудио.',
+    'campaign.auto': 'Авто',
+    'campaign.loop': 'Цикл',
+    'campaign.removeTitle': 'Убрать из кампании',
+    'campaign.upload': 'Загрузить',
+
+    'scene.title': 'НАЗВАНИЕ СЦЕНЫ',
+    'scene.description': 'ОПИСАНИЕ',
+    'scene.preview': 'ПРЕВЬЮ СЦЕНЫ',
+    'scene.previewHint': 'Файл изображения (PNG, JPG, WebP, GIF и т.д.).',
+    'scene.previewEmpty': 'Превью не задано',
+    'scene.previewBusy': 'Загрузка и оптимизация изображения…',
+    'scene.change': 'Изменить',
+    'scene.clear': 'Очистить',
+    'scene.autostart': 'Автостарт',
+    'scene.rotate': 'Повернуть',
+    'scene.audio': 'АУДИО СЦЕНЫ',
+    'scene.removeTitle': 'Убрать из сцены',
+    'scene.branching': 'ВЕТВЛЕНИЯ',
+    'scene.branchingHint':
+      'Перетащите сцену из списка на граф. С одной карточки можно задать несколько вариантов — по одной связи на каждую целевую сцену. Повторно к той же сцене (включая вторую карточку той же сцены на графе) подключить нельзя.',
+
+    'sceneCard.current': 'ТЕКУЩАЯ',
+    'sceneCard.menu': 'Меню сцены',
+
+    'graph.badgeStart': 'НАЧАЛО',
+    'graph.untitled': 'Без названия',
+    'graph.videoBadge': 'Видео',
+    'graph.audioBadge': 'Аудио',
+    'graph.loop': 'Цикл',
+    'graph.autoplay': 'Автостарт',
+    'graph.previewAutostart': 'Авто превью',
+    'graph.videoLoop': 'Цикл видео',
+    'graph.zoomBar': 'Масштаб графа',
+    'graph.zoomIn': 'Увеличить',
+    'graph.zoomOut': 'Уменьшить',
+    'graph.fitAll': 'Показать всё',
+    'graph.startScene': 'Начальная сцена',
+    'graph.unsetStartScene': 'Снять метку «Начальная сцена»',
+
+    'control.remoteTitle': 'ПУЛЬТ УПРАВЛЕНИЯ',
+    'control.effects': 'ЭФФЕКТЫ',
+    'control.tools': 'Инструменты',
+    'control.fieldEffects': 'Эффекты поля',
+    'control.actionEffects': 'Эффекты действий',
+    'control.eraser': 'Ластик',
+    'control.clearEffects': 'Очистить эффекты',
+    'control.fog': 'Туман',
+    'control.rain': 'Дождь',
+    'control.fire': 'Огонь',
+    'control.water': 'Вода',
+    'control.lightning': 'Молния',
+    'control.sunbeam': 'Луч света',
+    'control.freeze': 'Заморозка',
+    'control.poisonCloud': 'Облако яда',
+    'control.brushRadius': 'Радиус кисти',
+    'control.storyLine': 'СЮЖЕТНАЯ ЛИНИЯ',
+    'control.gotoScene': 'Перейти к этой сцене',
+    'control.currentSceneBadge': 'ТЕКУЩАЯ СЦЕНА',
+    'control.passed': 'Пройдено',
+    'control.noActiveScene': 'Нет активной сцены.',
+    'control.screenPreview': 'Предпросмотр экрана',
+    'control.stopPresentation': 'Выключить демонстрацию',
+    'control.videoBrushHint':
+      'Видео-превью: кисть эффектов отключена (как на экране демонстрации — оверлей только для изображения).',
+    'control.branches': 'Варианты ветвления',
+    'control.option': 'ОПЦИЯ {n}',
+    'control.unnamed': 'Без названия',
+    'control.switchScene': 'Переключить',
+    'control.noBranches': 'Нет вариантов перехода.',
+    'control.endPresentation': 'Завершить показ',
+    'control.music': 'Музыка',
+    'control.sceneMusic': 'МУЗЫКА СЦЕНЫ',
+    'control.gameMusic': 'МУЗЫКА ИГРЫ',
+    'control.noSceneAudio': 'В текущей сцене нет аудио.',
+    'control.noGameAudio': 'В игре нет аудио.',
+    'control.modeAuto': 'Авто',
+    'control.modeManual': 'Ручн.',
+    'control.once': 'Один раз',
+    'control.loop': 'Цикл',
+    'control.scrubSeek': 'Клик — перемотка',
+    'control.durationUnknown': 'Длительность неизвестна',
+    'control.pauseSceneMusic': 'Пауза (сцена)',
+    'control.pauseSceneMusicTitle': 'В сцене есть музыка',
+    'control.pauseCampaignTitle': 'Пауза: в сцене есть музыка',
+    'control.playFailed': 'Не удалось запустить.',
+    'control.audioAutoplayBlocked':
+      'Автозапуск заблокирован (нужно действие пользователя) или ошибка воспроизведения.',
+    'control.audioNoUrl': 'URL не получен',
+    'control.audioNoUrlDetail': 'Не удалось получить dnd://asset URL для аудио.',
+    'control.audioBlocked': 'Ошибка/блок',
+    'control.audioError': 'Ошибка',
+    'control.audioMediaError': 'MediaError code={code} (1=ABORTED, 2=NETWORK, 3=DECODE, 4=SRC_NOT_SUPPORTED)',
+    'control.audioLoading': 'Загрузка…',
+    'control.audioPlaying': 'Играет',
+    'control.audioPaused': 'Пауза',
+    'control.audioStopped': 'Остановлено',
+    'control.previewTrackLabel': 'Превью без субтитров',
+    'control.transportPlay': 'Воспроизведение',
+    'control.transportPause': 'Пауза',
+    'control.transportStop': 'Стоп',
+  },
+  en: {
+    'common.close': 'Close',
+    'common.cancel': 'Cancel',
+    'common.save': 'Save',
+    'common.understood': 'OK',
+    'common.message': 'Message',
+    'common.error': 'Error',
+    'common.delete': 'Delete',
+    'common.closeMenu': 'Close menu',
+
+    'notice.campaignAudioEmpty': 'No audio was added. Check the file format.',
+
+    'license.checkingTitle': 'Checking license…',
+    'license.checkingWait': 'Please wait.',
+    'license.requiredTitle': 'License required',
+    'license.requiredHint':
+      'Enter your key via Settings → Enter license key. Until activation, only Settings is available.',
+    'license.tokenTitle': 'Enter license key',
+    'license.tokenKey': 'KEY',
+    'license.tokenPlaceholder': 'DND product key…',
+    'license.tokenSaving': 'Saving…',
+    'license.eulaTitle': 'End User License Agreement',
+    'license.eulaReject': 'Decline',
+    'license.eulaAccept': 'I accept the terms',
+    'license.eulaNoteEn':
+      'The binding legal text below is in Russian. If you need an English summary, contact support.',
+    'license.aboutTitle': 'About license',
+    'license.aboutDevSkip': 'Development mode: license checks are disabled (DND_SKIP_LICENSE).',
+    'license.aboutStatus': 'STATUS',
+    'license.aboutProduct': 'PRODUCT',
+    'license.aboutLicenseId': 'LICENSE ID',
+    'license.aboutExpiry': 'EXPIRES',
+    'license.aboutDevice': 'DEVICE',
+    'license.aboutNoData': 'No license data.',
+    'license.reason.ok': 'Active',
+    'license.reason.none': 'No key provided',
+    'license.reason.expired': 'Expired',
+    'license.reason.bad_signature': 'Invalid signature',
+    'license.reason.bad_payload': 'Invalid token format',
+    'license.reason.malformed': 'Malformed token',
+    'license.reason.not_yet_valid': 'Not yet valid',
+    'license.reason.wrong_device': 'Wrong bound device',
+    'license.reason.revoked_remote': 'Revoked on server',
+
+    'presentation.overlay': 'Presentation running',
+    'presentation.title': 'Presentation running',
+    'presentation.body': 'The editor is locked. Close the Presentation and Control windows to continue.',
+
+    'zip.progress': 'Operation progress',
+    'zip.importTitle': 'Import project',
+    'zip.exportTitle': 'Export project',
+
+    'top.settings': 'Settings',
+    'top.project': 'Project',
+    'top.file': 'File',
+    'top.backToProjects': 'Back to projects',
+    'top.appVersion': 'App version',
+    'top.run': 'Run',
+    'top.afterLicense': 'Available after license activation',
+    'top.setStartScene': 'Set a start scene on the graph (right‑click a node)',
+
+    'menu.enterKey': 'Enter license key',
+    'menu.aboutLicense': 'About license',
+    'menu.language': 'Language',
+    'menu.langRu': 'Русский',
+    'menu.langEn': 'English',
+
+    'projectMenu.home': 'Home',
+    'projectMenu.import': 'Import',
+    'projectMenu.export': 'Export',
+    'projectMenu.noProjects': 'No saved projects',
+
+    'fileMenu.rename': 'Rename project',
+
+    'scenes.search': 'Search scenes…',
+    'scenes.new': '+ New scene',
+    'scenes.inspectorGame': 'Game properties',
+    'scenes.inspectorScene': 'Scene properties',
+    'scenes.selectHint': 'Select a scene on the left to edit its properties.',
+    'scenes.openProjectHint': 'Open a project to edit the campaign and scenes.',
+
+    'rename.title': 'Rename project',
+    'rename.projectName': 'PROJECT NAME',
+    'rename.projectPlaceholder': 'Project name…',
+    'rename.projectMin': 'At least 3 characters.',
+    'rename.projectDup': 'A project with this name already exists.',
+    'rename.fileName': 'PROJECT FILE NAME',
+    'rename.fileInvalid': 'At least 3 characters; forbidden characters <>:"/\\|?*',
+    'rename.fileDup': 'A project file with this name already exists.',
+    'rename.saving': 'Saving…',
+
+    'export.title': 'Export project',
+    'export.project': 'PROJECT',
+    'export.hint':
+      'A save dialog will open: choose a name and folder for the .dnd.zip file — a copy of the project archive will be created.',
+    'export.exporting': 'Exporting…',
+    'export.saveAs': 'Save as…',
+
+    'confirmDelete.title': 'Delete project',
+    'confirmDelete.body':
+      'Permanently delete project “{name}”? The file and cache will be removed from disk.',
+    'confirmDelete.failedTitle': 'Could not delete',
+
+    'picker.title': 'Projects',
+    'picker.newPlaceholder': 'New project name…',
+    'picker.create': 'Create project',
+    'picker.existing': 'EXISTING',
+    'picker.lockedHint':
+      'Opening and creating projects require an active license. The list still shows files in the app folder.',
+    'picker.empty': 'No projects yet.',
+    'picker.projectMenu': 'Project menu',
+    'picker.openDisabled': 'Open project — after license activation',
+    'picker.defaultName': 'My campaign',
+
+    'campaign.label': 'GAME AUDIO',
+    'campaign.noFiles': 'No files yet. Add audio.',
+    'campaign.auto': 'Auto',
+    'campaign.loop': 'Loop',
+    'campaign.removeTitle': 'Remove from campaign',
+    'campaign.upload': 'Upload',
+
+    'scene.title': 'SCENE TITLE',
+    'scene.description': 'DESCRIPTION',
+    'scene.preview': 'SCENE PREVIEW',
+    'scene.previewHint': 'Image file (PNG, JPG, WebP, GIF, etc.).',
+    'scene.previewEmpty': 'No preview',
+    'scene.previewBusy': 'Loading and optimizing image…',
+    'scene.change': 'Change',
+    'scene.clear': 'Clear',
+    'scene.autostart': 'Autostart',
+    'scene.rotate': 'Rotate',
+    'scene.audio': 'SCENE AUDIO',
+    'scene.removeTitle': 'Remove from scene',
+    'scene.branching': 'BRANCHING',
+    'scene.branchingHint':
+      'Drag a scene from the list onto the graph. One card can branch to several targets — one link per target scene. You cannot link twice to the same target (including a second card of the same scene).',
+
+    'sceneCard.current': 'CURRENT',
+    'sceneCard.menu': 'Scene menu',
+
+    'graph.badgeStart': 'START',
+    'graph.untitled': 'Untitled',
+    'graph.videoBadge': 'Video',
+    'graph.audioBadge': 'Audio',
+    'graph.loop': 'Loop',
+    'graph.autoplay': 'Autoplay',
+    'graph.previewAutostart': 'Preview autostart',
+    'graph.videoLoop': 'Video loop',
+    'graph.zoomBar': 'Graph zoom',
+    'graph.zoomIn': 'Zoom in',
+    'graph.zoomOut': 'Zoom out',
+    'graph.fitAll': 'Fit view',
+    'graph.startScene': 'Start scene',
+    'graph.unsetStartScene': 'Clear start scene mark',
+
+    'control.remoteTitle': 'CONTROL PANEL',
+    'control.effects': 'EFFECTS',
+    'control.tools': 'Tools',
+    'control.fieldEffects': 'Field effects',
+    'control.actionEffects': 'Action effects',
+    'control.eraser': 'Eraser',
+    'control.clearEffects': 'Clear effects',
+    'control.fog': 'Fog',
+    'control.rain': 'Rain',
+    'control.fire': 'Fire',
+    'control.water': 'Water',
+    'control.lightning': 'Lightning',
+    'control.sunbeam': 'Sunbeam',
+    'control.freeze': 'Freeze',
+    'control.poisonCloud': 'Poison cloud',
+    'control.brushRadius': 'Brush radius',
+    'control.storyLine': 'STORYLINE',
+    'control.gotoScene': 'Go to this scene',
+    'control.currentSceneBadge': 'CURRENT SCENE',
+    'control.passed': 'Visited',
+    'control.noActiveScene': 'No active scene.',
+    'control.screenPreview': 'Screen preview',
+    'control.stopPresentation': 'Stop presentation',
+    'control.videoBrushHint':
+      'Video preview: effect brush is disabled (like on the presentation screen — overlay is for images only).',
+    'control.branches': 'Branch options',
+    'control.option': 'OPTION {n}',
+    'control.unnamed': 'Untitled',
+    'control.switchScene': 'Switch',
+    'control.noBranches': 'No transitions available.',
+    'control.endPresentation': 'End presentation',
+    'control.music': 'Music',
+    'control.sceneMusic': 'SCENE MUSIC',
+    'control.gameMusic': 'GAME MUSIC',
+    'control.noSceneAudio': 'No audio in the current scene.',
+    'control.noGameAudio': 'No game audio.',
+    'control.modeAuto': 'Auto',
+    'control.modeManual': 'Manual',
+    'control.once': 'Once',
+    'control.loop': 'Loop',
+    'control.scrubSeek': 'Click to seek',
+    'control.durationUnknown': 'Duration unknown',
+    'control.pauseSceneMusic': 'Paused (scene)',
+    'control.pauseSceneMusicTitle': 'Scene has music',
+    'control.pauseCampaignTitle': 'Paused: scene has music',
+    'control.playFailed': 'Could not start playback.',
+    'control.audioAutoplayBlocked': 'Autoplay was blocked (user gesture required) or playback failed.',
+    'control.audioNoUrl': 'No URL',
+    'control.audioNoUrlDetail': 'Could not get dnd://asset URL for audio.',
+    'control.audioBlocked': 'Error / blocked',
+    'control.audioError': 'Error',
+    'control.audioMediaError': 'MediaError code={code} (1=ABORTED, 2=NETWORK, 3=DECODE, 4=SRC_NOT_SUPPORTED)',
+    'control.audioLoading': 'Loading…',
+    'control.audioPlaying': 'Playing',
+    'control.audioPaused': 'Paused',
+    'control.audioStopped': 'Stopped',
+    'control.previewTrackLabel': 'Preview (no captions)',
+    'control.transportPlay': 'Play',
+    'control.transportPause': 'Pause',
+    'control.transportStop': 'Stop',
+  },
+};
+
+export function translateEditorMessage(
+  locale: EditorLocale,
+  key: string,
+  vars?: Record<string, string | number>,
+): string {
+  let s = EDITOR_MESSAGES[locale][key] ?? EDITOR_MESSAGES.ru[key] ?? key;
+  if (vars) {
+    for (const [k, v] of Object.entries(vars)) {
+      s = s.split(`{${k}}`).join(String(v));
+    }
+  }
+  return s;
+}

app/renderer/editor/license/EditorLicenseModals.tsx

@@ -8,6 +8,7 @@ import { EULA_RU_MARKDOWN } from '../../legal/eulaRu';
 import { getDndApi } from '../../shared/dndApi';
 import { Button } from '../../shared/ui/controls';
 import styles from '../EditorApp.module.css';
+import { useEditorI18n } from '../i18n/EditorI18nContext';
 
 type LicenseTokenModalProps = {
   open: boolean;
@@ -16,6 +17,7 @@ type LicenseTokenModalProps = {
 };
 
 export function LicenseTokenModal({ open, onClose, onSaved }: LicenseTokenModalProps) {
+  const { t } = useEditorI18n();
   const [token, setToken] = useState('');
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -40,28 +42,38 @@ export function LicenseTokenModal({ open, onClose, onSaved }: LicenseTokenModalP
 
   return createPortal(
     <>
-      <button type="button" aria-label="Закрыть" onClick={onClose} className={styles.modalBackdrop} />
+      <button
+        type="button"
+        aria-label={t('common.close')}
+        onClick={onClose}
+        className={styles.modalBackdrop}
+      />
       <div role="dialog" aria-modal="true" className={styles.modalDialog}>
         <div className={styles.modalHeader}>
-          <div className={styles.modalTitle}>Указать ключ</div>
-          <button type="button" aria-label="Закрыть" onClick={onClose} className={styles.modalClose}>
+          <div className={styles.modalTitle}>{t('license.tokenTitle')}</div>
+          <button
+            type="button"
+            aria-label={t('common.close')}
+            onClick={onClose}
+            className={styles.modalClose}
+          >
             ×
           </button>
         </div>
         <div className={styles.fieldGrid}>
-          <div className={styles.fieldLabel}>КЛЮЧ</div>
+          <div className={styles.fieldLabel}>{t('license.tokenKey')}</div>
           <textarea
             className={styles.licenseTextarea}
             value={token}
             onChange={(e) => setToken(e.target.value)}
-            placeholder="Продуктовый ключ DND-..."
+            placeholder={t('license.tokenPlaceholder')}
             spellCheck={false}
           />
         </div>
         {error ? <div className={styles.fieldError}>{error}</div> : null}
         <div className={styles.modalFooter}>
           <Button onClick={onClose} disabled={saving}>
-            Отмена
+            {t('common.cancel')}
           </Button>
           <Button
             variant="primary"
@@ -82,7 +94,7 @@ export function LicenseTokenModal({ open, onClose, onSaved }: LicenseTokenModalP
               })();
             }}
           >
-            Сохранить
+            {t('common.save')}
           </Button>
         </div>
       </div>
@@ -98,6 +110,7 @@ type EulaModalProps = {
 };
 
 export function EulaModal({ open, onClose, onAccepted }: EulaModalProps) {
+  const { t, locale } = useEditorI18n();
   const [saving, setSaving] = useState(false);
 
   useEffect(() => {
@@ -113,18 +126,29 @@ export function EulaModal({ open, onClose, onAccepted }: EulaModalProps) {
 
   return createPortal(
     <>
-      <button type="button" aria-label="Закрыть" onClick={onClose} className={styles.modalBackdrop} />
+      <button
+        type="button"
+        aria-label={t('common.close')}
+        onClick={onClose}
+        className={styles.modalBackdrop}
+      />
       <div role="dialog" aria-modal="true" className={styles.modalDialog}>
         <div className={styles.modalHeader}>
-          <div className={styles.modalTitle}>Лицензионное соглашение</div>
-          <button type="button" aria-label="Закрыть" onClick={onClose} className={styles.modalClose}>
+          <div className={styles.modalTitle}>{t('license.eulaTitle')}</div>
+          <button
+            type="button"
+            aria-label={t('common.close')}
+            onClick={onClose}
+            className={styles.modalClose}
+          >
             ×
           </button>
         </div>
+        {locale === 'en' ? <div className={styles.muted}>{t('license.eulaNoteEn')}</div> : null}
         <div className={styles.eulaScroll}>{EULA_RU_MARKDOWN}</div>
         <div className={styles.modalFooter}>
           <Button onClick={onClose} disabled={saving}>
-            Не принимаю
+            {t('license.eulaReject')}
           </Button>
           <Button
             variant="primary"
@@ -144,7 +168,7 @@ export function EulaModal({ open, onClose, onAccepted }: EulaModalProps) {
               })();
             }}
           >
-            Принимаю условия
+            {t('license.eulaAccept')}
           </Button>
         </div>
       </div>
@@ -159,32 +183,16 @@ type LicenseAboutModalProps = {
   snapshot: LicenseSnapshot | null;
 };
 
-function reasonLabel(reason: LicenseSnapshot['reason']): string {
-  switch (reason) {
-    case 'ok':
-      return 'Активна';
-    case 'none':
-      return 'Ключ не указан';
-    case 'expired':
-      return 'Срок действия истёк';
-    case 'bad_signature':
-      return 'Недействительная подпись';
-    case 'bad_payload':
-      return 'Неверный формат токена';
-    case 'malformed':
-      return 'Повреждённый токен';
-    case 'not_yet_valid':
-      return 'Ещё не действует';
-    case 'wrong_device':
-      return 'Другой привязанный компьютер';
-    case 'revoked_remote':
-      return 'Отозвана на сервере';
-    default:
-      return reason;
-  }
+function licenseReasonLabel(t: (key: string) => string, reason: LicenseSnapshot['reason']): string {
+  const key = `license.reason.${reason}`;
+  const label = t(key);
+  return label === key ? reason : label;
 }
 
 export function LicenseAboutModal({ open, onClose, snapshot }: LicenseAboutModalProps) {
+  const { t, locale } = useEditorI18n();
+  const dateLocale = locale === 'en' ? 'en-US' : 'ru-RU';
+
   useEffect(() => {
     if (!open) return;
     const onKey = (e: KeyboardEvent) => {
@@ -198,7 +206,7 @@ export function LicenseAboutModal({ open, onClose, snapshot }: LicenseAboutModal
 
   const expText =
     snapshot?.summary?.exp != null
-      ? new Date(snapshot.summary.exp * 1000).toLocaleString('ru-RU', {
+      ? new Date(snapshot.summary.exp * 1000).toLocaleString(dateLocale, {
           dateStyle: 'long',
           timeStyle: 'short',
         })
@@ -206,48 +214,54 @@ export function LicenseAboutModal({ open, onClose, snapshot }: LicenseAboutModal
 
   return createPortal(
     <>
-      <button type="button" aria-label="Закрыть" onClick={onClose} className={styles.modalBackdrop} />
+      <button
+        type="button"
+        aria-label={t('common.close')}
+        onClick={onClose}
+        className={styles.modalBackdrop}
+      />
       <div role="dialog" aria-modal="true" className={styles.modalDialog}>
         <div className={styles.modalHeader}>
-          <div className={styles.modalTitle}>О лицензии</div>
-          <button type="button" aria-label="Закрыть" onClick={onClose} className={styles.modalClose}>
+          <div className={styles.modalTitle}>{t('license.aboutTitle')}</div>
+          <button
+            type="button"
+            aria-label={t('common.close')}
+            onClick={onClose}
+            className={styles.modalClose}
+          >
             ×
           </button>
         </div>
-        {snapshot?.devSkip ? (
-          <div className={styles.fieldError}>
-            Режим разработки: проверка лицензии отключена (DND_SKIP_LICENSE).
-          </div>
-        ) : null}
+        {snapshot?.devSkip ? <div className={styles.fieldError}>{t('license.aboutDevSkip')}</div> : null}
         <div className={styles.fieldGrid}>
-          <div className={styles.fieldLabel}>СТАТУС</div>
-          <div>{snapshot ? reasonLabel(snapshot.reason) : '—'}</div>
+          <div className={styles.fieldLabel}>{t('license.aboutStatus')}</div>
+          <div>{snapshot ? licenseReasonLabel(t, snapshot.reason) : '—'}</div>
         </div>
         {snapshot?.summary ? (
           <>
             <div className={styles.fieldGrid}>
-              <div className={styles.fieldLabel}>ПРОДУКТ</div>
+              <div className={styles.fieldLabel}>{t('license.aboutProduct')}</div>
               <div>{snapshot.summary.pid}</div>
             </div>
             <div className={styles.fieldGrid}>
-              <div className={styles.fieldLabel}>ID ЛИЦЕНЗИИ</div>
+              <div className={styles.fieldLabel}>{t('license.aboutLicenseId')}</div>
               <div style={{ wordBreak: 'break-all' }}>{snapshot.summary.sub}</div>
             </div>
             <div className={styles.fieldGrid}>
-              <div className={styles.fieldLabel}>ОКОНЧАНИЕ</div>
+              <div className={styles.fieldLabel}>{t('license.aboutExpiry')}</div>
               <div>{expText}</div>
             </div>
             <div className={styles.fieldGrid}>
-              <div className={styles.fieldLabel}>УСТРОЙСТВО</div>
+              <div className={styles.fieldLabel}>{t('license.aboutDevice')}</div>
               <div style={{ wordBreak: 'break-all' }}>{snapshot.deviceId}</div>
             </div>
           </>
         ) : (
-          <div className={styles.muted}>Нет данных лицензии.</div>
+          <div className={styles.muted}>{t('license.aboutNoData')}</div>
         )}
         <div className={styles.modalFooter}>
           <Button variant="primary" onClick={onClose}>
-            Закрыть
+            {t('common.close')}
           </Button>
         </div>
       </div>

app/renderer/editor/main.tsx

@@ -3,6 +3,7 @@ import { createRoot } from 'react-dom/client';
 
 import '../shared/ui/globals.css';
 import { EditorApp } from './EditorApp';
+import { EditorI18nProvider } from './i18n/EditorI18nContext';
 
 const rootEl = document.getElementById('root');
 if (!rootEl) {
@@ -11,6 +12,8 @@ if (!rootEl) {
 
 createRoot(rootEl).render(
   <React.StrictMode>
+    <EditorI18nProvider>
       <EditorApp />
+    </EditorI18nProvider>
   </React.StrictMode>,
 );

app/renderer/editor/state/projectState.race.test.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+void test('projectState: list/get after delete invalidates in-flight initial load (epoch guard)', () => {
+  const src = fs.readFileSync(path.join(here, 'projectState.ts'), 'utf8');
+  assert.match(src, /projectDataEpochRef/);
+  assert.match(src, /const epoch = \+\+projectDataEpochRef\.current/);
+  assert.match(src, /if \(projectDataEpochRef\.current !== epoch\) return/);
+  assert.match(
+    src,
+    /const deleteProject = async[\s\S]+?projectDataEpochRef\.current \+= 1[\s\S]+?await api\.invoke/,
+  );
+  assert.match(
+    src,
+    /const openProject = async[\s\S]+?projectDataEpochRef\.current \+= 1[\s\S]+?await api\.invoke/,
+  );
+  assert.match(src, /const refreshProjects = async \(\) => \{[\s\S]+?projectDataEpochRef\.current \+= 1/);
+});
+
+void test('ipc router: project.list does not require license', () => {
+  const routerSrc = fs.readFileSync(path.join(here, '..', '..', '..', 'main', 'ipc', 'router.ts'), 'utf8');
+  assert.match(routerSrc, /if \(channel === ipcChannels\.project\.list\) return false/);
+});

app/renderer/editor/state/projectState.ts

@@ -10,6 +10,7 @@ type State = {
   projects: ProjectSummary[];
   project: Project | null;
   selectedSceneId: SceneId | null;
+  zipProgress: { kind: 'import' | 'export'; percent: number; stage: string; detail?: string } | null;
 };
 
 type Actions = {
@@ -19,12 +20,15 @@ type Actions = {
   closeProject: () => Promise<void>;
   createScene: () => Promise<void>;
   selectScene: (id: SceneId) => Promise<void>;
+  importCampaignAudio: () => Promise<void>;
+  updateCampaignAudios: (next: Project['campaignAudios']) => Promise<void>;
   updateScene: (
     sceneId: SceneId,
     patch: {
       title?: string;
       description?: string;
       previewAssetId?: AssetId | null;
+      previewThumbAssetId?: AssetId | null;
       previewAssetType?: 'image' | 'video' | null;
       previewVideoAutostart?: boolean;
       previewRotationDeg?: 0 | 90 | 180 | 270;
@@ -54,16 +58,71 @@ function randomId(prefix: string): string {
   return `${prefix}_${Math.random().toString(16).slice(2)}_${Date.now().toString(16)}`;
 }
 
-export function useProjectState(licenseActive: boolean): readonly [State, Actions] {
+export type ProjectNoticeCode = 'campaign_audio_empty';
+
+export type ProjectStateOpts = {
+  onNotice?: (code: ProjectNoticeCode) => void;
+};
+
+export function useProjectState(licenseActive: boolean, opts?: ProjectStateOpts): readonly [State, Actions] {
   const api = getDndApi();
-  const [state, setState] = useState<State>({ projects: [], project: null, selectedSceneId: null });
+  const onNoticeRef = useRef(opts?.onNotice);
+  useEffect(() => {
+    onNoticeRef.current = opts?.onNotice;
+  }, [opts?.onNotice]);
+  const [state, setState] = useState<State>({
+    projects: [],
+    project: null,
+    selectedSceneId: null,
+    zipProgress: null,
+  });
   const projectRef = useRef<Project | null>(null);
+  /** Bumps on mutations / refresh; initial license load only applies if still current (avoids racing late list/get over newer state). */
+  const projectDataEpochRef = useRef(0);
   useEffect(() => {
     projectRef.current = state.project;
   }, [state.project]);
 
+  useEffect(() => {
+    const offImport = api.on(ipcChannels.project.importZipProgress, (evt) => {
+      const e = evt as unknown as { percent: number; stage: string; detail?: string };
+      setState((s) => ({
+        ...s,
+        zipProgress: {
+          kind: 'import',
+          percent: e.percent,
+          stage: e.stage,
+          ...(e.detail ? { detail: e.detail } : null),
+        },
+      }));
+      if (e.stage === 'done' || e.percent >= 100) {
+        setTimeout(() => setState((s) => ({ ...s, zipProgress: null })), 450);
+      }
+    });
+    const offExport = api.on(ipcChannels.project.exportZipProgress, (evt) => {
+      const e = evt as unknown as { percent: number; stage: string; detail?: string };
+      setState((s) => ({
+        ...s,
+        zipProgress: {
+          kind: 'export',
+          percent: e.percent,
+          stage: e.stage,
+          ...(e.detail ? { detail: e.detail } : null),
+        },
+      }));
+      if (e.stage === 'done' || e.percent >= 100) {
+        setTimeout(() => setState((s) => ({ ...s, zipProgress: null })), 450);
+      }
+    });
+    return () => {
+      offImport();
+      offExport();
+    };
+  }, [api]);
+
   const actions = useMemo<Actions>(() => {
     const refreshProjects = async () => {
+      projectDataEpochRef.current += 1;
       const res = await api.invoke(ipcChannels.project.list, {});
       setState((s) => ({ ...s, projects: res.projects }));
     };
@@ -75,13 +134,14 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
     };
 
     const openProject = async (id: ProjectId) => {
+      projectDataEpochRef.current += 1;
       const res = await api.invoke(ipcChannels.project.open, { projectId: id });
       setState((s) => ({ ...s, project: res.project, selectedSceneId: res.project.currentSceneId }));
     };
 
     const closeProject = async () => {
       setState((s) => ({ ...s, project: null, selectedSceneId: null }));
-      if (licenseActive) await refreshProjects();
+      await refreshProjects();
     };
 
     const createScene = async () => {
@@ -93,6 +153,7 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
         title: `Новая сцена`,
         description: '',
         previewAssetId: null,
+        previewThumbAssetId: null,
         previewAssetType: null,
         previewVideoAutostart: false,
         previewRotationDeg: 0,
@@ -125,12 +186,29 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
       await api.invoke(ipcChannels.project.setCurrentScene, { sceneId: id });
     };
 
+    const importCampaignAudio = async () => {
+      const res = await api.invoke(ipcChannels.project.importCampaignAudio, {});
+      if (res.canceled) return;
+      if (res.imported.length === 0) {
+        onNoticeRef.current?.('campaign_audio_empty');
+      }
+      setState((s) => ({ ...s, project: res.project }));
+      await refreshProjects();
+    };
+
+    const updateCampaignAudios = async (next: Project['campaignAudios']) => {
+      const res = await api.invoke(ipcChannels.project.updateCampaignAudios, { audios: next });
+      setState((s) => ({ ...s, project: res.project }));
+      await refreshProjects();
+    };
+
     const updateScene = async (
       sceneId: SceneId,
       patch: {
         title?: string;
         description?: string;
         previewAssetId?: AssetId | null;
+        previewThumbAssetId?: AssetId | null;
         previewAssetType?: 'image' | 'video' | null;
         previewVideoAutostart?: boolean;
         previewRotationDeg?: 0 | 90 | 180 | 270;
@@ -149,6 +227,9 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
           ...(patch.title !== undefined ? { title: patch.title } : null),
           ...(patch.description !== undefined ? { description: patch.description } : null),
           ...(patch.previewAssetId !== undefined ? { previewAssetId: patch.previewAssetId } : null),
+          ...(patch.previewThumbAssetId !== undefined
+            ? { previewThumbAssetId: patch.previewThumbAssetId }
+            : null),
           ...(patch.previewAssetType !== undefined ? { previewAssetType: patch.previewAssetType } : null),
           ...(patch.previewVideoAutostart !== undefined
             ? { previewVideoAutostart: patch.previewVideoAutostart }
@@ -276,6 +357,7 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
     };
 
     const deleteProject = async (projectId: ProjectId) => {
+      projectDataEpochRef.current += 1;
       await api.invoke(ipcChannels.project.deleteProject, { projectId });
       const listRes = await api.invoke(ipcChannels.project.list, {});
       const res = await api.invoke(ipcChannels.project.get, {});
@@ -294,6 +376,8 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
       closeProject,
       createScene,
       selectScene,
+      importCampaignAudio,
+      updateCampaignAudios,
       updateScene,
       updateConnections,
       importMediaToScene,
@@ -311,20 +395,37 @@ export function useProjectState(licenseActive: boolean): readonly [State, Action
       exportProject,
       deleteProject,
     };
-  }, [api, licenseActive]);
+  }, [api]);
 
   useEffect(() => {
+    const epoch = ++projectDataEpochRef.current;
+    void (async () => {
+      try {
+        const listRes = await api.invoke(ipcChannels.project.list, {});
+        if (projectDataEpochRef.current !== epoch) return;
         if (!licenseActive) {
-      queueMicrotask(() => {
-        setState({ projects: [], project: null, selectedSceneId: null });
-      });
+          setState((s) => ({
+            ...s,
+            projects: listRes.projects,
+            project: null,
+            selectedSceneId: null,
+          }));
           return;
         }
-    void (async () => {
-      const listRes = await api.invoke(ipcChannels.project.list, {});
         setState((s) => ({ ...s, projects: listRes.projects }));
         const res = await api.invoke(ipcChannels.project.get, {});
-      setState((s) => ({ ...s, project: res.project, selectedSceneId: res.project?.currentSceneId ?? null }));
+        if (projectDataEpochRef.current !== epoch) return;
+        setState((s) => ({
+          ...s,
+          project: res.project,
+          selectedSceneId: res.project?.currentSceneId ?? null,
+        }));
+      } catch {
+        if (projectDataEpochRef.current !== epoch) return;
+        if (!licenseActive) {
+          setState((s) => ({ ...s, project: null, selectedSceneId: null }));
+        }
+      }
     })();
   }, [licenseActive, api]);
 

app/renderer/shared/PresentationView.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 
 import { computeTimeSec } from '../../main/video/videoPlaybackStore';
 import type { SessionState } from '../../shared/ipc/contracts';
@@ -32,9 +32,39 @@ export function PresentationView({
   );
   const scene =
     session?.project && session.currentSceneId ? session.project.scenes[session.currentSceneId] : undefined;
-  const previewUrl = useAssetUrl(scene?.previewAssetId ?? null);
+  const originalUrl = useAssetUrl(scene?.previewAssetId ?? null);
+  const thumbUrl = useAssetUrl(scene?.previewThumbAssetId ?? null);
+  const [shownImageUrl, setShownImageUrl] = useState<string | null>(null);
   const rot = scene?.previewRotationDeg ?? 0;
 
+  useEffect(() => {
+    if (!scene) {
+      setShownImageUrl(null);
+      return;
+    }
+    if (scene.previewAssetType !== 'image') {
+      setShownImageUrl(null);
+      return;
+    }
+    // Show thumbnail instantly (if exists) to avoid stutter on slide switch, then swap to original when loaded.
+    setShownImageUrl(thumbUrl ?? originalUrl);
+    if (!thumbUrl || !originalUrl || thumbUrl === originalUrl) return;
+    let cancelled = false;
+    const img = new Image();
+    img.decoding = 'async';
+    img.onload = () => {
+      if (cancelled) return;
+      setShownImageUrl(originalUrl);
+    };
+    img.onerror = () => {
+      // keep thumbnail
+    };
+    img.src = originalUrl;
+    return () => {
+      cancelled = true;
+    };
+  }, [originalUrl, scene, thumbUrl]);
+
   useEffect(() => {
     const el = videoElRef.current;
     if (!el) return;
@@ -53,24 +83,33 @@ export function PresentationView({
     } else {
       el.pause();
     }
-  }, [scene?.previewAssetId, scene?.previewAssetType, vp]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- avoid reruns on 500ms heartbeats (serverNowMs-only updates)
+  }, [
+    scene?.previewAssetId,
+    scene?.previewAssetType,
+    originalUrl,
+    vp?.revision,
+    vp?.targetAssetId,
+    vp?.playing,
+    vp?.playbackRate,
+  ]);
 
   return (
     <div className={styles.root}>
-      {previewUrl && scene?.previewAssetType === 'image' ? (
+      {shownImageUrl && scene?.previewAssetType === 'image' ? (
         <div className={styles.fill}>
           <RotatedImage
-            url={previewUrl}
+            url={shownImageUrl}
             rotationDeg={rot}
             mode="contain"
             onContentRectChange={setContentRect}
           />
         </div>
-      ) : previewUrl && scene?.previewAssetType === 'video' ? (
+      ) : originalUrl && scene?.previewAssetType === 'video' ? (
         <video
           ref={videoElRef}
           className={styles.video}
-          src={previewUrl}
+          src={originalUrl}
           muted
           playsInline
           loop={false}

app/renderer/shared/RotatedImage.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useMemo, useRef, useState } from 'react';
+import React, { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 
 import styles from './RotatedImage.module.css';
 
@@ -9,6 +9,8 @@ type RotatedImageProps = {
   rotationDeg: 0 | 90 | 180 | 270;
   mode: Mode;
   alt?: string;
+  loading?: React.ImgHTMLAttributes<HTMLImageElement>['loading'];
+  decoding?: React.ImgHTMLAttributes<HTMLImageElement>['decoding'];
   /** Высота/ширина полностью контролируются родителем. */
   style?: React.CSSProperties;
   /** Прямоугольник видимого контента (contain/cover) внутри контейнера. */
@@ -22,13 +24,15 @@ function useElementSize<T extends HTMLElement>() {
   useEffect(() => {
     const el = ref.current;
     if (!el) return;
+    // clientWidth/Height — локальная вёрстка; getBoundingClientRect учитывает transform предков (React Flow zoom).
+    const readLayoutSize = () => {
+      setSize({ w: el.clientWidth, h: el.clientHeight });
+    };
     const ro = new ResizeObserver(() => {
-      const r = el.getBoundingClientRect();
-      setSize({ w: r.width, h: r.height });
+      readLayoutSize();
     });
     ro.observe(el);
-    const r = el.getBoundingClientRect();
-    setSize({ w: r.width, h: r.height });
+    readLayoutSize();
     return () => ro.disconnect();
   }, []);
 
@@ -40,23 +44,26 @@ export function RotatedImage({
   rotationDeg,
   mode,
   alt = '',
+  loading,
+  decoding,
   style,
   onContentRectChange,
 }: RotatedImageProps) {
   const [ref, size] = useElementSize<HTMLDivElement>();
   const [imgSize, setImgSize] = useState<{ w: number; h: number } | null>(null);
+  const imgRef = useRef<HTMLImageElement | null>(null);
 
-  useEffect(() => {
-    let cancelled = false;
-    const img = new Image();
-    img.onload = () => {
-      if (cancelled) return;
-      setImgSize({ w: img.naturalWidth || 1, h: img.naturalHeight || 1 });
-    };
-    img.src = url;
-    return () => {
-      cancelled = true;
-    };
+  useLayoutEffect(() => {
+    // If the image is served from cache, onLoad may fire before listeners attach.
+    // Reading from the <img> element itself is the most reliable source.
+    const el = imgRef.current;
+    if (!el) return;
+    if (!el.complete) return;
+    const w0 = el.naturalWidth || 0;
+    const h0 = el.naturalHeight || 0;
+    if (w0 <= 0 || h0 <= 0) return;
+    // eslint-disable-next-line react-hooks/set-state-in-effect, @typescript-eslint/prefer-optional-chain -- read cached <img> dimensions when onLoad may not fire
+    setImgSize((prev) => (prev && prev.w === w0 && prev.h === h0 ? prev : { w: w0, h: h0 }));
   }, [url]);
 
   const scale = useMemo(() => {
@@ -89,9 +96,23 @@ export function RotatedImage({
   return (
     <div ref={ref} className={styles.root} style={style}>
       <img
+        ref={imgRef}
         alt={alt}
         src={url}
+        loading={loading}
+        decoding={decoding}
         className={styles.img}
+        onLoad={(e) => {
+          const el = e.currentTarget;
+          const w0 = el.naturalWidth || 0;
+          const h0 = el.naturalHeight || 0;
+          if (w0 <= 0 || h0 <= 0) return;
+          setImgSize((prev) => {
+            // eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- rule can misfire on React state unions
+            if (prev && prev.w === w0 && prev.h === h0) return prev;
+            return { w: w0, h: h0 };
+          });
+        }}
         style={{
           width: w ?? '100%',
           height: h ?? '100%',

app/renderer/shared/video/useVideoPlaybackState.ts

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 
 import { ipcChannels } from '../../../shared/ipc/contracts';
 import type { VideoPlaybackEvent, VideoPlaybackState } from '../../../shared/types';
@@ -9,31 +9,36 @@ export function useVideoPlaybackState(): readonly [
   { dispatch: (event: VideoPlaybackEvent) => Promise<void> },
 ] {
   const api = getDndApi();
-  const [state, setState] = useState<VideoPlaybackState | null>(null);
-  const [timeOffsetMs, setTimeOffsetMs] = useState(0);
-  const [clientNowMs, setClientNowMs] = useState(() => Date.now());
-
-  useEffect(() => {
-    if (!state) return;
-    const id = window.setInterval(() => {
-      setClientNowMs(Date.now());
-    }, 250);
-    return () => window.clearInterval(id);
-  }, [state]);
+  const [playback, setPlayback] = useState<VideoPlaybackState | null>(null);
+  /** serverNowMs − Date.now() at last IPC sync; lets us compute a live clock without React timers. */
+  const timeOffsetMsRef = useRef(0);
 
   useEffect(() => {
     void api.invoke(ipcChannels.video.getState, {}).then((r) => {
-      setState(r.state);
-      setTimeOffsetMs(r.state.serverNowMs - Date.now());
+      timeOffsetMsRef.current = r.state.serverNowMs - Date.now();
+      setPlayback(r.state);
     });
     return api.on(ipcChannels.video.stateChanged, ({ state: next }) => {
-      setState(next);
-      setTimeOffsetMs(next.serverNowMs - Date.now());
+      timeOffsetMsRef.current = next.serverNowMs - Date.now();
+      setPlayback((prev) => {
+        if (prev?.revision === next.revision) return prev;
+        return next;
+      });
     });
   }, [api]);
 
+  const state = useMemo((): VideoPlaybackState | null => {
+    if (!playback) return null;
+    return {
+      ...playback,
+      get serverNowMs(): number {
+        return Date.now() + timeOffsetMsRef.current;
+      },
+    };
+  }, [playback]);
+
   return [
-    state ? { ...state, serverNowMs: clientNowMs + timeOffsetMs } : null,
+    state,
     {
       dispatch: async (event) => {
         await api.invoke(ipcChannels.video.dispatch, { event });

app/shared/ipc/contracts.ts

@@ -29,6 +29,8 @@ export const ipcChannels = {
     setCurrentScene: 'project.setCurrentScene',
     setCurrentGraphNode: 'project.setCurrentGraphNode',
     importMedia: 'project.importMedia',
+    importCampaignAudio: 'project.importCampaignAudio',
+    updateCampaignAudios: 'project.updateCampaignAudios',
     importScenePreview: 'project.importScenePreview',
     clearScenePreview: 'project.clearScenePreview',
     assetFileUrl: 'project.assetFileUrl',
@@ -43,11 +45,15 @@ export const ipcChannels = {
     importZip: 'project.importZip',
     exportZip: 'project.exportZip',
     deleteProject: 'project.deleteProject',
+    importZipProgress: 'project.importZipProgress',
+    exportZipProgress: 'project.exportZipProgress',
   },
   windows: {
     openMultiWindow: 'windows.openMultiWindow',
     closeMultiWindow: 'windows.closeMultiWindow',
     togglePresentationFullscreen: 'windows.togglePresentationFullscreen',
+    getMultiWindowState: 'windows.getMultiWindowState',
+    multiWindowStateChanged: 'windows.multiWindowStateChanged',
   },
   session: {
     stateChanged: 'session.stateChanged',
@@ -71,6 +77,23 @@ export const ipcChannels = {
   },
 } as const;
 
+export type ZipProgressEvent = {
+  kind: 'import' | 'export';
+  stage: 'copy' | 'unzip' | 'zip' | 'done';
+  percent: number; // 0..100
+  detail?: string;
+};
+
+export type IpcEventMap = {
+  [ipcChannels.session.stateChanged]: { state: SessionState };
+  [ipcChannels.effects.stateChanged]: { state: EffectsState };
+  [ipcChannels.video.stateChanged]: { state: VideoPlaybackState };
+  [ipcChannels.license.statusChanged]: { snapshot: LicenseSnapshot };
+  [ipcChannels.windows.multiWindowStateChanged]: { open: boolean };
+  [ipcChannels.project.importZipProgress]: ZipProgressEvent;
+  [ipcChannels.project.exportZipProgress]: ZipProgressEvent;
+};
+
 export type IpcInvokeMap = {
   [ipcChannels.app.quit]: {
     req: Record<string, never>;
@@ -120,6 +143,14 @@ export type IpcInvokeMap = {
     req: { sceneId: SceneId };
     res: { project: Project; imported: MediaAsset[] };
   };
+  [ipcChannels.project.importCampaignAudio]: {
+    req: Record<string, never>;
+    res: { canceled: boolean; project: Project; imported: MediaAsset[] };
+  };
+  [ipcChannels.project.updateCampaignAudios]: {
+    req: { audios: Project['campaignAudios'] };
+    res: { project: Project };
+  };
   [ipcChannels.project.importScenePreview]: {
     req: { sceneId: SceneId };
     res: { project: Project };
@@ -188,6 +219,10 @@ export type IpcInvokeMap = {
     req: Record<string, never>;
     res: { ok: true; isFullScreen: boolean };
   };
+  [ipcChannels.windows.getMultiWindowState]: {
+    req: Record<string, never>;
+    res: { open: boolean };
+  };
   [ipcChannels.effects.getState]: {
     req: Record<string, never>;
     res: { state: EffectsState };
@@ -227,7 +262,7 @@ export type SessionState = {
   currentSceneId: SceneId | null;
 };
 
-export type IpcEventMap = {
+export type LegacyIpcEventMap = {
   [ipcChannels.session.stateChanged]: { state: SessionState };
   [ipcChannels.effects.stateChanged]: { state: EffectsState };
   [ipcChannels.video.stateChanged]: { state: VideoPlaybackState };
@@ -239,6 +274,7 @@ export type ScenePatch = {
   description?: string;
   previewAssetId?: AssetId | null;
   previewAssetType?: 'image' | 'video' | null;
+  previewThumbAssetId?: AssetId | null;
   previewVideoAutostart?: boolean;
   previewRotationDeg?: 0 | 90 | 180 | 270;
   settings?: Partial<Scene['settings']>;

app/shared/types/domain.ts

@@ -84,6 +84,8 @@ export type Scene = {
   /** Превью ассет (изображение или видео). */
   previewAssetId: AssetId | null;
   previewAssetType: 'image' | 'video' | null;
+  /** Уменьшенное изображение для графа/списков; оригинал — в `previewAssetId`. */
+  previewThumbAssetId: AssetId | null;
   /** Для видео-превью: автозапуск (в редакторе/списках/на графе). */
   previewVideoAutostart: boolean;
   /** Поворот превью в градусах (0/90/180/270). */
@@ -112,6 +114,8 @@ export type Project = {
   meta: ProjectMeta;
   scenes: Record<SceneId, Scene>;
   assets: Record<AssetId, MediaAsset>;
+  /** Аудио кампании: играет в пульте на протяжении всей презентации, если в сцене нет своей музыки. */
+  campaignAudios: SceneAudioRef[];
   currentSceneId: SceneId | null;
   /** Текущая нода графа (важно, когда одна сцена имеет несколько нод). */
   currentGraphNodeId: GraphNodeId | null;

app/shared/video/videoPlaybackLoop.networkRegression.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+
+void test('video playback: control preview does not dispatch target.set on every render', () => {
+  const src = fs.readFileSync(
+    path.join(root, 'app', 'renderer', 'control', 'ControlScenePreview.tsx'),
+    'utf8',
+  );
+  // Регресс: зависимость `[... , scene, ...]` заставляла эффект с `target.set` срабатывать постоянно,
+  // сбрасывая видео (доля секунды проигрывается и начинается сначала).
+  assert.doesNotMatch(src, /\]\s*,\s*\[\s*[^\]]*\bscene\b/);
+});

app/shared/video/videoPlaybackPerf.networkRegression.test.ts

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+
+void test('video playback: renderer hooks/components do not tick React each frame', () => {
+  const hookSrc = fs.readFileSync(
+    path.join(root, 'app', 'renderer', 'shared', 'video', 'useVideoPlaybackState.ts'),
+    'utf8',
+  );
+  // Регресс: раньше был setInterval(250ms) для clientNowMs, который заставлял перерисовываться окна.
+  assert.doesNotMatch(hookSrc, /\bsetInterval\s*\(/);
+
+  const previewSrc = fs.readFileSync(
+    path.join(root, 'app', 'renderer', 'control', 'ControlScenePreview.tsx'),
+    'utf8',
+  );
+  // Регресс: раньше был RAF loop с setState на каждом кадре.
+  assert.doesNotMatch(previewSrc, /\brequestAnimationFrame\s*\(\s*loop\s*\)/);
+  assert.doesNotMatch(previewSrc, /\brequestAnimationFrame\s*\(\s*loop\b/);
+});

docs/GITEA_AUTO_UPDATE.md

@@ -0,0 +1,417 @@
+# Автообновление через Gitea (приватный код + публичный feed)
+
+Исходники остаются в **закрытом** репозитории с игрой. Файлы обновлений (`latest.yml`, установщики) лежат в **отдельном публичном** репозитории — по HTTPS их скачивает `electron-updater`.
+
+## Твой публичный репозиторий (уже есть)
+
+- Клон: `https://git.mailib.ru/ifontosh/DndGamePlayerUpdates.git`
+- Владелец/репо для секретов: **`ifontosh/DndGamePlayerUpdates`**
+- Базовый URL feed (вшивается в сборку и должен совпадать с secret **`DND_UPDATE_FEED_URL`**):
+
+  **`https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/`**
+
+  Обрати внимание: слово **`branch`** в пути — это часть URL Gitea, не имя ветки. Имя ветки — в конце: **`updates`**.
+
+В `package.json` уже указан этот же `build.publish.url` (для локального `npm run pack` и метаданных electron-builder).
+
+---
+
+## Шаг 0 — репозиторий сейчас пустой (важно)
+
+На странице репо написано, что **контента нет**. Пока нет **ни одного коммита**, CI не сможет сделать `git clone`.
+
+Сделай так (любой способ):
+
+1. На сайте открой `ifontosh/DndGamePlayerUpdates` → кнопка вроде **«Инициализировать репозиторий»** / **«Добавить файл»** → создай файл `README.md` с парой строк и закоммить **в ветку по умолчанию** (часто `main`).
+2. Либо с компьютера:
+
+```bash
+git clone https://git.mailib.ru/ifontosh/DndGamePlayerUpdates.git
+cd DndGamePlayerUpdates
+echo "# DndGamePlayer updates feed" > README.md
+git add README.md
+git commit -m "init"
+git push origin main
+```
+
+(Если ветка по умолчанию у тебя `master` — подставь её вместо `main`.)
+
+После этого репозиторий **не пустой** — workflow сможет клонировать и создать ветку **`updates`**.
+
+---
+
+## Шаг 1 — токен для записи в публичный репозиторий
+
+Нужен **персональный токен** (PAT), с которым CI сможет **пушить** в `DndGamePlayerUpdates`.
+
+В Gitea на русском обычно так (названия могут чуть отличаться в твоей теме):
+
+1. Вверху справа **аватар** → **Настройки** (или «Параметры»).
+2. Слева найди раздел вроде **«Приложения»** / **«Токены доступа»** / **«Токены»** (в англ. интерфейсе: **Settings → Applications → Generate New Token**).
+3. Создай новый токен:
+   - имя: например `dnd-release-ci`;
+   - права: достаточно доступа к репозиторию с **записью** (для пуша в `DndGamePlayerUpdates`). Если есть галочки — включи что-то вроде **«Запись в репозиторий»** / **write:repository** / полный доступ к репо.
+4. **Скопируй токен один раз** и сохрани в менеджере паролей — потом Gitea его не покажет.
+
+Этот токен пойдёт в secret **`DND_UPDATES_PUSH_TOKEN`** (см. ниже). **Не вставляй токен в код и не коммить его.**
+
+> На **git.mailib.ru** имена секретов **не могут начинаться с `GITEA_`** (зарезервировано). Поэтому в workflow используются `DND_UPDATES_*`, а не `GITEA_*`.
+
+---
+
+## Шаг 2 — секреты в приватном репозитории с кодом (`dnd_player`)
+
+Открой **приватный** репозиторий, где лежит исходник игры (не `DndGamePlayerUpdates`).
+
+Дальше (русский Gitea 1.26, ориентир по меню):
+
+1. Вкладка **«Настройки»** репозитория (вверху рядом с «Код», «Задачи» — иногда шестерёнка **«Настройки»**).
+2. Слева раздел **«Секреты»** / **«Действия»** → **«Секреты»** (в англ. UI: **Settings → Actions → Secrets**). Если видишь **«Переменные»** — секреты обычно рядом; нам нужны именно **секреты** (скрытые значения).
+
+Добавь **четыре** секрета (имя **точно** как в таблице — workflow их читает):
+
+| Имя секрета              | Что вписать в значение                                                                                   |
+| ------------------------ | -------------------------------------------------------------------------------------------------------- |
+| `DND_UPDATE_FEED_URL`    | `https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/` (обязательно **слэш в конце**) |
+| `DND_UPDATES_SERVER`     | `https://git.mailib.ru` (**без** слэша в конце)                                                          |
+| `UPDATES_REPO`           | `ifontosh/DndGamePlayerUpdates`                                                                          |
+| `DND_UPDATES_PUSH_TOKEN` | токен из шага 1 (одна длинная строка)                                                                    |
+
+Сохрани каждый секрет кнопкой вроде **«Сохранить»** / **«Добавить»**.
+
+Если раньше создавал секреты `GITEA_SERVER` / `GITEA_TOKEN` — их workflow **не читает**; удали или оставь, но **обязательно** заведи новые имена из таблицы.
+
+---
+
+## Раннер act_runner — без этого «Всего: 0» и сборки не будет
+
+Gitea **не запускает** workflow на своём процессе: нужна **отдельная машина** (VPS, сервер или **WSL2 Ubuntu** на твоём ПК), на которой крутится **[act_runner](https://docs.gitea.com/usage/actions/act-runner)** и которая видит `git.mailib.ru` по сети.
+
+Пока в **«Настройки» → «Действия» → «Раннеры»** написано **«Всего: 0»**, workflow **висит в ожидании** — нечему выполнять шаги.
+
+### Важно: это не тот токен, что для пуша в `DndGamePlayerUpdates`
+
+| Токен                                               | Где взять                                                                  | Зачем                                                                         |
+| --------------------------------------------------- | -------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| **Регистрация раннера** (короткая случайная строка) | **Настройки репо** → **Действия** → **Раннеры** → **Создать новый раннер** | Только для команды **`act_runner register`** (один раз на каталог с раннером) |
+| **`DND_UPDATES_PUSH_TOKEN`** (PAT)                  | **Аватар** → **Настройки пользователя** → токены доступа                   | Для CI: пуш в публичный репо обновлений (см. шаг 1 выше)                      |
+
+Если Gitea показала **только длинную строку** — это почти наверняка **токен регистрации раннера**. URL инстанса ты знаешь сам: **`https://git.mailib.ru`** (без пути к репозиторию).
+
+### Требования к машине под наш `release.yml`
+
+В workflow для job **`ubuntu-22.04`** идут **`sudo apt-get`** (пакеты **`nsis`**, **`wine64`**) на **Linux**. Multiarch **i386** намеренно не включается — на Debian с репозиториями только под amd64 (nginx, sury и т.п.) установка **wine32** часто падает с «unmet dependencies». После установки **`wine64`** в CI создаётся скрипт **`/usr/local/bin/wine`** с **`exec` по полному пути** к **`wine64`** (в job у act_runner иногда пустой/урезанный `PATH`, тогда имя `wine64` без пути не находится). electron-builder проверяет именно команду **`wine`** в `PATH`. Поэтому:
+
+- Нужен **Linux x86_64** (идеально **Ubuntu 22.04**), либо **WSL2** с Ubuntu 22.04 на Windows.
+- Запускать раннер на «голом» Windows с меткой `ubuntu-22.04` **бессмысленно** — шаги с `apt` не выполнятся.
+
+### Шаг A — получить токен регистрации в Gitea
+
+1. Открой репозиторий с кодом (**DndGamePlayer** или как он у тебя называется).
+2. **Настройки** → **Действия** → **Раннеры** → **Создать новый раннер**.
+3. Выбери тип **репозитория** (repository runner), ОС **Linux**.
+4. **Скопируй токен** (и при желании подсказку с URL инстанса, если она есть). Команду из мастера можно **не копировать**, если ниже удобнее готовая.
+
+### Шаг B — скачать act_runner (бинарник)
+
+Официальные сборки: **[релизы act_runner на gitea.com](https://gitea.com/gitea/act_runner/releases)**.
+
+1. Открой страницу релизов и посмотри **последний стабильный** тег, например **`v1.0.2`**.
+2. В списке файлов скачай **`gitea-runner-ВЕРСИЯ-linux-amd64`** — это один исполняемый файл **без** расширения `.zip` (не путай с `darwin` / `arm64`, если у тебя обычный ПК/сервер Intel/AMD).
+
+**Прямая ссылка (подставь свою версию из релиза):**
+
+`https://gitea.com/gitea/act_runner/releases/download/v1.0.2/gitea-runner-1.0.2-linux-amd64`
+
+В URL после `download/` идёт тег с **`v`**, в имени файла версия **без `v`**.
+
+**Скачать с Linux/WSL одной командой** (замени `1.0.2` на актуальную версию с сайта):
+
+```bash
+mkdir -p ~/gitea-act-runner && cd ~/gitea-act-runner
+VERSION="1.0.2"
+curl -fL -o act_runner "https://gitea.com/gitea/act_runner/releases/download/v${VERSION}/gitea-runner-${VERSION}-linux-amd64"
+chmod +x act_runner
+./act_runner --version
+```
+
+Если `curl` ругается на сертификат — обнови CA или скачай тот же файл через браузер и положи в папку, затем `chmod +x`.
+
+### Шаг C — регистрация (подставь свой токен)
+
+В каталоге, где лежит `act_runner`, выполни **одну** команду (токен — тот, что выдала Gitea при создании раннера):
+
+```bash
+cd ~/gitea-act-runner
+
+./act_runner register --no-interactive \
+  --instance "https://git.mailib.ru" \
+  --token "ВСТАВЬ_СЮДА_ТОКЕН_ИЗ_МАСТЕРА_GITEA" \
+  --name "dnd-release-runner" \
+  --labels "ubuntu-22.04:host"
+```
+
+Пояснения:
+
+- **`--instance`** — корень твоего Gitea (**без** `/ifontosh/...`).
+- **`--labels "ubuntu-22.04:host"`** — job в **`.gitea/workflows/release.yml`** имеет `runs-on: ubuntu-22.04`, а **`:host`** означает выполнение **на самой машине**, с настоящим `apt` и Wine (см. [документацию по меткам](https://docs.gitea.com/usage/actions/act-runner#labels)). Если при регистрации оставить **дефолтные** метки с **`docker://`**, шаги тоже могут сработать, но образ другой; для предсказуемости лучше **`ubuntu-22.04:host`** на чистой Ubuntu 22.04.
+- После успешной регистрации в этой папке появится файл **`.runner`** — его не удаляй и не коммить.
+
+Если Gitea пишет ошибку регистрации — часто неверный **токен** (устарел после «сброса» в UI) или выбран не тот уровень (инстанс/организация/репозиторий). Создай раннера заново и возьми **новый** токен.
+
+### Шаг D — запуск вручную (для проверки)
+
+В той же папке:
+
+```bash
+./act_runner daemon
+```
+
+Окно терминала должно остаться **открытым**. Остановка — `Ctrl+C`. Когда убедишься, что в Gitea раннер **online**, лучше перейти на **systemd** (шаг ниже).
+
+### Шаг D1 — systemd: автозапуск после перезагрузки (подробно)
+
+Идея: **systemd** сам поднимает `act_runner daemon` при загрузке системы и перезапускает процесс при падении. Рабочая директория должна быть **та же**, где лежат **`act_runner`** и зарегистрированный файл **`.runner`** (обычно `~/gitea-act-runner`).
+
+#### 0) Подготовка
+
+1. Регистрация (**шаг C**) уже выполнена, в каталоге есть **`.runner`**.
+2. Узнай **точный путь** к каталогу (systemd не понимает `~`):
+
+```bash
+cd ~/gitea-act-runner && pwd
+```
+
+Запомни вывод, например **`/home/ivan/gitea-act-runner`**. Имя пользователя Linux:
+
+```bash
+whoami
+```
+
+Дальше в примерах: **`/home/ivan/gitea-act-runner`** и пользователь **`ivan`** — замени на свои.
+
+#### 1) Останови ручной запуск
+
+Если где-то в терминале уже крутится `./act_runner daemon` — заверши **Ctrl+C**, иначе два процесса будут мешать друг другу.
+
+#### 2) Создай unit-файл службы
+
+На **VPS / обычной Ubuntu** с правами root:
+
+```bash
+sudo nano /etc/systemd/system/gitea-act-runner.service
+```
+
+Вставь текст **целиком** (подставь свои `User`, `Group`, `WorkingDirectory`, `ExecStart`):
+
+```ini
+[Unit]
+Description=Gitea Actions act_runner
+Documentation=https://docs.gitea.com/usage/actions/act-runner
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=ivan
+Group=ivan
+WorkingDirectory=/home/ivan/gitea-act-runner
+ExecStart=/home/ivan/gitea-act-runner/act_runner daemon
+Restart=always
+RestartSec=10
+
+# Логи в journald (см. ниже как читать)
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Сохрани файл: в **nano** — **Ctrl+O**, Enter, **Ctrl+X**.
+
+Пояснения:
+
+- **`User` / `Group`** — под этим пользователем ты делал `register` и владеешь папкой (проверка: `ls -la ~/gitea-act-runner` — владелец должен совпадать).
+- **`WorkingDirectory`** — каталог с **`.runner`**; без него раннер может не найти регистрацию.
+- **`ExecStart`** — полный путь к бинарнику **`act_runner`** (тот, что скачал и сделал `chmod +x`).
+- Блок **`After=network-online.target`** — старт после сети (удобно для `git`/`npm` в CI). Если вдруг зависнет старт из‑за сетевого таргета, можно временно заменить на **`After=network.target`**.
+
+Официальный пример с отдельным пользователем `act_runner` и `config.yaml`: [Start the runner with Systemd](https://docs.gitea.com/usage/actions/act-runner#start-the-runner-with-systemd) — у нас проще: один пользователь и без отдельного `config.yaml`, пока дефолты устраивают.
+
+#### 3) Включи и запусти службу
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable gitea-act-runner.service
+sudo systemctl start gitea-act-runner.service
+sudo systemctl status gitea-act-runner.service
+```
+
+В **`status`** должно быть **`active (running)`** зелёным. Если **`failed`** — смотри лог (шаг 5).
+
+Полезные команды:
+
+| Действие              | Команда                                                       |
+| --------------------- | ------------------------------------------------------------- |
+| Остановить            | `sudo systemctl stop gitea-act-runner`                        |
+| Запустить снова       | `sudo systemctl start gitea-act-runner`                       |
+| Перезапуск            | `sudo systemctl restart gitea-act-runner`                     |
+| Выключить автозапуск  | `sudo systemctl disable gitea-act-runner`                     |
+| Проверка после ребута | перезагрузи машину, затем `systemctl status gitea-act-runner` |
+
+#### 4) Проверка в Gitea
+
+Как в **шаге E**: раннер снова **online** (иногда 10–30 секунд после `start`).
+
+#### 5) Логи, если что-то не так
+
+```bash
+sudo journalctl -u gitea-act-runner -e --no-pager
+```
+
+В реальном времени:
+
+```bash
+sudo journalctl -u gitea-act-runner -f
+```
+
+Типичные ошибки: неверный **`User`** (нет прав на каталог), **`WorkingDirectory`** не тот (нет **`.runner`**), бинарник не исполняемый (`chmod +x`), или старый процесс `act_runner` ещё запущен вручную.
+
+#### WSL2 (Ubuntu в Windows)
+
+Если раннер стоит **внутри WSL2**:
+
+1. На современных WSL **systemd уже может быть включён**. Проверка: `systemctl status` — без ошибки «running in chroot».
+2. Если `systemctl` недоступен: в файле **`/etc/wsl.conf`** внутри дистрибутива добавь блок **`[boot]`** с **`systemd=true`**, затем из **PowerShell** Windows выполни **`wsl --shutdown`**, снова зайди в Ubuntu и повтори шаги 2–3. Подробнее: [документация Microsoft про systemd в WSL](https://learn.microsoft.com/en-us/windows/wsl/systemd).
+
+После **`wsl --shutdown`** раннер на WSL не работает, пока ты снова не откроешь WSL (это нормально для «домашнего» CI).
+
+### Шаг E — проверка в веб-интерфейсе
+
+Обнови **Настройки → Действия → Раннеры**: должен быть **1** раннер, статус **online**. У него в метках должно быть что-то вроде **`ubuntu-22.04`** (в связке с **host**).
+
+### Если у тебя только Windows
+
+Установи **WSL2** и дистрибутив **Ubuntu 22.04**, открой терминал Ubuntu и выполни шаги B–D **там** (это уже Linux). Файловую систему Windows из WSL видно как `/mnt/d/...`, но проще держать каталог раннера в домашнем каталоге Linux (`~/gitea-act-runner`).
+
+Официальная документация: [Gitea — Act Runner](https://docs.gitea.com/usage/actions/act-runner).
+
+Если раннер заводит **админ инстанса** — логика та же: раннер должен быть **online** и иметь метку, подходящую под **`runs-on`** в `release.yml` (сейчас **`ubuntu-22.04`**; при **`ubuntu-22.04:host`** в Gitea это сопоставляется с `runs-on: ubuntu-22.04`).
+
+---
+
+## Шаг 3 — включить Actions (если ещё не включены)
+
+1. В том же **приватном** репозитории: **«Настройки»**.
+2. Раздел **«Действия»** / **«Actions»** — включи использование Actions для этого репозитория, если Gitea это спрашивает.
+3. Убедись, что в корне репозитория есть файл **`.gitea/workflows/release.yml`** (он уже в проекте `dnd_player`).
+
+Бегунки Gitea должны иметь доступ в интернет (для `npm ci`, `actions/checkout` и т.д.) — это настраивает админ сервера.
+
+### Метки `runs-on` (если раннер уже есть, но job не берётся)
+
+- В списке раннеров посмотри **метки** у online-раннера.
+- В **`.gitea/workflows/release.yml`** в `runs-on:` должна совпадать **именно метка `ubuntu-22.04`** (Gitea сопоставляет её и с **`ubuntu-22.04:host`**, и с **`ubuntu-22.04:docker://...`** — см. [Labels](https://docs.gitea.com/usage/actions/act-runner#labels) в документации act_runner).
+- Если при регистрации указал только **`self-hosted`** — добавь **`ubuntu-22.04:host`** (или поменяй `runs-on` в workflow на твои метки и закоммить).
+
+Сборка **Windows (NSIS)** в CI идёт **на Linux**: нативный **`nsis`** (`makensis`) + **`wine64`** и обёртка **`wine`→`wine64`** (без **wine32**/i386 — см. `release.yml`). Отдельная **macOS**-сборка в workflow отключена, пока нет Mac-раннера (см. комментарии в `release.yml`).
+
+---
+
+## Шаг 4 — выпуск версии
+
+1. В `package.json` версия должна совпасть с тегом (workflow при пуше тега делает `npm version` из имени тега — удобно).
+2. Закоммить все изменения в **приватный** репо, затем:
+
+```bash
+git tag v1.0.1
+git push origin main
+git push origin v1.0.1
+```
+
+(ветка может быть не `main` — подставь свою.)
+
+3. Открой в Gitea **«Действия»** у приватного репо — должен появиться запуск **Release**. Дождись успеха job **`release`** (после появления раннера, см. раздел выше).
+
+4. После успеха открой **публичный** `DndGamePlayerUpdates` → ветка **`updates`** — в корне должны появиться `latest.yml`, установщики и т.д.
+
+---
+
+## Контрольный чеклист
+
+1. **`package.json` → `build.publish.url`** =  
+   `https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/`  
+   Совпадает с **`DND_UPDATE_FEED_URL`** (со слэшем в конце).
+2. В **DndGamePlayerUpdates** есть хотя бы один коммит (не пустой репо).
+3. В приватном репо заданы **все четыре** секрета из таблицы шага 2 (имена **не** начинаются с `GITEA_`).
+4. В репо с кодом есть **`.gitea/workflows/release.yml`**.
+5. Релиз: пуш тега `v*` → в Actions job **`release`** (сборка Win + push feed в одном job, без GitHub `upload-artifact`); в публичном репо появляется ветка **`updates`** с `latest.yml` и установщиками (нужен online-раннер, см. раздел про act_runner).
+6. В приложении: обновления только **`app.isPackaged`** и при **активной лицензии** (см. `app/main/update/installAutoUpdater.ts`).
+
+---
+
+## Поведение приложения
+
+- Проверка только в **собранной** установке (`app.isPackaged`).
+- Только если **лицензия активна**.
+- Первый запрос примерно через **12 с** после старта; при смене лицензии — снова (не чаще **30 с**).
+- Для отладки можно задать переменную окружения **`DND_UPDATE_FEED_URL`** при запуске `.exe` — переопределит feed.
+
+Подпись кода в CI отключена: `CSC_IDENTITY_AUTO_DISCOVERY=false`.
+
+---
+
+## Локальная отладка feed
+
+Запуск установленного приложения с другим URL (без пересборки): задать **`DND_UPDATE_FEED_URL`** в ярлыке или системных переменных окружения.
+
+---
+
+## Как сделать так, чтобы ассистент в Cursor мог «выпустить релиз»
+
+У ассистента **нет своего аккаунта** на `git.mailib.ru`. Релиз = **появление тега `v*`** на нужном коммите в **приватном** репозитории с кодом → Gitea Actions собирает и пушит feed. Ниже два рабочих варианта.
+
+### Вариант A — Gitea MCP (удобно из чата)
+
+У тебя уже подключён MCP **user-gitea-mailib** с инструментом **`create_tag`**: по API создаётся тег на сервере (аналог `git tag` + `git push` тега).
+
+**Что сделать один раз:**
+
+1. В Cursor MCP для Gitea должен быть **включён и залогинен** под учёткой, у которой есть право **создавать теги** в приватном репо с `dnd_player`.
+2. Знать **`owner`** и **`repo`** этого репозитория (как в URL: `https://git.mailib.ru/OWNER/REPO`).
+
+**Как просить в чате:**  
+«Создай тег `v1.0.2` в репозитории `OWNER/REPO` с целевой веткой `main`» (или укажи SHA коммита). Перед этим **весь код релиза уже должен быть запушен** в эту ветку — тег вешается на последний коммит (или на явный `target`).
+
+После создания тега зайди в **Действия** репозитория и проверь workflow **Release**.
+
+_(Отдельно: `create_release` в MCP создаёт **запись релиза** на Gitea; сборку у тебя запускает именно **тег** и `release.yml`.)_
+
+### Вариант B — команды `git` в терминале Cursor
+
+Ассистент может выполнить у тебя локально:
+
+```bash
+git fetch origin
+git tag v1.0.2 origin/main   # или другая ветка / коммит
+git push origin v1.0.2
+```
+
+**Что сделать один раз:**
+
+1. Чтобы `git push` **не спрашивал пароль** каждый раз: настроить **учётные данные** (Windows: диспетчер учётных данных / `git credential-manager`; либо **SSH-ключ** и remote `git@git.mailib.ru:...`).
+2. Убедиться, что из того же окружения, где работает Cursor, `git push` в приватный репо уже проходил успешно.
+
+Тогда в чате можно написать: «Поставь тег `v1.0.2` на `origin/main` и запушь тег» — ассистент выполнит команды в `dnd_player`.
+
+### Ограничения
+
+- Ассистент **не видит** твои пароли и не обходит Gitea: всё упирается в **MCP-токен** или **твои локальные git credentials**.
+- Если MCP отключён и git без настроенного доступа — релиз тегом придётся пушить **тебе** вручную (как в шаге 4 выше).
+
+---
+
+## Про коммит и пуш кода (не тег)
+
+Закоммитить и запушить **изменения в файлах** ассистент может через те же механизмы: либо ты делаешь `git push` после правок, либо настроенный **git** / отдельный скрипт. Без доступа к remote ассистент только правит файлы в рабочей копии.

docs/editor-performance-plan.md

@@ -0,0 +1,90 @@
+## План оптимизации редактора (агент)
+
+Цель: убрать лаги визуального редактора на проектах 20+ сцен (пан/зум графа, drag, создание связей) и снизить влияние тяжёлых ассетов (изображения/видео) на редактор.
+
+### Этап 0 — Замер и воспроизведение
+
+- **Сценарии**: пан/зум графа, drag узлов, создание/удаление связей, работа со списком сцен, редактирование свойств сцены.
+- **Сбор данных**: DevTools Performance (CPU/Rendering), наблюдение нагрузки (GPU/Video Decode), фиксация “где именно тормозит”.
+
+**Результат**: подтверждены основные “горячие места” (граф/рендер/медиа/IPC).
+
+---
+
+### Этап 1 — Быстрый выигрыш без изменения формата проекта (минимально и безопасно)
+
+#### 1.1 Lazy/async для изображений в карточках
+
+- Для `<img>` в карточках графа и списка сцен применить:
+  - `loading="lazy"`
+  - `decoding="async"`
+- Убедиться, что контейнеры превью не провоцируют лишние перерасчёты размеров/перерисовки.
+
+#### 1.2 Снижение перерисовок графа (минимально и безопасно)
+
+- **Стабилизировать входные данные** графа:
+  - вместо передачи “всего `project.scenes`” подготовить “лёгкое” представление сцен, содержащее только поля, нужные для карточек (title, preview refs, флаги).
+- Цель: изменения в инспекторе (описание/аудио/и т.п.) не должны заставлять ReactFlow пересобирать все `nodes/edges`.
+
+#### 1.3 Ограничить частоту тяжёлых обновлений при действиях в графе
+
+- Проверить, чтобы обновления позиций/связей не вызывали лишних “полных” пересборок и не инициировали дорогие операции чаще, чем нужно.
+
+**Критерий готовности**: на проекте с 22 сценами взаимодействие с графом заметно плавнее, задержка при создании связей снижается.
+
+---
+
+### Этап 2 — Самое эффективное: thumbnails вместо оригиналов
+
+#### 2.1 Модель данных для миниатюр
+
+- Для превью/медиа хранить:
+  - **original asset** (как сейчас) — для просмотра/презентации
+  - **thumbnail asset** — для графа и списков
+- Миниатюра — отдельный asset в `project.assets`, связанный с оригиналом (через поле в сцене или метаданные asset).
+
+#### 2.2 Генерация thumbnail при импорте изображений
+
+- При импорте превью/изображений:
+  - ресайз до ~**320px по длинной стороне**
+  - кодек: **WebP** (или JPEG)
+- Сохранять thumbnail как отдельный файл/asset.
+
+#### 2.3 Генерация thumbnail для видео по первому кадру
+
+- При импорте видео:
+  - извлечь кадр (0.5–1s если на 0s чёрный)
+  - сохранить как **image/webp/jpeg** thumbnail
+- В UI использовать thumbnail как постер для карточек.
+
+#### 2.4 Использование thumbnails в UI
+
+- **Граф сцен**: показывает только thumbnail.
+- **Список сцен**: показывает только thumbnail.
+- **Инспектор**: по желанию — только thumbnail.
+- **Презентация/просмотр**: оригинал.
+
+#### 2.5 Обратная совместимость
+
+- Старые проекты без thumbnails:
+  - “ленивая” догенерация в фоне при первом отображении,
+  - или отдельная команда “Оптимизировать проект (создать миниатюры)”.
+
+**Критерий готовности**: тяжёлые исходники почти не влияют на редактор; масштабируемость по сценам растёт.
+
+---
+
+### Этап 3 — Дополнительные ускорения (по ситуации)
+
+- **3.1 Виртуализация списка сцен** (если список остаётся тяжёлым при 50+ сценах).
+- **3.2 Дифф‑обновление `nodes/edges`** в ReactFlow вместо “пересборки целиком” (для 100+ сцен).
+- **3.3 LOD‑поведение**: при сильном зуме карточки упрощаются (только заголовок/иконки), thumbnails отключаются.
+
+---
+
+### Приоритизация
+
+- **Сразу**: Этап 1.
+- **Максимальный эффект**: Этап 2.
+- **Для больших проектов**: Этап 3.
+

eslint.config.js

@@ -12,7 +12,17 @@ const tsProject = ['./tsconfig.eslint.json'];
 
 export default tseslint.config(
   {
-    ignores: ['dist/**', 'release/**', 'node_modules/**', '.cursor/**', 'scripts/**', 'eslint.config.js'],
+    ignores: [
+      'dist/**',
+      'release/**',
+      'node_modules/**',
+      '.cursor/**',
+      'scripts/**',
+      'eslint.config.js',
+      // Plain ESM; shared with sibling ../project-converter (not parsed as TS project file).
+      'app/main/project/optimizeImageImport.lib.mjs',
+      'app/main/project/optimizeImageImport.lib.d.mts',
+    ],
   },
   js.configs.recommended,
   ...tseslint.configs.strictTypeChecked,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "DndGamePlayer",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "DNDGamePlayer — редактор и проигрыватель игр",
   "main": "dist/main/index.cjs",
   "scripts": {
@@ -10,9 +10,10 @@
     "build:obfuscate": "node scripts/build.mjs --production --obfuscate",
     "lint": "eslint . --max-warnings 0",
     "typecheck": "tsc -p tsconfig.eslint.json --noEmit",
-    "test": "tsx --test app/renderer/shared/ui/controls.tooltip.test.ts app/shared/ipc/contracts.mediaRemoval.test.ts app/shared/effectEraserHitTest.test.ts app/renderer/control/controlApp.effectsPanel.test.ts app/renderer/shared/effects/PxiEffectsOverlay.pointer.test.ts app/main/windows/createWindows.editorClose.test.ts app/main/windows/bootWindow.test.ts app/main/effects/effectsStore.test.ts app/main/project/assetPrune.test.ts app/main/project/zipRead.test.ts app/shared/package.build.test.ts app/shared/license/canonicalJson.test.ts app/shared/license/productKey.test.ts app/shared/license/licenseService.networkRegression.test.ts app/main/license/verifyLicenseToken.test.ts && node --test scripts/build-env.test.mjs scripts/obfuscate-main.test.mjs",
+    "test": "tsx --test app/renderer/shared/ui/controls.tooltip.test.ts app/renderer/editor/state/projectState.race.test.ts app/renderer/editor/graph/sceneCardById.test.ts app/renderer/editor/i18n/editorMessages.locale.test.ts app/shared/ipc/contracts.mediaRemoval.test.ts app/shared/effectEraserHitTest.test.ts app/renderer/control/controlApp.effectsPanel.test.ts app/renderer/shared/effects/PxiEffectsOverlay.pointer.test.ts app/main/windows/createWindows.editorClose.test.ts app/main/windows/bootWindow.test.ts app/main/effects/effectsStore.test.ts app/main/project/assetPrune.test.ts app/main/project/optimizeImageImport.test.ts app/main/project/scenePreviewThumbnail.test.ts app/main/project/fsRetry.test.ts app/main/project/zipRead.test.ts app/main/project/replaceFileAtomic.test.ts app/main/project/zipStore.legacyContract.test.ts app/shared/package.build.test.ts app/shared/license/canonicalJson.test.ts app/shared/license/productKey.test.ts app/shared/license/licenseService.networkRegression.test.ts app/shared/video/videoPlaybackPerf.networkRegression.test.ts app/shared/video/videoPlaybackLoop.networkRegression.test.ts app/main/license/verifyLicenseToken.test.ts && node --test scripts/build-env.test.mjs scripts/obfuscate-main.test.mjs",
     "format": "prettier . --check",
     "format:write": "prettier . --write",
+    "postinstall": "patch-package",
     "release:info": "node scripts/print-release-info.mjs",
     "pack": "npm run build && node scripts/release-win-prep.mjs && electron-builder",
     "pack:dir": "npm run build && node scripts/release-win-prep.mjs && electron-builder --dir",
@@ -25,10 +26,13 @@
   "type": "module",
   "dependencies": {
     "@fontsource/inter": "^5.2.8",
+    "electron-updater": "^6.6.2",
+    "ffmpeg-static": "^5.3.0",
     "pixi.js": "^8.18.1",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
-    "reactflow": "^11.11.4"
+    "reactflow": "^11.11.4",
+    "sharp": "^0.34.5"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.4",
@@ -54,6 +58,7 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-unicorn": "^64.0.0",
     "javascript-obfuscator": "^4.2.2",
+    "patch-package": "^8.0.1",
     "prettier": "^3.8.3",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
@@ -76,7 +81,10 @@
     ],
     "asar": true,
     "asarUnpack": [
-      "dist/preload/**"
+      "dist/preload/**",
+      "node_modules/sharp/**",
+      "node_modules/@img/**",
+      "node_modules/ffmpeg-static/**"
     ],
     "mac": {
       "category": "public.app-category.games",
@@ -118,7 +126,12 @@
     "nsis": {
       "oneClick": false,
       "allowToChangeInstallationDirectory": true,
-      "deleteAppDataOnUninstall": false
+      "deleteAppDataOnUninstall": false,
+      "artifactName": "${productName}-Setup-${version}.${ext}"
+    },
+    "publish": {
+      "provider": "generic",
+      "url": "https://git.mailib.ru/ifontosh/DndGamePlayerUpdates/raw/branch/updates/"
     }
   }
 }

patches/app-builder-lib+26.8.1.patch

@@ -0,0 +1,18 @@
+diff --git a/node_modules/app-builder-lib/out/targets/nsis/NsisTarget.js b/node_modules/app-builder-lib/out/targets/nsis/NsisTarget.js
+index 1e4ef94..5f64a59 100644
+--- a/node_modules/app-builder-lib/out/targets/nsis/NsisTarget.js
++++ b/node_modules/app-builder-lib/out/targets/nsis/NsisTarget.js
+@@ -367,7 +367,12 @@ class NsisTarget extends core_1.Target {
+             }
+         }
+         else {
+-            await (0, wine_1.execWine)(installerPath, null, [], { env: { __COMPAT_LAYER: "RunAsInvoker" } });
++            try {
++                await nsisUtil_1.UninstallerReader.exec(installerPath, uninstallerPath);
++            }
++            catch (_error) {
++                await (0, wine_1.execWine)(installerPath, null, [], { env: { __COMPAT_LAYER: "RunAsInvoker" } });
++            }
+         }
+         await packager.signIf(uninstallerPath);
+         delete defines.BUILD_UNINSTALLER;

scripts/build.mjs

@@ -62,7 +62,7 @@ async function buildNodeTargets() {
     bundle: true,
     minify: isProd,
     sourcemap: !isProd,
-    external: ['electron'],
+    external: ['electron', 'electron-updater', 'sharp', 'ffmpeg-static'],
     define,
     drop: isProd ? ['console', 'debugger'] : [],
   };

scripts/sync-update-feed.mjs

@@ -0,0 +1,102 @@
+/**
+ * Складывает артефакты electron-builder (win + mac) в публичный репозиторий,
+ * ветка `updates`, чтобы generic URL …/raw/branch/updates/ указывал на актуальные latest*.yml и установщики.
+ *
+ * Переменные окружения (имена без префикса GITEA_ — в Gitea секреты GITEA_* зарезервированы):
+ *   DND_UPDATES_SERVER       — https://git.example.com (без слэша в конце)
+ *   UPDATES_REPO             — owner/repo (публичный репозиторий «только релизы»)
+ *   DND_UPDATES_PUSH_TOKEN   — PAT с правом push в UPDATES_REPO
+ *   ARTIFACT_WIN    — каталог с файлами сборки Windows
+ *   ARTIFACT_MAC    — каталог с файлами сборки macOS
+ *   GIT_COMMIT_TAG  — опционально, для сообщения коммита
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const ALLOWED_EXT = new Set(['.yml', '.yaml', '.exe', '.blockmap', '.zip', '.dmg', '.pkg']);
+
+function mustEnv(name) {
+  const v = process.env[name]?.trim();
+  if (!v) throw new Error(`Missing env ${name}`);
+  return v;
+}
+
+function copyFlatReleaseFiles(fromDir, toDir) {
+  if (!fs.existsSync(fromDir)) {
+    console.warn(`[sync-update-feed] skip missing dir: ${fromDir}`);
+    return 0;
+  }
+  let n = 0;
+  for (const name of fs.readdirSync(fromDir)) {
+    const src = path.join(fromDir, name);
+    if (!fs.statSync(src).isFile()) continue;
+    const ext = path.extname(name).toLowerCase();
+    if (!ALLOWED_EXT.has(ext)) continue;
+    fs.copyFileSync(src, path.join(toDir, name));
+    n += 1;
+  }
+  return n;
+}
+
+function runGit(args, cwd) {
+  execFileSync('git', args, { cwd, stdio: 'inherit' });
+}
+
+function emptyWorkingTreeExceptGit(cwd) {
+  for (const ent of fs.readdirSync(cwd)) {
+    if (ent === '.git') continue;
+    fs.rmSync(path.join(cwd, ent), { recursive: true, force: true });
+  }
+}
+
+function main() {
+  const server = mustEnv('DND_UPDATES_SERVER').replace(/\/+$/u, '');
+  const updatesRepo = mustEnv('UPDATES_REPO');
+  const token = mustEnv('DND_UPDATES_PUSH_TOKEN');
+  const winDir = mustEnv('ARTIFACT_WIN');
+  const macDir = mustEnv('ARTIFACT_MAC');
+
+  const u = new URL(server);
+  const host = u.host;
+  const cloneUrl = `https://oauth2:${encodeURIComponent(token)}@${host}/${updatesRepo}.git`;
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'dnd-feed-'));
+  const work = path.join(tmp, 'repo');
+
+  try {
+    execFileSync('git', ['clone', '--depth', '1', '-b', 'updates', cloneUrl, work], { stdio: 'inherit' });
+  } catch {
+    execFileSync('git', ['clone', '--depth', '1', cloneUrl, work], { stdio: 'inherit' });
+    runGit(['checkout', '-B', 'updates'], work);
+  }
+
+  runGit(['config', 'user.email', 'ci@gitea-actions.local'], work);
+  runGit(['config', 'user.name', 'gitea-actions'], work);
+
+  emptyWorkingTreeExceptGit(work);
+
+  const copied = copyFlatReleaseFiles(winDir, work) + copyFlatReleaseFiles(macDir, work);
+  if (copied === 0) {
+    throw new Error('[sync-update-feed] no release files copied (check ARTIFACT_WIN / ARTIFACT_MAC)');
+  }
+
+  const tag = process.env.GIT_COMMIT_TAG?.trim() || 'ci';
+  runGit(['add', '-A'], work);
+  const st = execFileSync('git', ['status', '--porcelain'], { cwd: work }).toString().trim();
+  if (st) {
+    runGit(['commit', '-m', `update feed ${tag}`], work);
+    runGit(['push', '-u', 'origin', 'updates'], work);
+  } else {
+    console.warn('[sync-update-feed] nothing to commit (identical artifacts?)');
+  }
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+  console.log(`[sync-update-feed] done (${String(copied)} file(s) staged)`);
+}
+
+main();