chuijs 4.0.0 → 4.0.2

package/framework/modules/chui_services/chui_channels.js

@@ -40,9 +40,55 @@ const SERVICES_CHANNELS = {
     /** Событие main → рендерер: язык приложения изменился */
     LOCALE_EVENT: "chui_services_locale_event",
     /** Событие main → рендерер: сработала глобальная клавиша */
-    SHORTCUT_EVENT: "chui_shortcut"
+    SHORTCUT_EVENT: "chui_shortcut",
+    /** Путь приложения по имени из `APP_PATH_NAMES` */
+    APP_PATH: "chui_services_app_path",
+    /**
+     * Тот же путь, но ответ приходит значением, а не промисом: канал синхронный
+     * (`ipcRenderer.sendSync`). `Desktop.app.path` ходит сюда — путь берут на старте, чтобы
+     * собрать свои пути к файлам, и ждать промис там негде. Асинхронный `APP_PATH` оставлен:
+     * карта `window.chui.services` отдаётся странице целиком, её ключи — часть API безопасного
+     * режима, и убрать один из них значило бы сломать чужой вызов.
+     */
+    APP_PATH_SYNC: "chui_services_app_path_sync",
+    /** Сведения о приложении: имя, версия, язык, сборка */
+    APP_INFO: "chui_services_app_info",
+    /**
+     * Закрыть и перезапустить приложение со страницы. Идут через `Main.stop()`/`restart()`:
+     * это те же шаги, что у пункта меню «Выход», — снимаются обработчики сервисов, глобальные
+     * клавиши и подписки, а не просто закрывается окно.
+     */
+    APP_QUIT: "chui_services_app_quit",
+    APP_RESTART: "chui_services_app_restart",
+    /**
+     * Те же закрытие и перезапуск, но ответ приходит значением, а не промисом: канал
+     * синхронный (`ipcRenderer.sendSync`). `Desktop.app.quit()`/`restart()` ходят сюда — выход
+     * начинается тем же `Main.stop()`/`restart()`, а страница получает ответ сразу, без `await`.
+     * Асинхронные `APP_QUIT`/`APP_RESTART` оставлены: их ключи есть в карте `window.chui.services`,
+     * а это часть API безопасного режима.
+     */
+    APP_QUIT_SYNC: "chui_services_app_quit_sync",
+    APP_RESTART_SYNC: "chui_services_app_restart_sync",
+    /** Системные диалоги: окно берётся у отправителя */
+    DIALOG_OPEN: "chui_services_dialog_open",
+    DIALOG_SAVE: "chui_services_dialog_save",
+    DIALOG_MESSAGE: "chui_services_dialog_message",
+    /** Сессия окна-отправителя: кеш и хранилище */
+    SESSION_CACHE_SIZE: "chui_services_session_cache_size",
+    SESSION_CLEAR_CACHE: "chui_services_session_clear_cache",
+    SESSION_CLEAR_STORAGE: "chui_services_session_clear_storage"
 };
 
+/**
+ * Имена путей `app.getPath()`, которые может запросить страница. Это белый список: всё, что
+ * вне него, main отклоняет — странице не должен быть доступен произвольный каталог системы.
+ * Имена совпадают с именами Electron, кроме `logs` (в Electron это `logs`).
+ */
+const APP_PATH_NAMES = [
+    "home", "appData", "userData", "sessionData", "temp", "exe", "module",
+    "desktop", "documents", "downloads", "music", "pictures", "videos", "logs", "recent", "crashDumps"
+];
+
 /**
  * Метод моста preload'а → канал. `Desktop` вызывает метод по имени: в безопасном режиме
  * его берут из `window.chui.services`, в обычном — сами зовут `ipcRenderer.invoke(канал)`.
@@ -74,7 +120,41 @@ const SERVICES_CALLS = {
     themeSet: SERVICES_CHANNELS.THEME_SET,
     themeToggle: SERVICES_CHANNELS.THEME_TOGGLE,
     localeGet: SERVICES_CHANNELS.LOCALE_GET,
-    localeSet: SERVICES_CHANNELS.LOCALE_SET
+    localeSet: SERVICES_CHANNELS.LOCALE_SET,
+    appPath: SERVICES_CHANNELS.APP_PATH,
+    appInfo: SERVICES_CHANNELS.APP_INFO,
+    appQuit: SERVICES_CHANNELS.APP_QUIT,
+    appRestart: SERVICES_CHANNELS.APP_RESTART,
+    dialogOpen: SERVICES_CHANNELS.DIALOG_OPEN,
+    dialogSave: SERVICES_CHANNELS.DIALOG_SAVE,
+    dialogMessage: SERVICES_CHANNELS.DIALOG_MESSAGE,
+    sessionCacheSize: SERVICES_CHANNELS.SESSION_CACHE_SIZE,
+    sessionClearCache: SERVICES_CHANNELS.SESSION_CLEAR_CACHE,
+    sessionClearStorage: SERVICES_CHANNELS.SESSION_CLEAR_STORAGE
+};
+
+/**
+ * Синхронные вызовы (`ipcRenderer.sendSync`) — те, где ответ нужен значением, а не промисом.
+ *
+ * Отдельный map, а не строка в `SERVICES_CALLS`: тот мост превращает в методы страницы через
+ * `ipcRenderer.invoke`, а на синхронный канал invoke не отвечает — промис не завершился бы
+ * никогда, и страница молча ждала бы ответа.
+ *
+ * Ответ синхронного канала — конверт `{value}` или `{error}`: у `sendSync` нет канала для
+ * исключения, и без конверта причина отказа (имя пути вне белого списка) потерялась бы,
+ * а страница получила бы `undefined`. Разбирает конверт `Desktop.#callSync` — одинаково
+ * в обычном режиме и в безопасном.
+ *
+ * `sendSync` останавливает страницу на время ответа (main при этом свободен), поэтому
+ * синхронных вызовов должно быть мало и отвечать они обязаны мгновенно: `app.getPath` —
+ * чтение кеша Electron, без обращения к диску.
+ */
+const SERVICES_SYNC_CALLS = {
+    appPathSync: SERVICES_CHANNELS.APP_PATH_SYNC,
+    // Закрытие и перезапуск отвечают мгновенно (`setImmediate` в main откладывает выход),
+    // поэтому синхронный канал здесь так же уместен, как у пути: странице не нужен `await`
+    appQuitSync: SERVICES_CHANNELS.APP_QUIT_SYNC,
+    appRestartSync: SERVICES_CHANNELS.APP_RESTART_SYNC
 };
 
 /** Каналы моста: окно, тема и прикладные сообщения безопасного окна */
@@ -98,5 +178,7 @@ const BRIDGE_ARGS = {
 
 exports.SERVICES_CHANNELS = SERVICES_CHANNELS
 exports.SERVICES_CALLS = SERVICES_CALLS
+exports.SERVICES_SYNC_CALLS = SERVICES_SYNC_CALLS
 exports.BRIDGE_CHANNELS = BRIDGE_CHANNELS
+exports.APP_PATH_NAMES = APP_PATH_NAMES
 exports.BRIDGE_ARGS = BRIDGE_ARGS

package/framework/modules/chui_services/desktop.js

@@ -1,4 +1,4 @@
-const {SERVICES_CHANNELS, SERVICES_CALLS} = require("./chui_channels");
+const {SERVICES_CHANNELS, SERVICES_CALLS, SERVICES_SYNC_CALLS, APP_PATH_NAMES} = require("./chui_channels");
 
 /**
  * Десктоп-сервисы со стороны страницы: буфер обмена, последние документы, прогресс на иконке
@@ -125,6 +125,107 @@ class Desktop {
         onChange: (listener = () => {}) => Desktop.#subscribeLocale(listener)
     };
 
+    /**
+     * Приложение: пути, сведения и сырые модули Electron.
+     *
+     * Странице модули main не отдают — это и есть рекомендация Electron вместо `remote`,
+     * поэтому пути и сведения идут по IPC. В main-процессе IPC нет, и те же методы отвечают
+     * значением: `path()` берёт путь у Electron, а `get()`/`getSession()`/`getWebContents()`
+     * отдают сами объекты.
+     *
+     * ```javascript
+     * const dir = Desktop.app.path('userData');   // путь приходит сразу, без промиса
+     * const info = await Desktop.app.info();      // {name, version, locale, isPackaged}
+     * Desktop.app.quit();                         // закрыть приложение — тоже без промиса
+     * ```
+     */
+    static app = {
+        /**
+         * Путь по имени из белого списка (`"userData"`, `"downloads"`, …).
+         *
+         * Отвечает значением, а не промисом: из этих путей страница собирает свои (файлы,
+         * логи, кеш) на старте, и `await` пришлось бы протаскивать через весь код инициализации.
+         * Идёт по синхронному каналу (`SERVICES_SYNC_CALLS`), а потому значение берётся один раз
+         * на имя и кешируется — `sendSync` останавливает страницу на время ответа, а путь за
+         * жизнь приложения не меняется (`app.setPath` в main — редкий случай, и тогда кеш
+         * страницы устареет так же, как устарел бы вызов, сделанный раньше).
+         * Прежний `await Desktop.app.path(...)` продолжает работать: `await` на строке
+         * возвращает ту же строку.
+         *
+         * Работает и в main-процессе: там канала нет, и путь берётся у Electron напрямую
+         * (с тем же белым списком), поэтому `main.js` обходится без отдельного класса путей.
+         */
+        path: (name = String()) => Desktop.#appPath(String(name)),
+        /** @returns {Promise<{name: string, version: string, locale: string, systemLocale: string, isPackaged: boolean}>} */
+        info: () => Desktop.#call("appInfo"),
+        /**
+         * Сырой объект `app` Electron. **Только для main-процесса:** странице модули main
+         * не отдают, и здесь она получит ошибку с подсказкой — вместо `app` со страницы берут
+         * `Desktop.app.info()`, `Desktop.session.*`, `Desktop.dialog` или свой канал.
+         *
+         * ```javascript
+         * const app = Desktop.app.get();                  // main.js
+         * app.on('session-created', (session) => {});
+         * ```
+         */
+        get: () => Desktop.#electronObject("app"),
+        /** Сырой `session` Electron (только main-процесс; странице — `Desktop.session.*`) */
+        getSession: () => Desktop.#electronObject("session"),
+        /** Сырой `webContents` Electron (только main-процесс) */
+        getWebContents: () => Desktop.#electronObject("webContents"),
+        /**
+         * Закрыть приложение: тот же выход, что у пункта меню «Выход» — `Main.stop()` снимает
+         * обработчики сервисов, глобальные клавиши и подписки, а затем приложение выходит.
+         *
+         * Отвечает значением, а не промисом (синхронный канал): ждать результат не нужно и
+         * `await` ничего не меняет — `await true` даёт то же `true`. Ответ приходит до выхода,
+         * потому что main откладывает `stop()` через `setImmediate`.
+         *
+         * ```javascript
+         * new Button({title: 'Выход', clickEvent: () => Desktop.app.quit()});
+         * ```
+         * @returns {boolean} `true` — выход начат
+         */
+        quit: () => Desktop.#callSync("appQuitSync"),
+        /**
+         * Перезапустить приложение: процесс поднимается заново (`Main.restart()` →
+         * `app.relaunch()`), поэтому состояние из памяти не переносится — сохраните его сами.
+         *
+         * Отвечает значением, а не промисом (синхронный канал), как и `quit()`.
+         * @returns {boolean} `true` — перезапуск начат
+         */
+        restart: () => Desktop.#callSync("appRestartSync")
+    };
+
+    /**
+     * Системные диалоги — в том окне, которое их вызвало: родитель и модальность main
+     * берёт у отправителя. Результат открытия — `{canceled, filePaths}`, как у `dialog.*`.
+     *
+     * ```javascript
+     * const {canceled, filePaths} = await Desktop.dialog.open({properties: ["openFile"]});
+     * ```
+     */
+    static dialog = {
+        open: (options = Object()) => Desktop.#call("dialogOpen", options),
+        save: (options = Object()) => Desktop.#call("dialogSave", options),
+        message: (options = Object()) => Desktop.#call("dialogMessage", options)
+    };
+
+    /**
+     * Сессия окна-отправителя: кеш и хранилище. Именно своя сессия, а не чужого окна.
+     *
+     * ```javascript
+     * await Desktop.session.clearCache();
+     * await Desktop.session.clearStorageData({storages: ["cookies"]});
+     * ```
+     */
+    static session = {
+        /** @returns {Promise<number>} размер кеша в байтах */
+        getCacheSize: () => Desktop.#call("sessionCacheSize"),
+        clearCache: () => Desktop.#call("sessionClearCache"),
+        clearStorageData: (options = Object()) => Desktop.#call("sessionClearStorage", options)
+    };
+
     // accelerator → набор обработчиков этого окна
     static #shortcut_handlers = new Map();
     static #shortcut_event_bound = false;
@@ -138,6 +239,9 @@ class Desktop {
     static #history_handlers = new Set();
     static #history_event_bound = false;
     static #history_bridge_unsubscribe = undefined;
+    // Пути приложения, уже полученные значением: `sendSync` останавливает страницу на время
+    // ответа, поэтому за одним и тем же именем в main ходят один раз
+    static #app_paths = new Map();
 
     static #bridge() {
         if (typeof window === "undefined" || window.chui === undefined) return undefined;
@@ -152,6 +256,65 @@ class Desktop {
         return ipcRenderer.invoke(SERVICES_CALLS[method], ...args);
     }
 
+    /**
+     * Синхронный вызов сервиса: в безопасном режиме — метод моста, иначе — канал `sendSync`.
+     * Канал отвечает конвертом `{value}`/`{error}` (см. `SERVICES_SYNC_CALLS` в chui_channels.js),
+     * поэтому исключение из main превращается здесь в обычную ошибку с его текстом.
+     */
+    static #callSync(method = String(), ...args) {
+        const services = Desktop.#bridge();
+        const answer = services !== undefined && typeof services[method] === "function"
+            ? services[method](...args)
+            : require("electron").ipcRenderer.sendSync(SERVICES_SYNC_CALLS[method], ...args);
+        if (answer === null || typeof answer !== "object") return answer;
+        if (answer.error !== undefined) throw new Error(answer.error);
+        return answer.value;
+    }
+
+    /**
+     * Путь приложения значением (см. `Desktop.app.path`).
+     *
+     * В main-процессе IPC недоступен (`ipcRenderer` там нет, а отправителя-страницы не
+     * существует), поэтому путь берётся у Electron напрямую — с той же проверкой белого
+     * списка, что и в канале. Это позволяет звать `Desktop.app.path()` из `main.js` и со
+     * страницы одним и тем же вызовом.
+     */
+    static #appPath(name = String()) {
+        if (Desktop.#app_paths.has(name)) return Desktop.#app_paths.get(name);
+        const value = Desktop.#inMainProcess()
+            ? Desktop.#appPathInMain(name)
+            : Desktop.#callSync("appPathSync", name);
+        Desktop.#app_paths.set(name, value);
+        return value;
+    }
+
+    /** Различает процессы: у main нет `window`, у страницы и preload'а — есть */
+    static #inMainProcess() {
+        return typeof window === "undefined";
+    }
+
+    /** main-процесс: путь у Electron напрямую, но только из белого списка */
+    static #appPathInMain(name = String()) {
+        if (APP_PATH_NAMES.includes(name) === false) {
+            throw new Error(`Desktop.app.path: имя «${name}» вне белого списка`);
+        }
+        return require("electron").app.getPath(name);
+    }
+
+    /**
+     * Сырой объект Electron для main-процесса.
+     *
+     * Со страницы `app`/`session`/`webContents` недоступны: Electron не рекомендует `remote`,
+     * а мост preload'а отдаёт только узкий `window.chui`. Поэтому вместо тихого `undefined`
+     * здесь ошибка с подсказкой, что взять взамен.
+     */
+    static #electronObject(name = String()) {
+        if (Desktop.#inMainProcess() === false) {
+            throw new Error(`Desktop.app: сырой «${name}» доступен только в main-процессе — со страницы возьмите Desktop.app.info(), Desktop.session.* или свой канал из security.channels`);
+        }
+        return require("electron")[name];
+    }
+
     static #subscribe(accelerator = String(), handler = () => {}) {
         const handlers = Desktop.#shortcut_handlers.get(accelerator) ?? new Set();
         const first = handlers.size === 0;

package/index.js

@@ -1,6 +1,5 @@
 // === ИНСТРУМЕНТЫ ===
-const {app, BrowserWindow, Menu, Tray, ipcMain, ipcRenderer, shell, nativeTheme, session, webContents, systemPreferences} = require('electron');
-const { dialog } = require('@electron/remote/main');
+const {app, BrowserWindow, Menu, Tray, ipcMain, ipcRenderer, shell, nativeTheme, session, webContents, systemPreferences, dialog} = require('electron');
 // Одно хранилище настроек на модуль: его получает приложение через `require('chuijs').store`,
 // из него читают тему, язык и история буфера, а `Settings` берёт его для своих значений по умолчанию
 const {store} = require("./framework/modules/chui_store/chui_store");
@@ -50,6 +49,7 @@ const {Descriptions} = require('./framework/components/chui_descriptions/descrip
 const {Statistic} = require('./framework/components/chui_statistic/statistic');
 const {Backtop} = require('./framework/components/chui_backtop/backtop');
 const {Affix} = require('./framework/components/chui_affix/affix');
+const {StickyBar} = require('./framework/components/chui_sticky_bar/sticky_bar');
 const {Watermark} = require('./framework/components/chui_watermark/watermark');
 const {ShortcutHelp} = require('./framework/components/chui_shortcut_help/shortcut_help');
 const {Tooltip} = require('./framework/components/chui_tooltip/tooltip');
@@ -78,7 +78,7 @@ const {CodeBlock} = require('./framework/components/chui_code/code')
 const {HtmlBlock} = require('./framework/components/chui_html_block/html_block')
 const {sleep, render, getDefaultIcon, formatBytes} = require('./framework/modules/chui_functions');
 const {Shortcuts, Clipboard, RecentDocuments, TaskbarProgress} = require('./framework/modules/chui_services/chui_services');
-const {SERVICES_CHANNELS, BRIDGE_CHANNELS, BRIDGE_ARGS} = require('./framework/modules/chui_services/chui_channels');
+const {SERVICES_CHANNELS, BRIDGE_CHANNELS, BRIDGE_ARGS, APP_PATH_NAMES} = require('./framework/modules/chui_services/chui_channels');
 const {Desktop} = require('./framework/modules/chui_services/desktop');
 const {I18n} = require('./framework/modules/chui_i18n/chui_i18n');
 const {Shell, Theme, Locale, ClipboardHistory: ClipboardHistoryService, Print} = require('./framework/modules/chui_services/chui_services');
@@ -150,6 +150,23 @@ const {QRCode} = require("./framework/components/chui_qrcode/qrcode");
 const {Log} = require("./framework/modules/chui_logger/chui_logger");
 const url = require("node:url");
 
+/** Код исполняется на странице (renderer), а не в main: от этого зависит доступ к модулям Electron */
+function inRenderer() {
+    return process !== undefined && process.type === "renderer";
+}
+
+/**
+ * Путь приложения по имени из белого списка.
+ *
+ * Одно правило на два канала (`APP_PATH` и `APP_PATH_SYNC`): странице не должен быть доступен
+ * произвольный каталог системы, поэтому всё, что вне `APP_PATH_NAMES`, main отклоняет. Сам
+ * `app.getPath` синхронный и без диска — именно поэтому путь можно отдавать значением.
+ */
+function appPathByName(name = String()) {
+    if (APP_PATH_NAMES.includes(name) === false) throw new Error(`Desktop.app.path: имя «${name}» вне белого списка`);
+    return app.getPath(name);
+}
+
 //VARS
 let isQuiting = false;
 
@@ -228,6 +245,9 @@ class Main {
     // Десктоп-сервисы (буфер, недавние, прогресс, глобальные клавиши) и их подписки по окнам
     #services_enabled = false;
     #service_handlers = [];
+    // Синхронные каналы снимаются не `removeHandler`, а `removeListener`: они зарегистрированы
+    // через `ipcMain.on` — см. `#handleSync`
+    #service_sync_handlers = [];
     #shortcut_subscribers = new Map();
     #shortcut_watchers = new Map();
     #progress_windows = new Map();
@@ -236,6 +256,7 @@ class Main {
     #security = {contextIsolation: false, csp: false, channels: []};
     #secure_contents = new Set();
     #bridge_enabled = false;
+    #window_actions_bound = false;
     #theme_bound = false;
     #page_message_handlers = new Map();
     #onUncaughtException = (error) => {
@@ -431,7 +452,6 @@ class Main {
                     plugins: false,
                     nodeIntegration: false,
                     contextIsolation: true,
-                    enableRemoteModule: false,
                     sandbox: false,
                     preload: Main.SECURE_PRELOAD,
                     additionalArguments: Main.#bridgeArguments(options.render, security),
@@ -448,7 +468,6 @@ class Main {
                     preload: options.render === undefined ? this.#renderer : options.render,
                     spellcheck: false,
                     webviewTag: true,
-                    enableRemoteModule: true,
                     webSecurity: this.#webSecurity,
                     nodeIntegrationInSubFrames: true,
                 },
@@ -627,6 +646,9 @@ class Main {
     enableServices() {
         if (this.#services_enabled) return this;
         this.#services_enabled = true;
+        // Кнопки окна: каналы нужны и обычным окнам — в них `AppLayout` зовёт их по IPC,
+        // потому что `@electron/remote` в рендерере больше нет
+        this.#enableWindowActions();
         this.services = {
             shortcuts: new Shortcuts(),
             shell: new Shell(),
@@ -686,6 +708,51 @@ class Main {
             this.services.clipboard.clear();
             return true;
         });
+        // Приложение и системные диалоги для страницы: Electron советует IPC вместо `remote`.
+        // Путь — только из белого списка, диалог и сессия — у окна-отправителя.
+        this.#handle(SERVICES_CHANNELS.APP_PATH, (event, name) => appPathByName(name));
+        // `Desktop.app.path` отвечает значением, а не промисом, поэтому у пути есть второй,
+        // синхронный канал: `sendSync` ждёт `event.returnValue`, а не ответ `handle`.
+        // Асинхронный канал выше оставлен — его ключ есть в карте `window.chui.services`
+        this.#handleSync(SERVICES_CHANNELS.APP_PATH_SYNC, (event, name) => appPathByName(name));
+        this.#handle(SERVICES_CHANNELS.APP_INFO, () => ({
+            name: app.getName(),
+            version: app.getVersion(),
+            locale: app.getLocale(),
+            systemLocale: app.getSystemLocale(),
+            isPackaged: app.isPackaged
+        }));
+        // Закрытие и перезапуск со страницы: страница — код самого приложения, поэтому кнопке
+        // «Выход» не нужен свой канал в каждом проекте. Идут через `Main.stop()`/`restart()` —
+        // те же шаги, что у пункта меню: снимаются обработчики сервисов, глобальные клавиши и
+        // подписки, а не просто закрывается окно. Ответ уходит странице до выхода
+        // (`setImmediate`): иначе промис отваливался бы с «Render frame was disposed», и
+        // `await Desktop.app.quit()` со страницы выглядел бы ошибкой
+        this.#handle(SERVICES_CHANNELS.APP_QUIT, () => {
+            setImmediate(() => this.stop());
+            return true;
+        });
+        this.#handle(SERVICES_CHANNELS.APP_RESTART, () => {
+            setImmediate(() => this.restart());
+            return true;
+        });
+        // У закрытия и перезапуска есть и синхронные каналы: `Desktop.app.quit()`/`restart()`
+        // отвечают значением, а не промисом — как `Desktop.app.path`. Выход по-прежнему
+        // откладывается `setImmediate`, чтобы `event.returnValue` успел уйти странице.
+        this.#handleSync(SERVICES_CHANNELS.APP_QUIT_SYNC, () => {
+            setImmediate(() => this.stop());
+            return true;
+        });
+        this.#handleSync(SERVICES_CHANNELS.APP_RESTART_SYNC, () => {
+            setImmediate(() => this.restart());
+            return true;
+        });
+        this.#handle(SERVICES_CHANNELS.DIALOG_OPEN, (event, options) => Main.#showDialog(event, "showOpenDialog", options));
+        this.#handle(SERVICES_CHANNELS.DIALOG_SAVE, (event, options) => Main.#showDialog(event, "showSaveDialog", options));
+        this.#handle(SERVICES_CHANNELS.DIALOG_MESSAGE, (event, options) => Main.#showDialog(event, "showMessageBox", options));
+        this.#handle(SERVICES_CHANNELS.SESSION_CACHE_SIZE, (event) => event.sender.session.getCacheSize());
+        this.#handle(SERVICES_CHANNELS.SESSION_CLEAR_CACHE, (event) => event.sender.session.clearCache());
+        this.#handle(SERVICES_CHANNELS.SESSION_CLEAR_STORAGE, (event, options) => event.sender.session.clearStorageData(options));
         this.#handle(SERVICES_CHANNELS.RECENT_ADD, (event, path, name) => {
             this.services.recent.add(path, name);
             return true;
@@ -741,13 +808,42 @@ class Main {
         return this;
     }
 
+    /**
+     * Синхронный канал: `ipcRenderer.sendSync` в странице ждёт `event.returnValue`, а не ответ
+     * `handle`, поэтому здесь `ipcMain.on`. Ответ — конверт `{value}`/`{error}`: у синхронного
+     * канала нет способа передать исключение, и без конверта страница получила бы `undefined`
+     * вместо причины отказа (см. `SERVICES_SYNC_CALLS` в chui_channels.js).
+     */
+    #handleSync(channel = String(), handler = () => {}) {
+        const listener = (event, ...args) => {
+            try {
+                event.returnValue = {value: handler(event, ...args)};
+            } catch (error) {
+                event.returnValue = {error: error instanceof Error ? error.message : String(error)};
+            }
+        };
+        ipcMain.on(channel, listener);
+        this.#service_sync_handlers.push([channel, listener]);
+        return this;
+    }
+
     /**
      * Включает мост безопасных окон (`contextBridge`): управление окном, тема и прикладные
      * сообщения по белому списку каналов. Вызывается сам при создании безопасного окна.
      */
-    enableBridge() {
-        if (this.#bridge_enabled) return this;
-        this.#bridge_enabled = true;
+    /** Диалог в окне отправителя: без окна (уже закрыто) Electron зовётся без родителя */
+    static #showDialog(event, method = String(), options = Object()) {
+        const window = BrowserWindow.fromWebContents(event.sender);
+        return window === null ? dialog[method](options) : dialog[method](window, options);
+    }
+
+    /**
+     * Каналы кнопок окна. Ими пользуются оба режима: безопасное окно — через мост
+     * `window.chui.window`, обычное — прямым `ipcRenderer.invoke`. Регистрируются один раз на приложение.
+     */
+    #enableWindowActions() {
+        if (this.#window_actions_bound) return this;
+        this.#window_actions_bound = true;
         this.#handle(BRIDGE_CHANNELS.WINDOW_ACTION, (event, action) => Main.#applyWindowAction(event.sender, action));
         this.#handle(BRIDGE_CHANNELS.WINDOW_STATE, (event) => {
             const window = BrowserWindow.fromWebContents(event.sender);
@@ -759,6 +855,13 @@ class Main {
                 isFocused: window.isFocused()
             };
         });
+        return this;
+    }
+
+    enableBridge() {
+        if (this.#bridge_enabled) return this;
+        this.#bridge_enabled = true;
+        this.#enableWindowActions();
         this.#handle(BRIDGE_CHANNELS.THEME_GET, () => (nativeTheme.shouldUseDarkColors ? "dark" : "light"));
         this.#handle(BRIDGE_CHANNELS.LOCALE_GET, () => this.services.locale.get());
         this.#handle(BRIDGE_CHANNELS.MESSAGE, (event, channel, ...args) => {
@@ -790,7 +893,7 @@ class Main {
         return this.#send(BRIDGE_CHANNELS.MESSAGE, [channel, payload], windowName);
     }
 
-    /** Действия кнопок окна для безопасного режима (там нет @electron/remote) */
+    /** Действия кнопок окна: и обычные окна, и безопасные зовут их по IPC */
     static #applyWindowAction(sender, action = String()) {
         const window = BrowserWindow.fromWebContents(sender);
         if (window === null || window.isDestroyed()) return false;
@@ -1008,6 +1111,8 @@ class Main {
         // Десктоп-сервисы: снимаем обработчики IPC, подписки клавиш и сами клавиши
         for (const [channel] of this.#service_handlers) ipcMain.removeHandler(channel);
         this.#service_handlers = [];
+        for (const [channel, listener] of this.#service_sync_handlers) ipcMain.removeListener(channel, listener);
+        this.#service_sync_handlers = [];
         this.#shortcut_subscribers.clear();
         this.#shortcut_watchers.clear();
         this.#progress_windows.clear();
@@ -1021,6 +1126,7 @@ class Main {
         this.#on_theme_updated = undefined;
         this.#page_message_handlers.clear();
         this.#bridge_enabled = false;
+        this.#window_actions_bound = false;
         if (this.#updaterListening) {
             this.#updaterListening = false;
             require("electron-updater").autoUpdater.removeListener('update-downloaded', this.#onUpdateDownloaded);
@@ -1074,9 +1180,7 @@ class Main {
                 Menu.setApplicationMenu(null)
             }
             this.enableServices();
-            const window = this.#buildWindow({name: Main.MAIN_WINDOW, hideOnClose: options.hideOnClose});
-            require("@electron/remote/main").initialize();
-            require("@electron/remote/main").enable(window.webContents);
+            this.#buildWindow({name: Main.MAIN_WINDOW, hideOnClose: options.hideOnClose});
         })
     }
 
@@ -1168,53 +1272,6 @@ class Styles {
     };
 }
 
-class Application {
-    getApp() {
-        if (process && process.type === 'renderer') {
-            return require("@electron/remote").app;
-        } else {
-            return app;
-        }
-    }
-    getSession() {
-        if (process && process.type === 'renderer') {
-            return require("@electron/remote").session;
-        } else {
-            return session;
-        }
-    }
-    getWebContents() {
-        if (process && process.type === 'renderer') {
-            return require("@electron/remote").webContents;
-        } else {
-            return webContents;
-        }
-    }
-}
-
-class App {
-    static get() { return new Application().getApp() }
-    static getSession() { return new Application().getSession() }
-    static getWebContents() { return new Application().getWebContents() }
-    // ПУТИ
-    static homePath() { return new Application().getApp().getPath("home") }
-    static appDataPath() { return new Application().getApp().getPath("appData") }
-    static userDataPath() { return new Application().getApp().getPath("userData") }
-    static sessionDataPath() { return new Application().getApp().getPath("sessionData") }
-    static logsPath() { return new Application().getApp().getPath("logs") }
-    static tempPath() { return new Application().getApp().getPath("temp") }
-    static exePath() { return new Application().getApp().getPath("exe") }
-    static modulePath() { return new Application().getApp().getPath("module") }
-    static desktopPath() { return new Application().getApp().getPath("desktop") }
-    static documentsPath() { return new Application().getApp().getPath("documents") }
-    static downloadsPath() { return new Application().getApp().getPath("downloads") }
-    static musicPath() { return new Application().getApp().getPath("music") }
-    static picturesPath() { return new Application().getApp().getPath("pictures") }
-    static videosPath() { return new Application().getApp().getPath("videos") }
-    static recentPath() { return new Application().getApp().getPath("recent") }
-    static crashDumpsPath() { return new Application().getApp().getPath("crashDumps") }
-}
-
 module.exports = {
     Main: Main,
     sleep: sleep,
@@ -1246,6 +1303,7 @@ module.exports = {
     Statistic: Statistic,
     Backtop: Backtop,
     Affix: Affix,
+    StickyBar: StickyBar,
     Watermark: Watermark,
     ShortcutHelp: ShortcutHelp,
     Alert: Alert,
@@ -1371,8 +1429,6 @@ module.exports = {
     transliterate: transliterate,
     store: store,
     //
-    App: App,
-    //
     // Десктоп-сервисы: классы main-процесса и доступ из страницы
     Shortcuts: Shortcuts,
     Shell: Shell,
@@ -1388,7 +1444,12 @@ module.exports = {
     //
     downloadSession: downloadSession,
     Log: Log,
-    chooseFile: dialog,
+    chooseFile: {
+        // Диалоги: странице — по IPC (окно берётся у отправителя), в main — обычный dialog Electron
+        showOpenDialog: (options = {}) => (inRenderer() ? Desktop.dialog.open(options) : dialog.showOpenDialog(options)),
+        showSaveDialog: (options = {}) => (inRenderer() ? Desktop.dialog.save(options) : dialog.showSaveDialog(options)),
+        showMessageBox: (options = {}) => (inRenderer() ? Desktop.dialog.message(options) : dialog.showMessageBox(options))
+    },
     //
     systemPreferences: systemPreferences
 }