@e-xi/xion 0.0.6

package/dist/preload/bridge/preload.cjs

@@ -0,0 +1,1706 @@
+"use strict";
+
+// src/preload/bridge/bridge-abstract.ts
+var BridgeAbstract = class {
+};
+
+// src/shared/errors/ipc-invoke-error.ts
+var IpcInvokeErrorName = "IpcInvokeError";
+var IpcInvokeError = class extends Error {
+  /* 错误类型标记 */
+  kind = IpcInvokeErrorName;
+  /* 错误码 */
+  code;
+  /* 错误数据 */
+  data;
+  /**
+   * 构造函数
+   * @param {XoIpc.Result} result IPC 调用结果
+   */
+  constructor(result) {
+    super(result.message || "IPC \u8C03\u7528\u5931\u8D25");
+    this.name = IpcInvokeErrorName;
+    this.code = result.code;
+    this.data = result.data;
+  }
+};
+
+// src/preload/utils/bridge-util.ts
+var import_electron = require("electron");
+var BridgeUtil = class _BridgeUtil {
+  /**
+   * 调用IPC并返回结果
+   * @template R 返回值类型
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any[]}         args    参数
+   * @returns {Promise<XoIpc.Result<R>>}
+   */
+  static async invokeResult(channel, ...args) {
+    return await import_electron.ipcRenderer.invoke(channel, ...args);
+  }
+  /**
+   * 调用IPC并返回数据
+   * @template R 返回值类型
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any[]}         args    参数
+   * @returns {Promise<R | undefined>}
+   */
+  static async invoke(channel, ...args) {
+    const result = await _BridgeUtil.invokeResult(channel, ...args);
+    if (!result.success) {
+      const error = new IpcInvokeError(result);
+      throw {
+        kind: error.kind,
+        name: error.name,
+        message: error.message,
+        code: error.code,
+        data: error.data
+      };
+    }
+    return result.data;
+  }
+  /**
+   * 发送IPC消息
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any[]}         args    参数
+   */
+  static send(channel, ...args) {
+    import_electron.ipcRenderer.send(channel, ...args);
+  }
+  /**
+   * 监听IPC消息
+   * @template TArgs 参数类型
+   * @param {XoIpc.Channel}            channel  通道
+   * @param {(...args: TArgs) => void} listener 监听器
+   * @returns {() => void}
+   */
+  static on(channel, listener) {
+    const wrappedListener = (_event, ...args) => {
+      listener(...args);
+    };
+    import_electron.ipcRenderer.on(channel, wrappedListener);
+    return () => {
+      import_electron.ipcRenderer.removeListener(channel, wrappedListener);
+    };
+  }
+  /**
+   * 单次监听IPC消息
+   * @template TArgs 参数类型
+   * @param {XoIpc.Channel}             channel  通道
+   * @param {(...args: TArgs) => void} listener 监听器
+   */
+  static once(channel, listener) {
+    import_electron.ipcRenderer.once(channel, (_event, ...args) => {
+      listener(...args);
+    });
+  }
+};
+
+// src/shared/ipc/consts/ipc-channel.ts
+var IpcChannelPrefix = "Channel_";
+
+// src/shared/utils/ipc-util.ts
+var IpcUtil = class {
+  /**
+   * 创建IPC通道
+   * @param {string} name 通道名
+   * @returns {XoIpc.Channel}
+   */
+  static channel(name) {
+    return `${IpcChannelPrefix}${name}`;
+  }
+};
+
+// src/shared/ipc/channels/app-channels.ts
+var AppChannels = class {
+  /** 获取应用信息 */
+  static getInfo = IpcUtil.channel("BuiltIn:App:getInfo");
+  /** 获取应用目录 */
+  static getPaths = IpcUtil.channel("BuiltIn:App:getPaths");
+  /** 获取通用设置 */
+  static getGeneralSettings = IpcUtil.channel("BuiltIn:App:getGeneralSettings");
+  /** 获取 APP 透明度 */
+  static getOpacity = IpcUtil.channel("BuiltIn:App:getOpacity");
+  /** 设置 APP 透明度 */
+  static setOpacity = IpcUtil.channel("BuiltIn:App:setOpacity");
+  /** 获取快捷窗口材质 */
+  static getWindowMaterial = IpcUtil.channel("BuiltIn:App:getWindowMaterial");
+  /** 设置快捷窗口材质 */
+  static setWindowMaterial = IpcUtil.channel("BuiltIn:App:setWindowMaterial");
+  /** 获取应用启动模式 */
+  static getAppLaunchMode = IpcUtil.channel("BuiltIn:App:getAppLaunchMode");
+  /** 设置应用启动模式 */
+  static setAppLaunchMode = IpcUtil.channel("BuiltIn:App:setAppLaunchMode");
+  /** 获取是否开机启动 */
+  static getLaunchOnStartup = IpcUtil.channel("BuiltIn:App:getLaunchOnStartup");
+  /** 设置是否开机启动 */
+  static setLaunchOnStartup = IpcUtil.channel("BuiltIn:App:setLaunchOnStartup");
+  /** 获取关闭窗口行为 */
+  static getWindowCloseBehavior = IpcUtil.channel("BuiltIn:App:getWindowCloseBehavior");
+  /** 设置关闭窗口行为 */
+  static setWindowCloseBehavior = IpcUtil.channel("BuiltIn:App:setWindowCloseBehavior");
+  /** 获取日志等级 */
+  static getLogLevel = IpcUtil.channel("BuiltIn:App:getLogLevel");
+  /** 设置日志等级 */
+  static setLogLevel = IpcUtil.channel("BuiltIn:App:setLogLevel");
+  /** 获取快捷键配置 */
+  static getShortcuts = IpcUtil.channel("BuiltIn:App:getShortcuts");
+  /** 设置快捷键配置 */
+  static setShortcuts = IpcUtil.channel("BuiltIn:App:setShortcuts");
+  /** 设置单个快捷键配置 */
+  static setShortcut = IpcUtil.channel("BuiltIn:App:setShortcut");
+  /** 删除快捷键配置 */
+  static deleteShortcut = IpcUtil.channel("BuiltIn:App:deleteShortcut");
+  /** 重定向指定窗口路由 */
+  static redirectWindowRoute = IpcUtil.channel("BuiltIn:App:redirectWindowRoute");
+  /** 重定向主窗口路由 */
+  static redirectMainWindowRoute = IpcUtil.channel("BuiltIn:App:redirectMainWindowRoute");
+  /** 重定向设置窗口路由 */
+  static redirectSettingWindowRoute = IpcUtil.channel("BuiltIn:App:redirectSettingWindowRoute");
+  /** 显示主窗口 */
+  static showMainWindow = IpcUtil.channel("BuiltIn:App:showMainWindow");
+  /** 显示设置窗口 */
+  static showSettingWindow = IpcUtil.channel("BuiltIn:App:showSettingWindow");
+  /** 重启应用 */
+  static restart = IpcUtil.channel("BuiltIn:App:restart");
+};
+
+// src/preload/bridges/app/app-bridge.ts
+var AppBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.app}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      app: {
+        // 获取应用信息
+        getInfo: this.getInfo.bind(this),
+        // 获取应用目录
+        getPaths: this.getPaths.bind(this),
+        // 获取通用设置
+        getGeneralSettings: this.getGeneralSettings.bind(this),
+        // 获取 APP 透明度
+        getOpacity: this.getOpacity.bind(this),
+        // 设置 APP 透明度
+        setOpacity: this.setOpacity.bind(this),
+        // 获取快捷窗口材质
+        getWindowMaterial: this.getWindowMaterial.bind(this),
+        // 设置快捷窗口材质
+        setWindowMaterial: this.setWindowMaterial.bind(this),
+        // 获取应用启动模式
+        getAppLaunchMode: this.getAppLaunchMode.bind(this),
+        // 设置应用启动模式
+        setAppLaunchMode: this.setAppLaunchMode.bind(this),
+        // 获取是否开机启动
+        getLaunchOnStartup: this.getLaunchOnStartup.bind(this),
+        // 设置是否开机启动
+        setLaunchOnStartup: this.setLaunchOnStartup.bind(this),
+        // 获取关闭窗口行为
+        getWindowCloseBehavior: this.getWindowCloseBehavior.bind(this),
+        // 设置关闭窗口行为
+        setWindowCloseBehavior: this.setWindowCloseBehavior.bind(this),
+        // 获取日志等级
+        getLogLevel: this.getLogLevel.bind(this),
+        // 设置日志等级
+        setLogLevel: this.setLogLevel.bind(this),
+        // 获取快捷键配置
+        getShortcuts: this.getShortcuts.bind(this),
+        // 设置快捷键配置
+        setShortcuts: this.setShortcuts.bind(this),
+        // 设置单个快捷键配置
+        setShortcut: this.setShortcut.bind(this),
+        // 删除快捷键配置
+        deleteShortcut: this.deleteShortcut.bind(this),
+        // 重定向指定窗口路由
+        redirectWindowRoute: this.redirectWindowRoute.bind(this),
+        // 重定向主窗口路由
+        redirectMainWindowRoute: this.redirectMainWindowRoute.bind(this),
+        // 重定向设置窗口路由
+        redirectSettingWindowRoute: this.redirectSettingWindowRoute.bind(this),
+        // 显示主窗口
+        showMainWindow: this.showMainWindow.bind(this),
+        // 显示设置窗口
+        showSettingWindow: this.showSettingWindow.bind(this),
+        // 重启应用
+        restart: this.restart.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取应用信息
+   * @returns {Promise<XoApp.Info>}
+   */
+  getInfo = async () => {
+    const data = await BridgeUtil.invoke(AppChannels.getInfo);
+    return data ?? {};
+  };
+  /**
+   * 获取应用目录
+   * @returns {Promise<XoApp.Paths>}
+   */
+  getPaths = async () => {
+    const data = await BridgeUtil.invoke(AppChannels.getPaths);
+    return data ?? {
+      userData: "",
+      sessionData: "",
+      logs: "",
+      crashDumps: "",
+      temp: "",
+      updaterCacheDir: ""
+    };
+  };
+  /**
+   * 获取通用设置
+   * @returns {Promise<XoApp.GeneralSettings>}
+   */
+  getGeneralSettings = async () => {
+    const settings = await BridgeUtil.invoke(AppChannels.getGeneralSettings);
+    return settings ?? {
+      opacity: 1,
+      windowMaterial: "none",
+      shortcuts: {},
+      logLevel: "info",
+      launchOnStartup: false,
+      appLaunchMode: "window",
+      windowCloseBehavior: "minimize"
+    };
+  };
+  /**
+   * 获取 APP 透明度
+   * @returns {Promise<number>}
+   */
+  getOpacity = async () => {
+    const opacity = await BridgeUtil.invoke(AppChannels.getOpacity);
+    return opacity ?? 1;
+  };
+  /**
+   * 设置 APP 透明度
+   * @param {number} opacity APP 透明度
+   * @returns {Promise<void>}
+   */
+  setOpacity = async (opacity) => {
+    await BridgeUtil.invoke(AppChannels.setOpacity, opacity);
+  };
+  /**
+   * 获取快捷窗口材质
+   * @returns {Promise<XoApp.WindowMaterial | undefined>}
+   */
+  getWindowMaterial = async () => {
+    return await BridgeUtil.invoke(AppChannels.getWindowMaterial);
+  };
+  /**
+   * 设置快捷窗口材质
+   * @param {XoApp.WindowMaterial} windowMaterial 窗口材质
+   * @returns {Promise<void>}
+   */
+  setWindowMaterial = async (windowMaterial) => {
+    await BridgeUtil.invoke(AppChannels.setWindowMaterial, windowMaterial);
+  };
+  /**
+   * 获取应用启动模式
+   * @returns {Promise<XoApp.AppLaunchMode>}
+   */
+  getAppLaunchMode = async () => {
+    const appLaunchMode = await BridgeUtil.invoke(AppChannels.getAppLaunchMode);
+    return appLaunchMode ?? "window";
+  };
+  /**
+   * 设置应用启动模式
+   * @param {XoApp.AppLaunchMode} appLaunchMode 应用启动模式
+   * @returns {Promise<void>}
+   */
+  setAppLaunchMode = async (appLaunchMode) => {
+    await BridgeUtil.invoke(AppChannels.setAppLaunchMode, appLaunchMode);
+  };
+  /**
+   * 获取是否开机启动
+   * @returns {Promise<boolean>}
+   */
+  getLaunchOnStartup = async () => {
+    const launchOnStartup = await BridgeUtil.invoke(AppChannels.getLaunchOnStartup);
+    return launchOnStartup ?? false;
+  };
+  /**
+   * 设置是否开机启动
+   * @param {boolean} launchOnStartup 是否开机启动
+   * @returns {Promise<void>}
+   */
+  setLaunchOnStartup = async (launchOnStartup) => {
+    await BridgeUtil.invoke(AppChannels.setLaunchOnStartup, launchOnStartup);
+  };
+  /**
+   * 获取关闭窗口行为
+   * @returns {Promise<XoApp.WindowCloseBehavior>}
+   */
+  getWindowCloseBehavior = async () => {
+    const windowCloseBehavior = await BridgeUtil.invoke(AppChannels.getWindowCloseBehavior);
+    return windowCloseBehavior ?? "minimize";
+  };
+  /**
+   * 设置关闭窗口行为
+   * @param {XoApp.WindowCloseBehavior} windowCloseBehavior 关闭窗口行为
+   * @returns {Promise<void>}
+   */
+  setWindowCloseBehavior = async (windowCloseBehavior) => {
+    await BridgeUtil.invoke(AppChannels.setWindowCloseBehavior, windowCloseBehavior);
+  };
+  /**
+   * 获取日志等级
+   * @returns {Promise<XoLogger.Level>}
+   */
+  getLogLevel = async () => {
+    const logLevel = await BridgeUtil.invoke(AppChannels.getLogLevel);
+    return logLevel ?? "info";
+  };
+  /**
+   * 设置日志等级
+   * @param {XoLogger.Level} logLevel 日志等级
+   * @returns {Promise<void>}
+   */
+  setLogLevel = async (logLevel) => {
+    await BridgeUtil.invoke(AppChannels.setLogLevel, logLevel ?? "info");
+  };
+  /**
+   * 获取快捷键配置
+   * @returns {Promise<XoShortcut.KeyMap>}
+   */
+  getShortcuts = async () => {
+    const shortcuts = await BridgeUtil.invoke(AppChannels.getShortcuts);
+    return shortcuts ?? {};
+  };
+  /**
+   * 设置快捷键配置
+   * @param {XoShortcut.KeyMap} shortcuts 快捷键配置
+   * @returns {Promise<void>}
+   */
+  setShortcuts = async (shortcuts) => {
+    await BridgeUtil.invoke(AppChannels.setShortcuts, shortcuts);
+  };
+  /**
+   * 设置单个快捷键配置
+   * @param {XoShortcut.Key} shortcut 快捷键配置
+   * @returns {Promise<void>}
+   */
+  setShortcut = async (shortcut) => {
+    await BridgeUtil.invoke(AppChannels.setShortcut, shortcut);
+  };
+  /**
+   * 删除快捷键配置
+   * @param {XoShortcut.ID} id 快捷键 ID
+   * @returns {Promise<void>}
+   */
+  deleteShortcut = async (id) => {
+    await BridgeUtil.invoke(AppChannels.deleteShortcut, id);
+  };
+  /** 重定向指定窗口路由 */
+  redirectWindowRoute = async (request) => {
+    const result = await BridgeUtil.invoke(AppChannels.redirectWindowRoute, request);
+    return result ?? false;
+  };
+  /** 重定向主窗口路由 */
+  redirectMainWindowRoute = async (request) => {
+    const result = await BridgeUtil.invoke(AppChannels.redirectMainWindowRoute, request);
+    return result ?? false;
+  };
+  /** 重定向设置窗口路由 */
+  redirectSettingWindowRoute = async (request) => {
+    const result = await BridgeUtil.invoke(AppChannels.redirectSettingWindowRoute, request);
+    return result ?? false;
+  };
+  /**
+   * 显示主窗口
+   * @param {XoWindow.RouteRedirectRequestWithoutWindow} request 路由重定向请求
+   * @returns {Promise<void>}
+   */
+  showMainWindow = async (request) => {
+    await BridgeUtil.invoke(AppChannels.showMainWindow, request);
+  };
+  /**
+   * 显示设置窗口
+   * @param {XoWindow.RouteRedirectRequestWithoutWindow} request 路由重定向请求
+   * @returns {Promise<void>}
+   */
+  showSettingWindow = async (request) => {
+    await BridgeUtil.invoke(AppChannels.showSettingWindow, request);
+  };
+  /**
+   * 重启应用
+   * @returns {Promise<void>}
+   */
+  restart = async () => {
+    await BridgeUtil.invoke(AppChannels.restart);
+  };
+};
+
+// src/shared/ipc/channels/auth-channels.ts
+var AuthChannels = class {
+  /** 获取认证状态 */
+  static getState = IpcUtil.channel("BuiltIn:Auth:getState");
+  /** 登录 */
+  static login = IpcUtil.channel("BuiltIn:Auth:login");
+  /** 退出登录 */
+  static logout = IpcUtil.channel("BuiltIn:Auth:logout");
+  /* ------ 监听通道 ------ */
+  /** 监听认证状态 */
+  static onState = IpcUtil.channel("BuiltIn:Auth:onState");
+};
+
+// src/preload/bridges/auth/auth-bridge.ts
+var AuthBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * @returns {{auth: XoBridgeApi.Map['auth']}}
+   */
+  apiMap() {
+    return {
+      auth: {
+        // 获取认证状态
+        getState: this.getState.bind(this),
+        // 登录
+        login: this.login.bind(this),
+        // 退出登录
+        logout: this.logout.bind(this),
+        // 监听认证状态
+        onState: this.onState.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取认证状态
+   * @returns {Promise<XoAuth.State>}
+   */
+  getState = async () => {
+    return await BridgeUtil.invoke(AuthChannels.getState) ?? { status: "unauthenticated" };
+  };
+  /**
+   * 登录
+   * @param {XoAuth.LoginRequest} request 登录请求
+   * @returns {Promise<XoAuth.State>}
+   */
+  login = async (request) => {
+    return await BridgeUtil.invoke(AuthChannels.login, request) ?? { status: "unauthenticated" };
+  };
+  /**
+   * 退出登录
+   * @returns {Promise<XoAuth.State>}
+   */
+  logout = async () => {
+    return await BridgeUtil.invoke(AuthChannels.logout) ?? { status: "unauthenticated" };
+  };
+  /**
+   * 监听认证状态
+   * @param {XoAuth.StateListener} listener 状态监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(AuthChannels.onState, listener);
+  };
+};
+
+// src/shared/ipc/channels/clipboard-channels.ts
+var ClipboardChannels = class {
+  /** 读取文本 */
+  static readText = IpcUtil.channel("BuiltIn:Clipboard:readText");
+  /** 写入文本 */
+  static writeText = IpcUtil.channel("BuiltIn:Clipboard:writeText");
+  /** 写入图片 */
+  static writeImage = IpcUtil.channel("BuiltIn:Clipboard:writeImage");
+  /** 清空剪切板 */
+  static clear = IpcUtil.channel("BuiltIn:Clipboard:clear");
+};
+
+// src/preload/bridges/clipboard/clipboard-bridge.ts
+var ClipboardBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.clipboard}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      clipboard: {
+        // 读取文本
+        readText: this.readText.bind(this),
+        // 写入文本
+        writeText: this.writeText.bind(this),
+        // 写入图片
+        writeImage: this.writeImage.bind(this),
+        // 清空剪切板
+        clear: this.clear.bind(this)
+      }
+    };
+  }
+  /**
+   * 读取文本
+   * @returns {Promise<string>}
+   */
+  readText = async () => {
+    const text = await BridgeUtil.invoke(ClipboardChannels.readText);
+    return text ?? "";
+  };
+  /**
+   * 写入文本
+   * @param {string} text 文本
+   * @returns {Promise<void>}
+   */
+  writeText = async (text) => {
+    await BridgeUtil.invoke(ClipboardChannels.writeText, text);
+  };
+  /**
+   * 写入图片
+   * @param {string} dataURL 图片 DataURL
+   * @returns {Promise<void>}
+   */
+  writeImage = async (dataURL) => {
+    await BridgeUtil.invoke(ClipboardChannels.writeImage, dataURL);
+  };
+  /**
+   * 清空剪切板
+   * @returns {Promise<void>}
+   */
+  clear = async () => {
+    await BridgeUtil.invoke(ClipboardChannels.clear);
+  };
+};
+
+// src/shared/ipc/channels/context-menu-channels.ts
+var ContextMenuChannels = class {
+  /** 执行菜单命令 */
+  static executeCommand = IpcUtil.channel("BuiltIn:ContextMenu:executeCommand");
+  /* ------ 监听通道 ------ */
+  /** 监听上下文菜单请求 */
+  static onRequested = IpcUtil.channel("BuiltIn:ContextMenu:onRequested");
+};
+
+// src/preload/bridges/context-menu/context-menu-bridge.ts
+var ContextMenuBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.contextMenu}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      contextMenu: {
+        // 监听上下文菜单请求
+        onRequested: this.onRequested.bind(this),
+        // 执行菜单命令
+        executeCommand: this.executeCommand.bind(this)
+      }
+    };
+  }
+  /**
+   * 监听上下文菜单请求
+   * @param {XoMenu.ContextMenuRequestedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onRequested(listener) {
+    return BridgeUtil.on(ContextMenuChannels.onRequested, listener);
+  }
+  /**
+   * 执行菜单命令
+   * @param {XoMenu.ExecuteCommandRequest} request 请求
+   * @returns {Promise<boolean>}
+   */
+  executeCommand = async (request) => {
+    const success = await BridgeUtil.invoke(ContextMenuChannels.executeCommand, request);
+    return success ?? false;
+  };
+};
+
+// src/shared/ipc/channels/dialog-channels.ts
+var DialogChannels = class {
+  /** 打开文件 */
+  static openFile = IpcUtil.channel("BuiltIn:Dialog:openFile");
+  /** 打开目录 */
+  static openDir = IpcUtil.channel("BuiltIn:Dialog:openDir");
+  /** 保存文件 */
+  static saveFile = IpcUtil.channel("BuiltIn:Dialog:saveFile");
+};
+
+// src/preload/bridges/dialog/dialog-bridge.ts
+var DialogBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.dialog}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      dialog: {
+        // 打开文件选择框
+        openFile: this.openFile.bind(this),
+        // 打开目录选择框
+        openDir: this.openDir.bind(this),
+        // 打开文件保存框
+        saveFile: this.saveFile.bind(this)
+      }
+    };
+  }
+  /**
+   * 打开文件选择框
+   * @returns {Promise<XoDialog.OpenResult>}
+   */
+  openFile = async () => {
+    const openResult = await BridgeUtil.invoke(DialogChannels.openFile);
+    return openResult ?? { canceled: true, filePaths: [] };
+  };
+  /**
+   * 打开目录选择框
+   * @returns {Promise<XoDialog.OpenResult>}
+   */
+  openDir = async () => {
+    const openResult = await BridgeUtil.invoke(DialogChannels.openDir);
+    return openResult ?? { canceled: true, filePaths: [] };
+  };
+  /**
+   * 打开文件保存框
+   * @returns {Promise<XoDialog.SaveResult>}
+   */
+  saveFile = async () => {
+    const saveResult = await BridgeUtil.invoke(DialogChannels.saveFile);
+    return saveResult ?? { canceled: true, filePath: null };
+  };
+};
+
+// src/shared/ipc/channels/file-channels.ts
+var FileChannels = class {
+  /** 读取文本 */
+  static readText = IpcUtil.channel("BuiltIn:File:readText");
+  /** 写入文本 */
+  static writeText = IpcUtil.channel("BuiltIn:File:writeText");
+  /** 文件是否存在 */
+  static exists = IpcUtil.channel("BuiltIn:File:exists");
+};
+
+// src/preload/bridges/file/file-bridge.ts
+var FileBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.file}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      file: {
+        // 读取文本文件
+        readText: this.readText.bind(this),
+        // 写入文本文件
+        writeText: this.writeText.bind(this),
+        // 文件是否存在
+        exists: this.exists.bind(this)
+      }
+    };
+  }
+  /**
+   * 读取文本文件
+   * @param {string} path 文件路径
+   * @returns {Promise<string>}
+   */
+  readText = async (path) => {
+    const text = await BridgeUtil.invoke(FileChannels.readText, path);
+    return text ?? "";
+  };
+  /**
+   * 写入文本文件
+   * @param {string} path    文件路径
+   * @param {string} content 内容
+   * @returns {Promise<boolean>}
+   */
+  writeText = async (path, content) => {
+    const request = { path, content };
+    const success = await BridgeUtil.invoke(FileChannels.writeText, request);
+    return success ?? false;
+  };
+  /**
+   * 文件是否存在
+   * @param {string} path 文件路径
+   * @returns {Promise<boolean>}
+   */
+  exists = async (path) => {
+    const exists = await BridgeUtil.invoke(FileChannels.exists, path);
+    return exists ?? false;
+  };
+};
+
+// src/preload/bridges/ipc/ipc-bridge.ts
+var IpcBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.ipc}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      ipc: {
+        // 调用主进程方法
+        invoke: this.invoke.bind(this),
+        // 给主进程发送消息
+        send: this.send.bind(this),
+        // 监听主进程消息
+        on: this.on.bind(this),
+        // 单次监听主进程消息
+        once: this.once.bind(this)
+      }
+    };
+  }
+  /**
+   * 调用主进程方法（内置）
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any}           request 参数
+   * @returns {Promise<XoIpc.Result>}
+   */
+  invoke = async (channel, request) => {
+    return await BridgeUtil.invokeResult(channel, request);
+  };
+  /**
+   * 给主进程发送消息（内置）
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any}           request 参数
+   */
+  send = (channel, request) => {
+    BridgeUtil.send(channel, request);
+  };
+  /**
+   * 监听主进程消息（内置）
+   * <p>支持主动解除监听</p>
+   * <p>const off = window.xion.ipc.on(channel, listener); off()</p>
+   * @param {XoIpc.Channel}  channel  通道
+   * @param {XoIpc.Listener} listener 监听器
+   * @returns {() => void}
+   */
+  on = (channel, listener) => {
+    return BridgeUtil.on(channel, listener);
+  };
+  /**
+   * 单次监听主进程消息（内置）
+   * @param {XoIpc.Channel}  channel  通道
+   * @param {XoIpc.Listener} listener 监听器
+   */
+  once = (channel, listener) => {
+    BridgeUtil.once(channel, listener);
+  };
+};
+
+// src/shared/ipc/channels/log-channels.ts
+var LogChannels = class {
+  /** 写入 debug 日志 */
+  static debug = IpcUtil.channel("BuiltIn:Log:debug");
+  /** 写入 info 日志 */
+  static info = IpcUtil.channel("BuiltIn:Log:info");
+  /** 写入 warn 日志 */
+  static warn = IpcUtil.channel("BuiltIn:Log:warn");
+  /** 写入 error 日志 */
+  static error = IpcUtil.channel("BuiltIn:Log:error");
+};
+
+// src/shared/utils/log-util.ts
+var MaxMessageLength = 16 * 1024;
+var MaxValueLength = 8 * 1024;
+var MaxDataItems = 100;
+var MaxCollectionItems = 100;
+var MaxDepth = 10;
+var MaxNodes = 500;
+var LogUtil = class _LogUtil {
+  /**
+   * 标准化渲染进程日志请求
+   * @param {unknown} message 日志消息
+   * @param {unknown} data    附加数据
+   * @returns {XoIpcLogger.Request}
+   */
+  static normalizeRequest(message, data) {
+    const budget = { remaining: MaxNodes };
+    const seen = /* @__PURE__ */ new WeakSet();
+    return {
+      message: _LogUtil.normalizeText(typeof message === "string" ? message : String(message ?? ""), MaxMessageLength),
+      data: (Array.isArray(data) ? data : []).slice(0, MaxDataItems).map((value) => _LogUtil.normalizeValue(value, 0, seen, budget))
+    };
+  }
+  /**
+   * 标准化日志值
+   * @param {unknown}         value            原始值
+   * @param {number}          depth            当前深度
+   * @param {WeakSet<object>} seen             已处理对象
+   * @param {NormalizeBudget} budget           处理预算
+   * @param {boolean}         preserveNewlines 是否保留换行
+   * @returns {XoIpcLogger.Value}
+   * @private
+   */
+  static normalizeValue(value, depth, seen, budget, preserveNewlines = false) {
+    if (budget.remaining <= 0) return "[Truncated]";
+    budget.remaining--;
+    if (value === null) return null;
+    if (typeof value === "string") return _LogUtil.normalizeText(value, MaxValueLength, preserveNewlines);
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "undefined") return "[undefined]";
+    if (typeof value === "symbol") return `[Symbol ${value.description ?? ""}]`;
+    if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? "[Invalid Date]" : value.toISOString();
+    }
+    if (value instanceof Error) {
+      return {
+        name: _LogUtil.normalizeText(value.name, MaxValueLength),
+        message: _LogUtil.normalizeText(value.message, MaxValueLength),
+        stack: _LogUtil.normalizeText(value.stack ?? "", MaxValueLength, true)
+      };
+    }
+    if (depth >= MaxDepth) return "[Max Depth]";
+    if (seen.has(value)) return "[Circular]";
+    seen.add(value);
+    try {
+      if (Array.isArray(value)) {
+        return value.slice(0, MaxCollectionItems).map((item) => _LogUtil.normalizeValue(item, depth + 1, seen, budget));
+      }
+      return Object.fromEntries(
+        Object.entries(value).slice(0, MaxCollectionItems).map(([key, item]) => [
+          _LogUtil.normalizeText(key, 128),
+          _LogUtil.normalizeValue(item, depth + 1, seen, budget, key === "stack")
+        ])
+      );
+    } catch {
+      return "[Unserializable Object]";
+    } finally {
+      seen.delete(value);
+    }
+  }
+  /**
+   * 清理日志文本中的控制字符并限制长度
+   * @param {string}  text             原始文本
+   * @param {number}  maxLength        最大长度
+   * @param {boolean} preserveNewlines 是否保留换行
+   * @returns {string}
+   * @private
+   */
+  static normalizeText(text, maxLength, preserveNewlines = false) {
+    const normalized = preserveNewlines ? text.replace(/\r\n?/g, "\n") : text.replace(/\r\n?|\n/g, "\\n");
+    return normalized.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").slice(0, maxLength);
+  }
+};
+
+// src/preload/bridges/log/log-bridge.ts
+var LogBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.log}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      log: {
+        debug: this.debug.bind(this),
+        info: this.info.bind(this),
+        warn: this.warn.bind(this),
+        error: this.error.bind(this)
+      }
+    };
+  }
+  /**
+   * 写入 debug 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  debug = async (message, ...data) => {
+    await this.write(LogChannels.debug, message, data);
+  };
+  /**
+   * 写入 info 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  info = async (message, ...data) => {
+    await this.write(LogChannels.info, message, data);
+  };
+  /**
+   * 写入 warn 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  warn = async (message, ...data) => {
+    await this.write(LogChannels.warn, message, data);
+  };
+  /**
+   * 写入 error 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  error = async (message, ...data) => {
+    await this.write(LogChannels.error, message, data);
+  };
+  /**
+   * 写入日志
+   * @param {XoIpc.Channel} channel 日志通道
+   * @param {string}        message 日志消息
+   * @param {unknown[]}     data    附加数据
+   * @returns {Promise<void>}
+   * @private
+   */
+  async write(channel, message, data) {
+    try {
+      const request = LogUtil.normalizeRequest(message, data);
+      await BridgeUtil.invoke(channel, request);
+    } catch {
+    }
+  }
+};
+
+// src/shared/ipc/channels/remote-service-channels.ts
+var RemoteServiceChannels = class {
+  /** 获取远程服务状态 */
+  static getState = IpcUtil.channel("BuiltIn:RemoteService:getState");
+  /** 获取远程服务设置 */
+  static getSettings = IpcUtil.channel("BuiltIn:RemoteService:getSettings");
+  /** 设置远程服务用户设置 */
+  static setSettings = IpcUtil.channel("BuiltIn:RemoteService:setSettings");
+  /** 重置远程服务用户设置 */
+  static resetSettings = IpcUtil.channel("BuiltIn:RemoteService:resetSettings");
+  /** 请求远程服务 API */
+  static request = IpcUtil.channel("BuiltIn:RemoteService:request");
+  /* ------ 监听通道 ------ */
+  /** 监听远程服务状态 */
+  static onState = IpcUtil.channel("BuiltIn:RemoteService:onState");
+  /** 监听远程服务设置 */
+  static onSettings = IpcUtil.channel("BuiltIn:RemoteService:onSettings");
+};
+
+// src/preload/bridges/remote-service/remote-service-bridge.ts
+var RemoteServiceBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.remoteService}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      remoteService: {
+        // 获取远程服务状态
+        getState: this.getState.bind(this),
+        // 获取远程服务设置
+        getSettings: this.getSettings.bind(this),
+        // 设置远程服务用户设置
+        setSettings: this.setSettings.bind(this),
+        // 重置远程服务用户设置
+        resetSettings: this.resetSettings.bind(this),
+        // 请求远程服务 API
+        request: this.request.bind(this),
+        // 监听远程服务状态
+        onState: this.onState.bind(this),
+        // 监听远程服务设置
+        onSettings: this.onSettings.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取远程服务状态
+   * @returns {Promise<XoRemoteService.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(RemoteServiceChannels.getState);
+    return state ?? {
+      status: "idle",
+      reconnectCount: 0
+    };
+  };
+  /**
+   * 获取远程服务设置
+   * @returns {Promise<XoRemoteService.EffectiveSettings>}
+   */
+  getSettings = async () => {
+    const settings = await BridgeUtil.invoke(RemoteServiceChannels.getSettings);
+    return settings;
+  };
+  /**
+   * 设置远程服务用户设置
+   * @param {XoRemoteService.UserSettings} settings 远程服务用户设置
+   * @returns {Promise<void>}
+   */
+  setSettings = async (settings) => {
+    await BridgeUtil.invoke(RemoteServiceChannels.setSettings, settings);
+  };
+  /**
+   * 重置远程服务用户设置
+   * @returns {Promise<void>}
+   */
+  resetSettings = async () => {
+    await BridgeUtil.invoke(RemoteServiceChannels.resetSettings);
+  };
+  /**
+   * 请求远程服务 API
+   * @template T 响应数据类型
+   * @param {XoRemoteService.Request} request 请求参数
+   * @returns {Promise<XoRemoteService.Response<T>>}
+   */
+  request = async (request) => {
+    const response = await BridgeUtil.invoke(RemoteServiceChannels.request, request);
+    return response;
+  };
+  /**
+   * 监听远程服务状态
+   * @param {XoRemoteService.StateListener} listener 监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(RemoteServiceChannels.onState, listener);
+  };
+  /**
+   * 监听远程服务设置
+   * @param {XoRemoteService.SettingsListener} listener 监听器
+   * @returns {() => void}
+   */
+  onSettings = (listener) => {
+    return BridgeUtil.on(RemoteServiceChannels.onSettings, listener);
+  };
+};
+
+// src/shared/ipc/channels/shell-channels.ts
+var ShellChannels = class {
+  /** 使用系统默认程序打开路径 */
+  static openPath = IpcUtil.channel("BuiltIn:Shell:openPath");
+  /** 在文件管理器中显示路径 */
+  static showItemInFolder = IpcUtil.channel("BuiltIn:Shell:showItemInFolder");
+};
+
+// src/preload/bridges/shell/shell-bridge.ts
+var ShellBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.shell}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      shell: {
+        // 使用系统默认程序打开路径
+        openPath: this.openPath.bind(this),
+        // 在文件管理器中显示路径
+        showItemInFolder: this.showItemInFolder.bind(this)
+      }
+    };
+  }
+  /**
+   * 使用系统默认程序打开路径
+   * @param {string} path 路径
+   * @returns {Promise<void>}
+   */
+  openPath = async (path) => {
+    await BridgeUtil.invoke(ShellChannels.openPath, path);
+  };
+  /**
+   * 在文件管理器中显示路径
+   * @param {string} path 路径
+   * @returns {Promise<void>}
+   */
+  showItemInFolder = async (path) => {
+    await BridgeUtil.invoke(ShellChannels.showItemInFolder, path);
+  };
+};
+
+// src/shared/ipc/channels/theme-channels.ts
+var ThemeChannels = class {
+  /** 获取主题状态 */
+  static getState = IpcUtil.channel("BuiltIn:Theme:getState");
+  /** 设置主题来源 */
+  static setSource = IpcUtil.channel("BuiltIn:Theme:setSource");
+  /* ------ 监听通道 ------ */
+  /** 监听主题更新 */
+  static onUpdate = IpcUtil.channel("BuiltIn:Theme:onUpdate");
+};
+
+// src/preload/bridges/theme/theme-bridge.ts
+var ThemeBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.theme}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      theme: {
+        // 获取主题状态
+        getState: this.getState.bind(this),
+        // 设置主题来源
+        setSource: this.setSource.bind(this),
+        // 监听主题更新
+        onUpdated: this.onUpdated.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取主题状态
+   * @returns {Promise<XoTheme.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(ThemeChannels.getState);
+    return state ?? {
+      themeSource: "system",
+      shouldUseDarkColors: false,
+      titleBarOverlayEnabled: false,
+      titleBarOverlay: {},
+      titleBarOverlayBackground: void 0
+    };
+  };
+  /**
+   * 设置主题来源
+   * @param {XoTheme.Source} themeSource 主题来源
+   * @returns {Promise<void>}
+   */
+  setSource = async (themeSource) => {
+    await BridgeUtil.invoke(ThemeChannels.setSource, themeSource);
+  };
+  /**
+   * 监听主题更新
+   * @param {XoTheme.UpdatedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onUpdated = (listener) => {
+    return BridgeUtil.on(ThemeChannels.onUpdate, listener);
+  };
+};
+
+// src/shared/ipc/channels/updater-channels.ts
+var UpdaterChannels = class {
+  /** 检查更新 */
+  static checkForUpdates = IpcUtil.channel("BuiltIn:Updater:checkForUpdates");
+  /** 下载更新 */
+  static downloadUpdate = IpcUtil.channel("BuiltIn:Updater:downloadUpdate");
+  /** 取消下载 */
+  static cancelDownload = IpcUtil.channel("BuiltIn:Updater:cancelDownload");
+  /** 退出并安装更新 */
+  static quitAndInstall = IpcUtil.channel("BuiltIn:Updater:quitAndInstall");
+  /** 获取更新器状态 */
+  static getState = IpcUtil.channel("BuiltIn:Updater:getState");
+  /** 获取更新器设置 */
+  static getSettings = IpcUtil.channel("BuiltIn:Updater:getSettings");
+  /** 设置更新器用户设置 */
+  static setSettings = IpcUtil.channel("BuiltIn:Updater:setSettings");
+  /** 重置更新器用户设置 */
+  static resetSettings = IpcUtil.channel("BuiltIn:Updater:resetSettings");
+  /* ------ 监听通道 ------ */
+  /** 监听更新器状态 */
+  static onState = IpcUtil.channel("BuiltIn:Updater:onState");
+  /** 监听更新器设置 */
+  static onSettings = IpcUtil.channel("BuiltIn:Updater:onSettings");
+};
+
+// src/preload/bridges/updater/updater-bridge.ts
+var UpdaterBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.updater}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      updater: {
+        // 检查更新
+        checkForUpdates: this.checkForUpdates.bind(this),
+        // 下载更新
+        downloadUpdate: this.downloadUpdate.bind(this),
+        // 取消下载
+        cancelDownload: this.cancelDownload.bind(this),
+        // 退出并安装更新
+        quitAndInstall: this.quitAndInstall.bind(this),
+        // 获取更新器状态
+        getState: this.getState.bind(this),
+        // 获取更新器设置
+        getSettings: this.getSettings.bind(this),
+        // 设置更新器用户设置
+        setSettings: this.setSettings.bind(this),
+        // 重置更新器用户设置
+        resetSettings: this.resetSettings.bind(this),
+        // 监听更新器状态
+        onState: this.onState.bind(this),
+        // 监听更新器设置
+        onSettings: this.onSettings.bind(this)
+      }
+    };
+  }
+  /**
+   * 检查更新
+   * @returns {Promise<void>}
+   */
+  checkForUpdates = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.checkForUpdates);
+  };
+  /**
+   * 下载更新
+   * @returns {Promise<void>}
+   */
+  downloadUpdate = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.downloadUpdate);
+  };
+  /**
+   * 取消下载
+   * @returns {Promise<boolean>}
+   */
+  cancelDownload = async () => {
+    const cancelled = await BridgeUtil.invoke(UpdaterChannels.cancelDownload);
+    return cancelled ?? false;
+  };
+  /**
+   * 退出并安装更新
+   * @returns {Promise<void>}
+   */
+  quitAndInstall = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.quitAndInstall);
+  };
+  /**
+   * 获取更新器状态
+   * @returns {Promise<XoUpdater.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(UpdaterChannels.getState);
+    return state ?? {
+      status: "idle",
+      downloadCancellationCount: 0,
+      disabledUntilRestart: false
+    };
+  };
+  /**
+   * 获取更新器设置
+   * @returns {Promise<XoUpdater.EffectiveSettings>}
+   */
+  getSettings = async () => {
+    const settings = await BridgeUtil.invoke(UpdaterChannels.getSettings);
+    return settings;
+  };
+  /**
+   * 设置更新器用户设置
+   * @param {XoUpdater.UserSettings} settings 更新器用户设置
+   */
+  setSettings = async (settings) => {
+    await BridgeUtil.invoke(UpdaterChannels.setSettings, settings);
+  };
+  /**
+   * 重置更新器用户设置
+   */
+  resetSettings = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.resetSettings);
+  };
+  /**
+   * 监听更新器状态
+   * @param {XoUpdater.UpdatedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(UpdaterChannels.onState, listener);
+  };
+  /**
+   * 监听更新器设置
+   * @param {XoUpdater.SettingsUpdatedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onSettings = (listener) => {
+    return BridgeUtil.on(UpdaterChannels.onSettings, listener);
+  };
+};
+
+// src/preload/bridges/window/internal/route-redirect-buffer.ts
+var RouteRedirectBuffer = class {
+  /** Renderer 是否已完成初始化 */
+  rendererReady = false;
+  /** Renderer 路由重定向监听器 */
+  listener;
+  /** 等待分发的路由重定向请求 */
+  pendingRequests = [];
+  /**
+   * 接收路由重定向请求
+   * @param {XoWindow.RouteRedirectRequest} request 路由重定向请求
+   * @returns {void}
+   */
+  receive(request) {
+    if (!this.rendererReady || !this.listener) {
+      this.pendingRequests.push(request);
+      return;
+    }
+    this.listener(request);
+  }
+  /**
+   * 设置 Renderer 路由重定向监听器
+   * @param {XoWindow.RouteRedirectListener} listener 路由重定向监听器
+   * @returns {() => void}
+   */
+  setListener(listener) {
+    this.listener = listener;
+    this.flush();
+    return () => {
+      if (this.listener === listener) {
+        this.listener = void 0;
+      }
+    };
+  }
+  /**
+   * 标记 Renderer 已完成初始化
+   * @returns {void}
+   */
+  setReady() {
+    this.rendererReady = true;
+    this.flush();
+  }
+  /**
+   * 分发等待中的路由重定向请求
+   * @returns {void}
+   * @private
+   */
+  flush() {
+    const listener = this.listener;
+    if (!this.rendererReady || !listener) {
+      return;
+    }
+    for (const request of this.pendingRequests.splice(0)) {
+      listener(request);
+    }
+  }
+};
+
+// src/shared/ipc/channels/window-channels.ts
+var WindowChannels = class {
+  /** 渲染进程首屏渲染完成 */
+  static ready = IpcUtil.channel("BuiltIn:Window:ready");
+  /** 是否等待 Renderer 渲染完成后再显示窗口 */
+  static shouldShowAfterRendererReady = IpcUtil.channel("BuiltIn:Window:shouldShowAfterRendererReady");
+  /** 获取窗口状态 */
+  static getState = IpcUtil.channel("BuiltIn:Window:getState");
+  /** 获取当前已打开窗口标识 */
+  static getOpenedWindowIdentities = IpcUtil.channel("BuiltIn:Window:getOpenedWindowIdentities");
+  /** 最小化窗口 */
+  static minimize = IpcUtil.channel("BuiltIn:Window:minimize");
+  /** 最大化窗口 */
+  static maximize = IpcUtil.channel("BuiltIn:Window:maximize");
+  /** 是否已最大化 */
+  static isMaximized = IpcUtil.channel("BuiltIn:Window:isMaximized");
+  /** 取消最大化窗口 */
+  static unmaximize = IpcUtil.channel("BuiltIn:Window:unmaximize");
+  /** 全屏窗口 */
+  static fullScreen = IpcUtil.channel("BuiltIn:Window:fullScreen");
+  /** 退出全屏窗口 */
+  static exitFullScreen = IpcUtil.channel("BuiltIn:Window:exitFullScreen");
+  /** 重新加载窗口 */
+  static reload = IpcUtil.channel("BuiltIn:Window:reload");
+  /** 居中窗口 */
+  static center = IpcUtil.channel("BuiltIn:Window:center");
+  /** 隐藏窗口 */
+  static hide = IpcUtil.channel("BuiltIn:Window:hide");
+  /** 还原窗口 */
+  static restore = IpcUtil.channel("BuiltIn:Window:restore");
+  /** 切换窗口置顶 */
+  static toggleAlwaysOnTop = IpcUtil.channel("BuiltIn:Window:toggleAlwaysOnTop");
+  /** 切换侧边栏折叠 */
+  static toggleSidebarFold = IpcUtil.channel("BuiltIn:Window:toggleSidebarFold");
+  /** 关闭窗口 */
+  static close = IpcUtil.channel("BuiltIn:Window:close");
+  /* ------ 监听通道 ------ */
+  /** 监听窗口状态 */
+  static onState = IpcUtil.channel("BuiltIn:Window:onState");
+  /** 监听路由重定向 */
+  static onRouteRedirect = IpcUtil.channel("BuiltIn:Window:onRouteRedirect");
+};
+
+// src/preload/bridges/window/window-bridge.ts
+var WindowBridge = class extends BridgeAbstract {
+  /** 路由重定向请求缓冲器 */
+  routeRedirectBuffer = new RouteRedirectBuffer();
+  /**
+   * 构造函数
+   */
+  constructor() {
+    super();
+    BridgeUtil.on(WindowChannels.onRouteRedirect, (request) => this.routeRedirectBuffer.receive(request));
+  }
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.window}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      window: {
+        // 通知主进程渲染进程首屏渲染完成
+        ready: this.ready.bind(this),
+        // 是否等待 Renderer 渲染完成后再显示窗口
+        shouldShowAfterRendererReady: this.shouldShowAfterRendererReady.bind(this),
+        // 获取窗口状态
+        getState: this.getState.bind(this),
+        // 获取当前已打开窗口标识
+        getOpenedWindowIdentities: this.getOpenedWindowIdentities.bind(this),
+        // 最小化窗口
+        minimize: this.minimize.bind(this),
+        // 最大化窗口
+        maximize: this.maximize.bind(this),
+        // 是否已最大化
+        isMaximized: this.isMaximized.bind(this),
+        // 取消最大化窗口
+        unmaximize: this.unmaximize.bind(this),
+        // 全屏窗口
+        fullScreen: this.fullScreen.bind(this),
+        // 退出全屏窗口
+        exitFullScreen: this.exitFullScreen.bind(this),
+        // 重新加载窗口
+        reload: this.reload.bind(this),
+        // 居中窗口
+        center: this.center.bind(this),
+        // 隐藏窗口
+        hide: this.hide.bind(this),
+        // 还原窗口
+        restore: this.restore.bind(this),
+        // 切换窗口置顶
+        toggleAlwaysOnTop: this.toggleAlwaysOnTop.bind(this),
+        // 切换侧边栏折叠
+        toggleSidebarFold: this.toggleSidebarFold.bind(this),
+        // 关闭窗口
+        close: this.close.bind(this),
+        // 监听窗口状态
+        onState: this.onState.bind(this),
+        // 监听路由重定向
+        onRouteRedirect: this.onRouteRedirect.bind(this)
+      }
+    };
+  }
+  /**
+   * 通知主进程渲染进程首屏渲染完成
+   * @returns {Promise<void>}
+   */
+  ready = async () => {
+    this.routeRedirectBuffer.setReady();
+    await BridgeUtil.invoke(WindowChannels.ready);
+  };
+  /**
+   * 是否等待 Renderer 渲染完成后再显示窗口
+   * @returns {Promise<boolean>}
+   */
+  shouldShowAfterRendererReady = async () => {
+    const enabled = await BridgeUtil.invoke(WindowChannels.shouldShowAfterRendererReady);
+    return enabled ?? true;
+  };
+  /**
+   * 获取窗口状态
+   * @returns {Promise<XoWindow.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(WindowChannels.getState);
+    return state ?? {
+      isSidebarFolded: false,
+      isAlwaysOnTop: false,
+      isMaximized: false,
+      isFullScreen: false,
+      isMinimized: false,
+      isFullScreenable: false,
+      isMinimizable: false,
+      isMaximizable: false,
+      isClosable: false
+    };
+  };
+  /**
+   * 获取当前已打开窗口标识
+   * @returns {Promise<XoWindow.Identity[]>}
+   */
+  getOpenedWindowIdentities = async () => {
+    return await BridgeUtil.invoke(WindowChannels.getOpenedWindowIdentities) ?? [];
+  };
+  /**
+   * 最小化窗口
+   * @returns {Promise<void>}
+   */
+  minimize = async () => {
+    await BridgeUtil.invoke(WindowChannels.minimize);
+  };
+  /**
+   * 最大化窗口
+   * @returns {Promise<void>}
+   */
+  maximize = async () => {
+    await BridgeUtil.invoke(WindowChannels.maximize);
+  };
+  /**
+   * 是否已最大化
+   * @returns {Promise<boolean>}
+   */
+  isMaximized = async () => {
+    const maximized = await BridgeUtil.invoke(WindowChannels.isMaximized);
+    return maximized ?? false;
+  };
+  /**
+   * 取消最大化窗口
+   * @returns {Promise<void>}
+   */
+  unmaximize = async () => {
+    await BridgeUtil.invoke(WindowChannels.unmaximize);
+  };
+  /**
+   * 全屏窗口
+   * @returns {Promise<void>}
+   */
+  fullScreen = async () => {
+    await BridgeUtil.invoke(WindowChannels.fullScreen);
+  };
+  /**
+   * 退出全屏窗口
+   * @returns {Promise<void>}
+   */
+  exitFullScreen = async () => {
+    await BridgeUtil.invoke(WindowChannels.exitFullScreen);
+  };
+  /**
+   * 重新加载窗口
+   * @returns {Promise<void>}
+   */
+  reload = async () => {
+    await BridgeUtil.invoke(WindowChannels.reload);
+  };
+  /**
+   * 居中窗口
+   * @returns {Promise<void>}
+   */
+  center = async () => {
+    await BridgeUtil.invoke(WindowChannels.center);
+  };
+  /**
+   * 隐藏窗口
+   * @returns {Promise<void>}
+   */
+  hide = async () => {
+    await BridgeUtil.invoke(WindowChannels.hide);
+  };
+  /**
+   * 还原窗口
+   * @returns {Promise<void>}
+   */
+  restore = async () => {
+    await BridgeUtil.invoke(WindowChannels.restore);
+  };
+  /**
+   * 切换窗口置顶
+   * @returns {Promise<void>}
+   */
+  toggleAlwaysOnTop = async () => {
+    await BridgeUtil.invoke(WindowChannels.toggleAlwaysOnTop);
+  };
+  /**
+   * 切换侧边栏折叠
+   * @returns {Promise<void>}
+   */
+  toggleSidebarFold = async () => {
+    await BridgeUtil.invoke(WindowChannels.toggleSidebarFold);
+  };
+  /**
+   * 关闭窗口
+   * @returns {Promise<void>}
+   */
+  close = async () => {
+    await BridgeUtil.invoke(WindowChannels.close);
+  };
+  /**
+   * 监听窗口状态
+   * @param {XoWindow.StateListener} listener 监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(WindowChannels.onState, listener);
+  };
+  /**
+   * 监听路由重定向
+   * @param {XoWindow.RouteRedirectListener} listener 监听器
+   * @returns {() => void}
+   */
+  onRouteRedirect = (listener) => {
+    return this.routeRedirectBuffer.setListener(listener);
+  };
+};
+
+// src/shared/app/consts/xion-name.ts
+var XionName = "Xion";
+
+// src/preload/bridge/bridge.ts
+var import_electron2 = require("electron");
+var Bridge = class _Bridge {
+  /**
+   * 是否已安装（window.xion）
+   * @type {boolean}
+   * @private
+   */
+  static installed = false;
+  /**
+   * 已安装接口名称
+   * @type {Set<string>}
+   * @private
+   */
+  static installedApiKeys = /* @__PURE__ */ new Set();
+  /**
+   * 安装桥接器（接口挂载到 window.xion 上）
+   * <p>仅允许执行一次</p>
+   * @param {(new () => BridgeAbstract)[]} bridges 桥接器实现列表
+   */
+  static install(bridges) {
+    if (_Bridge.installed) {
+      throw new Error("Bridge \u91CD\u590D\u5B89\u88C5");
+    }
+    _Bridge.installed = true;
+    _Bridge.customInstall(XionName.toLowerCase(), bridges);
+  }
+  /**
+   * 自定义安装（接口挂载到 window.[apiKey] 上）
+   * <p>可以多次执行，但同一 apiKey 仅能安装一次</p>
+   * @param {string}                       apiKey  接口名称
+   * @param {(new () => BridgeAbstract)[]} bridges 桥接器实现列表
+   */
+  static customInstall(apiKey, bridges) {
+    if (_Bridge.installedApiKeys.has(apiKey)) {
+      throw new Error(`Bridge \u63A5\u53E3\u91CD\u590D\u5B89\u88C5: ${apiKey}`);
+    }
+    const builtInBridges = apiKey === XionName.toLowerCase() ? [
+      // APP 桥接器
+      AppBridge,
+      // JWT 认证桥接器
+      AuthBridge,
+      // 对话框桥接器
+      DialogBridge,
+      // 剪切板桥接器
+      ClipboardBridge,
+      // 文件桥接器
+      FileBridge,
+      // 主题桥接器
+      ThemeBridge,
+      // Shell 桥接器
+      ShellBridge,
+      // IPC 桥接器
+      IpcBridge,
+      // 日志桥接器
+      LogBridge,
+      // 上下文菜单桥接器
+      ContextMenuBridge,
+      // 窗口桥接器
+      WindowBridge,
+      // 更新器桥接器
+      UpdaterBridge,
+      // 远程服务桥接器
+      RemoteServiceBridge
+    ] : [];
+    const bridgeList = [
+      // 内置桥接器
+      ...builtInBridges,
+      // 自定义桥接器
+      ...bridges ?? []
+    ];
+    const apis = {};
+    for (let bridge of bridgeList) {
+      const apiBridge = new bridge();
+      const apiMap = apiBridge.apiMap();
+      for (let key in apiMap) {
+        apis[key] = apiMap[key];
+      }
+    }
+    import_electron2.contextBridge.exposeInMainWorld(apiKey, apis);
+    _Bridge.installedApiKeys.add(apiKey);
+  }
+};
+
+// src/preload/bridge/preload.internal.ts
+Bridge.install();