@aiot-nexus/plugin-sdk 2.0.2 → 2.1.1

package/dist/internal/src-electron/main/plugins/plugin-electron-facade-broker.js

@@ -0,0 +1,890 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginElectronFacadeBrokerService = void 0;
+const path = __importStar(require("path"));
+const plugin_electron_facade_1 = require("../../shared/plugin-electron-facade");
+const plugin_electron_facade_descriptors_1 = require("../../shared/plugin-electron-facade-descriptors");
+const runtime_result_1 = require("../core/runtime-result");
+class ElectronFacadeBrokerError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ElectronFacadeBrokerError";
+    }
+}
+const basicModules = new Set(plugin_electron_facade_descriptors_1.electronFacadeExportDescriptors
+    .filter((descriptor) => descriptor.defaultAccess === "basic")
+    .map((descriptor) => descriptor.name));
+const ownedConstructorModules = new Set(plugin_electron_facade_descriptors_1.electronFacadeExportDescriptors
+    .filter((descriptor) => descriptor.defaultAccess === "owned" && descriptor.kind === "constructor")
+    .map((descriptor) => descriptor.name));
+const ownedServiceModules = new Set(plugin_electron_facade_descriptors_1.electronFacadeExportDescriptors
+    .filter((descriptor) => descriptor.defaultAccess === "owned" && descriptor.kind === "module")
+    .map((descriptor) => descriptor.name));
+const defaultAppMembers = new Set([
+    "getAppPath",
+    "getLocale",
+    "getLocaleCountryCode",
+    "getName",
+    "getPath",
+    "getVersion",
+    "isDefaultProtocolClient",
+    "isPackaged",
+    "isReady",
+    "name",
+    "userAgentFallback"
+]);
+class PluginElectronFacadeBrokerService {
+    constructor(injectedRoot) {
+        this.injectedRoot = injectedRoot;
+        this.states = new Map();
+        this.nextGeneration = 0;
+    }
+    attachPlugin(pluginId, binding) {
+        this.disposePlugin(pluginId);
+        const namespaceId = pluginId.replace(/[^a-z0-9._-]/gi, "-");
+        this.states.set(pluginId, {
+            pluginId,
+            binding,
+            generation: ++this.nextGeneration,
+            nextHandleId: 0,
+            handles: new Map(),
+            reverseHandles: new WeakMap(),
+            shortcuts: new Set(),
+            powerSaveBlockers: new Set(),
+            ipcHandlers: new Set(),
+            ipcListeners: [],
+            protocols: [],
+            sessionPartition: "persist:nexus-plugin:" + namespaceId,
+            ipcNamespace: "nexus-plugin:" + namespaceId + ":",
+            protocolNamespace: "nexus-plugin-" + namespaceId + "-"
+        });
+    }
+    async invoke(pluginId, value) {
+        if (!(0, plugin_electron_facade_1.isElectronFacadeRequest)(value)) {
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.InvalidRequest, "Electron facade request is invalid.");
+        }
+        const state = this.states.get(pluginId);
+        if (!state) {
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ProcessUnavailable, "Electron facade plugin generation is unavailable.");
+        }
+        try {
+            if (value.operation === "release") {
+                if (!this.releaseHandle(state, value.handleId)) {
+                    return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.HandleReleased, "Electron facade handle was already released.", {
+                        handleId: value.handleId
+                    });
+                }
+                return (0, runtime_result_1.ok)({ $nexusElectron: "undefined" });
+            }
+            if (value.operation === "construct") {
+                return this.construct(pluginId, state, value);
+            }
+            const targetResult = this.resolveTarget(state, value);
+            if (!targetResult.ok) {
+                return targetResult;
+            }
+            const target = targetResult.value;
+            const member = value.member;
+            if (value.operation === "get") {
+                const handle = value.handleId ? state.handles.get(value.handleId) : undefined;
+                if (handle?.typeName === "Session" && member === "protocol") {
+                    const protocol = Reflect.get(handle.value, member);
+                    if (!isObjectLike(protocol)) {
+                        return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.MemberUnavailable, "Electron Session protocol is unavailable.");
+                    }
+                    return (0, runtime_result_1.ok)(this.encodeHandle(pluginId, state, this.createProtocolModuleTarget(state, state.binding.hostControl, protocol), { typeName: state.binding.hostControl ? "Protocol" : "PluginProtocol" }));
+                }
+                return (0, runtime_result_1.ok)(this.encodeResult(pluginId, state, Reflect.get(target, member)));
+            }
+            if (value.operation === "set") {
+                if (value.module && !state.binding.hostControl) {
+                    return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.MemberUnavailable, "Electron facade modules are read-only.", { module: value.module, member });
+                }
+                const decoded = this.decodeArguments(pluginId, state, value.args || []);
+                if (!Reflect.set(target, member, decoded[0])) {
+                    return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.InvocationFailed, "Electron facade property could not be assigned.", { member });
+                }
+                return (0, runtime_result_1.ok)({ $nexusElectron: "undefined" });
+            }
+            if (value.operation === "on" || value.operation === "once") {
+                return this.subscribe(pluginId, state, target, member, value.args?.[0], value.operation === "once");
+            }
+            const candidate = Reflect.get(target, member);
+            if (typeof candidate !== "function") {
+                return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.MemberUnavailable, "Electron facade member is not callable.", {
+                    module: value.module,
+                    handleId: value.handleId,
+                    member
+                });
+            }
+            this.assertSpecialMemberAvailable(state, value, member);
+            const args = this.decodeArguments(pluginId, state, value.args || []);
+            const result = await candidate.apply(target, args);
+            if (this.states.get(pluginId) !== state) {
+                this.disposeDetachedValue(result);
+                return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ProcessUnavailable, "Electron facade plugin generation changed during invocation.");
+            }
+            return (0, runtime_result_1.ok)(this.encodeCallResult(pluginId, state, value.module, member, result));
+        }
+        catch (error) {
+            if (error instanceof ElectronFacadeBrokerError) {
+                return (0, runtime_result_1.fail)(error.code, error.message);
+            }
+            if (error instanceof plugin_electron_facade_1.ElectronFacadeCodecError) {
+                return (0, runtime_result_1.fail)(error.code, error.message);
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.InvocationFailed, "Electron facade invocation failed.", message);
+        }
+    }
+    disposePlugin(pluginId) {
+        const state = this.states.get(pluginId);
+        if (!state) {
+            return;
+        }
+        this.states.delete(pluginId);
+        for (const handleId of Array.from(state.handles.keys()).reverse()) {
+            this.releaseHandle(state, handleId);
+        }
+        const root = this.electronRootIfAvailable();
+        const globalShortcut = asObject(root?.globalShortcut);
+        for (const accelerator of state.shortcuts) {
+            safeCall(globalShortcut, "unregister", accelerator);
+        }
+        const powerSaveBlocker = asObject(root?.powerSaveBlocker);
+        for (const blockerId of state.powerSaveBlockers) {
+            safeCall(powerSaveBlocker, "stop", blockerId);
+        }
+        state.shortcuts.clear();
+        state.powerSaveBlockers.clear();
+        const ipcMain = asObject(root?.ipcMain);
+        for (const channel of state.ipcHandlers) {
+            safeCall(ipcMain, "removeHandler", channel);
+        }
+        for (const registration of state.ipcListeners) {
+            safeCall(ipcMain, "removeListener", registration.channel, registration.listener);
+        }
+        for (const registration of state.protocols) {
+            safeCall(registration.target, "unregisterProtocol", registration.scheme);
+        }
+        state.ipcHandlers.clear();
+        state.ipcListeners.length = 0;
+        state.protocols.length = 0;
+    }
+    construct(pluginId, state, request) {
+        const moduleName = request.module;
+        const descriptor = (0, plugin_electron_facade_descriptors_1.getElectronFacadeExportDescriptor)(moduleName);
+        const canConstruct = descriptor?.kind === "constructor"
+            && (ownedConstructorModules.has(moduleName) || state.binding.hostControl);
+        if (!canConstruct) {
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ModuleUnavailable, "Electron facade constructor is unavailable.", { module: moduleName });
+        }
+        const candidate = this.electronRoot()[moduleName];
+        if (typeof candidate !== "function") {
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ModuleUnavailable, "Electron constructor is unavailable in this process.", { module: moduleName });
+        }
+        const args = this.decodeArguments(pluginId, state, request.args || []);
+        const normalizedArgs = !state.binding.hostControl && (moduleName === "BrowserWindow" || moduleName === "BrowserView")
+            ? this.normalizeWebContentsConstructorArgs(state, args)
+            : args;
+        const result = Reflect.construct(candidate, normalizedArgs);
+        const encoded = this.encodeHandle(pluginId, state, result, {
+            typeName: moduleName,
+            dispose: this.createOwnedDisposer(moduleName, result)
+        });
+        if (moduleName === "BrowserWindow") {
+            this.attachClosedHandleInvalidation(state, result, readHandleId(encoded));
+        }
+        return (0, runtime_result_1.ok)(encoded);
+    }
+    resolveTarget(state, request) {
+        if (request.module) {
+            const moduleName = request.module;
+            const descriptor = (0, plugin_electron_facade_descriptors_1.getElectronFacadeExportDescriptor)(moduleName);
+            if (descriptor?.process === "renderer") {
+                return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ProcessUnavailable, "Electron renderer-only API is unavailable in the plugin worker.", {
+                    module: moduleName
+                });
+            }
+            if (state.binding.hostControl && descriptor) {
+                if (moduleName === "ipcMain") {
+                    return (0, runtime_result_1.ok)(this.createIpcMainModuleTarget(state, true));
+                }
+                if (moduleName === "protocol") {
+                    return (0, runtime_result_1.ok)(this.createProtocolModuleTarget(state, true));
+                }
+                const hostModule = this.electronRoot()[moduleName];
+                if (!isObjectLike(hostModule)) {
+                    return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ModuleUnavailable, "Electron host module is unavailable in this process.", {
+                        module: moduleName
+                    });
+                }
+                return (0, runtime_result_1.ok)(hostModule);
+            }
+            if (basicModules.has(moduleName)) {
+                if (moduleName === "app" && !defaultAppMembers.has(request.member)) {
+                    return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.MemberUnavailable, "Electron app member is not available to the default facade.", {
+                        member: request.member
+                    });
+                }
+                const moduleValue = this.electronRoot()[moduleName];
+                if (!isObjectLike(moduleValue)) {
+                    return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ModuleUnavailable, "Electron facade module is unavailable in this process.", {
+                        module: moduleName
+                    });
+                }
+                return (0, runtime_result_1.ok)(moduleValue);
+            }
+            if (ownedConstructorModules.has(moduleName) || ownedServiceModules.has(moduleName)) {
+                return (0, runtime_result_1.ok)(this.createOwnedModuleTarget(state, moduleName));
+            }
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.ModuleUnavailable, "Electron facade module is not available to plugin-owned resources.", {
+                module: moduleName
+            });
+        }
+        const record = state.handles.get(request.handleId);
+        if (!record) {
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.HandleReleased, "Electron facade handle is unavailable or released.", {
+                handleId: request.handleId
+            });
+        }
+        return (0, runtime_result_1.ok)(record.value);
+    }
+    createOwnedModuleTarget(state, moduleName) {
+        const root = this.electronRoot();
+        if (moduleName === "BrowserWindow") {
+            return {
+                getAllWindows: () => this.ownedValues(state, "BrowserWindow"),
+                getFocusedWindow: () => this.ownedValues(state, "BrowserWindow").find((item) => safeBooleanCall(item, "isFocused")) || null,
+                fromId: (id) => this.ownedValues(state, "BrowserWindow").find((item) => Reflect.get(item, "id") === id) || null
+            };
+        }
+        if (moduleName === "BrowserView") {
+            return {};
+        }
+        if (moduleName === "Menu") {
+            const menu = asObject(root.Menu);
+            return {
+                buildFromTemplate: (...args) => requireFunction(menu, "buildFromTemplate").apply(menu, args)
+            };
+        }
+        if (moduleName === "Notification") {
+            const notification = asObject(root.Notification);
+            return {
+                isSupported: () => requireFunction(notification, "isSupported").apply(notification, [])
+            };
+        }
+        if (moduleName === "Tray") {
+            return {};
+        }
+        if (moduleName === "session") {
+            const session = asObject(root.session);
+            return {
+                fromPartition: (partition, options) => requireFunction(session, "fromPartition").call(session, this.namespacedPartition(state, partition), options)
+            };
+        }
+        if (moduleName === "net") {
+            const net = asObject(root.net);
+            return {
+                request: (options) => requireFunction(net, "request").call(net, this.normalizeNetRequestOptions(state, options)),
+                isOnline: () => requireFunction(net, "isOnline").call(net),
+                resolveHost: (...args) => requireFunction(net, "resolveHost").apply(net, args)
+            };
+        }
+        if (moduleName === "globalShortcut") {
+            const shortcuts = asObject(root.globalShortcut);
+            return {
+                register: (accelerator, callback) => {
+                    if (typeof accelerator !== "string" || typeof callback !== "function") {
+                        throw new Error("globalShortcut.register requires an accelerator and callback.");
+                    }
+                    const registered = Boolean(requireFunction(shortcuts, "register").call(shortcuts, accelerator, callback));
+                    if (registered) {
+                        state.shortcuts.add(accelerator);
+                    }
+                    return registered;
+                },
+                isRegistered: (accelerator) => typeof accelerator === "string"
+                    && state.shortcuts.has(accelerator)
+                    && Boolean(requireFunction(shortcuts, "isRegistered").call(shortcuts, accelerator)),
+                unregister: (accelerator) => {
+                    if (typeof accelerator === "string" && state.shortcuts.delete(accelerator)) {
+                        requireFunction(shortcuts, "unregister").call(shortcuts, accelerator);
+                    }
+                },
+                unregisterAll: () => {
+                    for (const accelerator of state.shortcuts) {
+                        requireFunction(shortcuts, "unregister").call(shortcuts, accelerator);
+                    }
+                    state.shortcuts.clear();
+                }
+            };
+        }
+        if (moduleName === "powerSaveBlocker") {
+            const blockers = asObject(root.powerSaveBlocker);
+            return {
+                start: (type) => {
+                    const blockerId = Number(requireFunction(blockers, "start").call(blockers, type));
+                    state.powerSaveBlockers.add(blockerId);
+                    return blockerId;
+                },
+                isStarted: (blockerId) => typeof blockerId === "number"
+                    && state.powerSaveBlockers.has(blockerId)
+                    && Boolean(requireFunction(blockers, "isStarted").call(blockers, blockerId)),
+                stop: (blockerId) => {
+                    if (typeof blockerId === "number" && state.powerSaveBlockers.delete(blockerId)) {
+                        requireFunction(blockers, "stop").call(blockers, blockerId);
+                    }
+                }
+            };
+        }
+        if (moduleName === "utilityProcess") {
+            const utilityProcess = asObject(root.utilityProcess);
+            return {
+                fork: (modulePath, args, options) => {
+                    if (typeof modulePath !== "string") {
+                        throw new Error("utilityProcess.fork module path must be a string.");
+                    }
+                    const resolved = path.resolve(state.binding.pluginDirectory, modulePath);
+                    if (!isPathInside(state.binding.pluginDirectory, resolved)) {
+                        throw new Error("utilityProcess.fork module path must stay inside the plugin directory.");
+                    }
+                    const normalizedOptions = isPlainRecord(options) ? { ...options, cwd: state.binding.pluginDirectory } : { cwd: state.binding.pluginDirectory };
+                    return requireFunction(utilityProcess, "fork").call(utilityProcess, resolved, Array.isArray(args) ? args : [], normalizedOptions);
+                }
+            };
+        }
+        if (moduleName === "ipcMain") {
+            return this.createIpcMainModuleTarget(state, false);
+        }
+        if (moduleName === "protocol") {
+            return this.createProtocolModuleTarget(state, false);
+        }
+        throw new Error("Electron owned module is unavailable: " + moduleName + ".");
+    }
+    createIpcMainModuleTarget(state, hostControl) {
+        const ipcMain = asObject(this.electronRoot().ipcMain);
+        const channelName = (value) => hostControl
+            ? this.globalIpcChannel(value)
+            : this.namespacedIpcChannel(state, value);
+        return createFacadeModuleProxy(ipcMain, {
+            namespace: hostControl ? null : state.ipcNamespace,
+            handle: (channel, listener) => {
+                if (typeof listener !== "function") {
+                    throw new Error("ipcMain.handle requires an async listener.");
+                }
+                const resolvedChannel = channelName(channel);
+                requireFunction(ipcMain, "handle").call(ipcMain, resolvedChannel, listener);
+                state.ipcHandlers.add(resolvedChannel);
+            },
+            handleOnce: (channel, listener) => {
+                if (typeof listener !== "function") {
+                    throw new Error("ipcMain.handleOnce requires an async listener.");
+                }
+                const resolvedChannel = channelName(channel);
+                requireFunction(ipcMain, "handleOnce").call(ipcMain, resolvedChannel, listener);
+                state.ipcHandlers.add(resolvedChannel);
+            },
+            removeHandler: (channel) => {
+                const resolvedChannel = channelName(channel);
+                if (hostControl || state.ipcHandlers.has(resolvedChannel)) {
+                    requireFunction(ipcMain, "removeHandler").call(ipcMain, resolvedChannel);
+                    state.ipcHandlers.delete(resolvedChannel);
+                }
+            },
+            on: (channel, listener) => this.registerIpcListener(state, ipcMain, channelName(channel), listener, "on"),
+            once: (channel, listener) => this.registerIpcListener(state, ipcMain, channelName(channel), listener, "once"),
+            addListener: (channel, listener) => this.registerIpcListener(state, ipcMain, channelName(channel), listener, "addListener"),
+            prependListener: (channel, listener) => this.registerIpcListener(state, ipcMain, channelName(channel), listener, "prependListener"),
+            prependOnceListener: (channel, listener) => this.registerIpcListener(state, ipcMain, channelName(channel), listener, "prependOnceListener"),
+            removeListener: (channel, listener) => {
+                const namespaced = channelName(channel);
+                if (typeof listener !== "function") {
+                    return;
+                }
+                requireFunction(ipcMain, "removeListener").call(ipcMain, namespaced, listener);
+                state.ipcListeners = state.ipcListeners.filter((item) => item.channel !== namespaced || item.listener !== listener);
+            },
+            off: (channel, listener) => {
+                const resolvedChannel = channelName(channel);
+                if (typeof listener !== "function") {
+                    return;
+                }
+                requireFunction(ipcMain, "off").call(ipcMain, resolvedChannel, listener);
+                state.ipcListeners = state.ipcListeners.filter((item) => item.channel !== resolvedChannel || item.listener !== listener);
+            },
+            removeAllListeners: (channel) => {
+                if (hostControl) {
+                    if (channel === undefined) {
+                        requireFunction(ipcMain, "removeAllListeners").call(ipcMain);
+                        state.ipcListeners.length = 0;
+                        return;
+                    }
+                    const resolvedChannel = channelName(channel);
+                    requireFunction(ipcMain, "removeAllListeners").call(ipcMain, resolvedChannel);
+                    state.ipcListeners = state.ipcListeners.filter((item) => item.channel !== resolvedChannel);
+                    return;
+                }
+                const channels = channel === undefined
+                    ? Array.from(new Set(state.ipcListeners.map((item) => item.channel)))
+                    : [channelName(channel)];
+                for (const namespaced of channels) {
+                    requireFunction(ipcMain, "removeAllListeners").call(ipcMain, namespaced);
+                    state.ipcListeners = state.ipcListeners.filter((item) => item.channel !== namespaced);
+                }
+            }
+        });
+    }
+    registerIpcListener(state, ipcMain, resolvedChannel, listener, method) {
+        if (typeof listener !== "function") {
+            throw new Error("ipcMain event registration requires a listener.");
+        }
+        requireFunction(ipcMain, method).call(ipcMain, resolvedChannel, listener);
+        state.ipcListeners.push({ channel: resolvedChannel, listener: listener });
+    }
+    createProtocolModuleTarget(state, hostControl, protocolOverride) {
+        const protocol = protocolOverride || (hostControl
+            ? this.electronRoot().protocol
+            : asObject(this.pluginSession(state))?.protocol);
+        const target = asObject(protocol);
+        const schemeName = (value) => hostControl
+            ? this.globalProtocolScheme(value)
+            : this.namespacedProtocolScheme(state, value);
+        return createFacadeModuleProxy(target, {
+            namespace: hostControl ? null : state.protocolNamespace,
+            isProtocolRegistered: (scheme) => requireFunction(target, "isProtocolRegistered").call(target, schemeName(scheme)),
+            unregisterProtocol: (scheme) => this.unregisterProtocol(state, target, schemeName(scheme), hostControl),
+            registerFileProtocol: (scheme, handler) => this.registerProtocol(state, target, "registerFileProtocol", schemeName(scheme), handler),
+            registerBufferProtocol: (scheme, handler) => this.registerProtocol(state, target, "registerBufferProtocol", schemeName(scheme), handler),
+            registerStringProtocol: (scheme, handler) => this.registerProtocol(state, target, "registerStringProtocol", schemeName(scheme), handler),
+            registerHttpProtocol: (scheme, handler) => this.registerProtocol(state, target, "registerHttpProtocol", schemeName(scheme), handler),
+            registerStreamProtocol: (scheme, handler) => this.registerProtocol(state, target, "registerStreamProtocol", schemeName(scheme), handler)
+        });
+    }
+    registerProtocol(state, protocol, method, scheme, handler) {
+        if (typeof handler !== "function") {
+            throw new Error(method + " requires an async handler.");
+        }
+        const nativeHandler = (request, callback) => {
+            void Promise.resolve(handler(request)).then((response) => callback(response), () => callback({ error: -2 }));
+        };
+        const registered = Boolean(requireFunction(protocol, method).call(protocol, scheme, nativeHandler));
+        if (registered) {
+            state.protocols.push({ scheme, target: protocol });
+        }
+        return registered;
+    }
+    unregisterProtocol(state, protocol, scheme, allowUnowned) {
+        const registrationIndex = state.protocols.findIndex((item) => item.scheme === scheme && item.target === protocol);
+        if (!allowUnowned && registrationIndex < 0) {
+            return false;
+        }
+        const unregistered = Boolean(requireFunction(protocol, "unregisterProtocol").call(protocol, scheme));
+        if (unregistered && registrationIndex >= 0) {
+            state.protocols.splice(registrationIndex, 1);
+        }
+        return unregistered;
+    }
+    subscribe(pluginId, state, target, eventName, callbackValue, once) {
+        const callbackId = readCallbackId(callbackValue);
+        const addListener = Reflect.get(target, once ? "once" : "on");
+        const removeListener = Reflect.get(target, "removeListener");
+        if (typeof addListener !== "function" || typeof removeListener !== "function") {
+            return (0, runtime_result_1.fail)(plugin_electron_facade_1.ElectronFacadeErrorCodes.MemberUnavailable, "Electron facade target does not support events.", { eventName });
+        }
+        const listener = (...args) => {
+            if (this.states.get(pluginId) !== state) {
+                return;
+            }
+            state.binding.emitEvent(callbackId, args.map((item) => this.encodeEventArgument(pluginId, state, item)));
+        };
+        addListener.call(target, eventName, listener);
+        const subscription = {};
+        return (0, runtime_result_1.ok)(this.encodeHandle(pluginId, state, subscription, {
+            typeName: "ElectronEventSubscription",
+            callbackId,
+            dispose: () => {
+                removeListener.call(target, eventName, listener);
+            }
+        }));
+    }
+    decodeArguments(pluginId, state, values) {
+        return values.map((item) => (0, plugin_electron_facade_1.decodeElectronFacadeValue)(item, {
+            decodeHandle: (handleId) => {
+                const record = state.handles.get(handleId);
+                if (!record) {
+                    throw new ElectronFacadeBrokerError(plugin_electron_facade_1.ElectronFacadeErrorCodes.HandleReleased, "Electron facade handle is unavailable or belongs to another plugin generation.");
+                }
+                return record.value;
+            },
+            decodeFunction: (callbackId) => (...args) => this.invokeRemoteCallback(pluginId, state, callbackId, args)
+        }));
+    }
+    async invokeRemoteCallback(pluginId, state, callbackId, args) {
+        if (this.states.get(pluginId) !== state) {
+            throw new Error("Electron facade callback belongs to an expired plugin generation.");
+        }
+        const result = await state.binding.invokeCallback(callbackId, args.map((item) => this.encodeResult(pluginId, state, item)));
+        if (!result.ok) {
+            const error = new Error(result.error.message);
+            error.name = result.error.code;
+            throw error;
+        }
+        return (0, plugin_electron_facade_1.decodeElectronFacadeValue)(result.value, {
+            decodeHandle: (handleId) => {
+                const record = state.handles.get(handleId);
+                if (!record) {
+                    throw new ElectronFacadeBrokerError(plugin_electron_facade_1.ElectronFacadeErrorCodes.HandleReleased, "Electron callback returned an unavailable handle.");
+                }
+                return record.value;
+            }
+        });
+    }
+    encodeCallResult(pluginId, state, moduleName, member, value) {
+        if (moduleName === "Menu" && member === "buildFromTemplate" && isObjectLike(value)) {
+            return this.encodeHandle(pluginId, state, value, {
+                typeName: "Menu",
+                dispose: this.createOwnedDisposer("Menu", value)
+            });
+        }
+        if (moduleName === "net" && member === "request" && isObjectLike(value)) {
+            return this.encodeHandle(pluginId, state, value, {
+                typeName: "ClientRequest",
+                dispose: this.createOwnedDisposer("ClientRequest", value)
+            });
+        }
+        if (moduleName === "utilityProcess" && member === "fork" && isObjectLike(value)) {
+            return this.encodeHandle(pluginId, state, value, {
+                typeName: "UtilityProcess",
+                dispose: this.createOwnedDisposer("UtilityProcess", value)
+            });
+        }
+        if (moduleName === "session" && member === "fromPartition" && isObjectLike(value)) {
+            return this.encodeHandle(pluginId, state, value, { typeName: "Session" });
+        }
+        return this.encodeResult(pluginId, state, value);
+    }
+    encodeResult(pluginId, state, value) {
+        return (0, plugin_electron_facade_1.encodeElectronFacadeValue)(value, {
+            encodeObject: (objectValue) => this.encodeHandle(pluginId, state, objectValue)
+        });
+    }
+    encodeEventArgument(pluginId, state, value) {
+        if (!isElectronEvent(value)) {
+            return this.encodeResult(pluginId, state, value);
+        }
+        const sender = safeGet(value, "sender");
+        const senderId = isObjectLike(sender) ? safeGet(sender, "id") : undefined;
+        return this.encodeResult(pluginId, state, {
+            defaultPrevented: safeGet(value, "defaultPrevented") === true,
+            preventDefaultSupported: false,
+            ...((typeof senderId === "number" || typeof senderId === "string") ? { senderId } : {})
+        });
+    }
+    encodeHandle(pluginId, state, value, options = {}) {
+        const existing = state.reverseHandles.get(value);
+        const handleId = existing || pluginId + ":electron:g" + String(state.generation) + ":" + String(++state.nextHandleId);
+        const typeName = options.typeName || value.constructor?.name || "ElectronObject";
+        if (!existing) {
+            state.handles.set(handleId, {
+                value,
+                typeName,
+                ...(options.callbackId ? { callbackId: options.callbackId } : {}),
+                ...(options.dispose ? { dispose: options.dispose } : {})
+            });
+            state.reverseHandles.set(value, handleId);
+        }
+        const record = state.handles.get(handleId);
+        return {
+            $nexusElectron: "handle",
+            handleId,
+            typeName: record.typeName,
+            ...(record.callbackId ? { callbackId: record.callbackId } : {})
+        };
+    }
+    releaseHandle(state, handleId, disposeResource = true) {
+        const record = state.handles.get(handleId);
+        if (!record) {
+            return false;
+        }
+        state.handles.delete(handleId);
+        state.reverseHandles.delete(record.value);
+        if (disposeResource) {
+            try {
+                record.dispose?.();
+            }
+            catch {
+                // Cleanup is best effort; all remaining plugin resources must still be released.
+            }
+        }
+        return true;
+    }
+    normalizeWebContentsConstructorArgs(state, args) {
+        const options = isPlainRecord(args[0]) ? { ...args[0] } : {};
+        const webPreferences = isPlainRecord(options.webPreferences) ? { ...options.webPreferences } : {};
+        delete webPreferences.preload;
+        Object.assign(webPreferences, {
+            contextIsolation: true,
+            allowRunningInsecureContent: false,
+            nodeIntegration: false,
+            nodeIntegrationInSubFrames: false,
+            nodeIntegrationInWorker: false,
+            sandbox: true,
+            webSecurity: true,
+            webviewTag: false,
+            partition: state.sessionPartition
+        });
+        options.webPreferences = webPreferences;
+        return [options, ...args.slice(1)];
+    }
+    normalizeNetRequestOptions(state, value) {
+        const session = this.pluginSession(state);
+        return typeof value === "string"
+            ? { url: value, session }
+            : { ...(isPlainRecord(value) ? value : {}), session };
+    }
+    pluginSession(state) {
+        const session = asObject(this.electronRoot().session);
+        return requireFunction(session, "fromPartition").call(session, state.sessionPartition);
+    }
+    pluginSessionIfAvailable(state) {
+        try {
+            return asObject(this.pluginSession(state));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    namespacedIpcChannel(state, value) {
+        return state.ipcNamespace + this.globalIpcChannel(value);
+    }
+    globalIpcChannel(value) {
+        if (typeof value !== "string" || !/^[A-Za-z0-9._:-]{1,120}$/.test(value)) {
+            throw new Error("Plugin IPC channel is invalid.");
+        }
+        return value;
+    }
+    namespacedProtocolScheme(state, value) {
+        return (state.protocolNamespace + this.globalProtocolScheme(value)).toLowerCase();
+    }
+    globalProtocolScheme(value) {
+        if (typeof value !== "string" || !/^[A-Za-z][A-Za-z0-9+.-]{0,39}$/.test(value)) {
+            throw new Error("Plugin protocol scheme is invalid.");
+        }
+        return value.toLowerCase();
+    }
+    assertSpecialMemberAvailable(state, request, member) {
+        const handle = request.handleId ? state.handles.get(request.handleId) : undefined;
+        const owner = request.module || handle?.typeName;
+        if (!owner) {
+            return;
+        }
+        const descriptor = (0, plugin_electron_facade_descriptors_1.getElectronFacadeSpecialMemberDescriptor)(owner, member);
+        if (!descriptor) {
+            return;
+        }
+        if (descriptor.behavior === "synchronousCallback") {
+            if (request.args?.[0] === null) {
+                return;
+            }
+            throw new ElectronFacadeBrokerError(plugin_electron_facade_1.ElectronFacadeErrorCodes.SynchronousCallbackUnsupported, owner + "." + member + " is unavailable because " + descriptor.reason + ".");
+        }
+        const app = asObject(this.electronRoot().app);
+        if (safeBooleanCall(app || {}, "isReady")) {
+            throw new ElectronFacadeBrokerError(plugin_electron_facade_1.ElectronFacadeErrorCodes.LifecycleUnavailable, owner + "." + member + " is unavailable after Electron app ready because it " + descriptor.reason + ".");
+        }
+    }
+    namespacedPartition(state, value) {
+        if (typeof value !== "string" || value.trim().length === 0) {
+            return state.sessionPartition;
+        }
+        const suffix = value.replace(/^persist:/i, "").replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 64);
+        return state.sessionPartition + ":" + (suffix || "default");
+    }
+    ownedValues(state, typeName) {
+        return Array.from(state.handles.values())
+            .filter((record) => record.typeName === typeName && (typeName !== "BrowserWindow" || !safeBooleanCall(record.value, "isDestroyed")))
+            .map((record) => record.value);
+    }
+    attachClosedHandleInvalidation(state, value, handleId) {
+        const target = value;
+        const once = Reflect.get(target, "once");
+        if (typeof once === "function") {
+            once.call(target, "closed", () => {
+                this.releaseHandle(state, handleId, false);
+            });
+        }
+    }
+    createOwnedDisposer(typeName, value) {
+        const target = value;
+        if (typeName === "BrowserWindow") {
+            return () => {
+                if (!safeBooleanCall(target, "isDestroyed")) {
+                    safeCall(target, "destroy");
+                }
+            };
+        }
+        if (typeName === "BrowserView") {
+            return () => {
+                const webContents = asObject(Reflect.get(target, "webContents"));
+                safeCall(webContents, "close");
+            };
+        }
+        if (typeName === "Tray") {
+            return () => safeCall(target, "destroy");
+        }
+        if (typeName === "Notification") {
+            return () => safeCall(target, "close");
+        }
+        if (typeName === "Menu" || typeName === "ShareMenu") {
+            return () => safeCall(target, "closePopup");
+        }
+        if (typeName === "MessageChannelMain") {
+            return () => {
+                safeCall(asObject(Reflect.get(target, "port1")), "close");
+                safeCall(asObject(Reflect.get(target, "port2")), "close");
+            };
+        }
+        if (typeName === "ClientRequest") {
+            return () => safeCall(target, "abort");
+        }
+        if (typeName === "UtilityProcess") {
+            return () => safeCall(target, "kill");
+        }
+        return undefined;
+    }
+    disposeDetachedValue(value) {
+        if (!isObjectLike(value)) {
+            return;
+        }
+        const typeName = value.constructor?.name || "";
+        this.createOwnedDisposer(typeName, value)?.();
+    }
+    electronRoot() {
+        if (this.injectedRoot) {
+            return this.injectedRoot;
+        }
+        const loaded = module.require("electron");
+        if (typeof loaded !== "object" || loaded === null) {
+            throw new Error("Electron main-process exports are unavailable.");
+        }
+        return loaded;
+    }
+    electronRootIfAvailable() {
+        try {
+            return this.electronRoot();
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.PluginElectronFacadeBrokerService = PluginElectronFacadeBrokerService;
+function readCallbackId(value) {
+    if (!isPlainRecord(value) || value.$nexusElectron !== "callback" || typeof value.callbackId !== "string") {
+        throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade event callback is invalid.");
+    }
+    return value.callbackId;
+}
+function readHandleId(value) {
+    if (!isPlainRecord(value) || value.$nexusElectron !== "handle" || typeof value.handleId !== "string") {
+        throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade handle result is invalid.");
+    }
+    return value.handleId;
+}
+function requireFunction(target, member) {
+    const candidate = target && Reflect.get(target, member);
+    if (typeof candidate !== "function") {
+        throw new Error("Electron member is unavailable: " + member + ".");
+    }
+    return candidate;
+}
+function safeCall(target, member, ...args) {
+    try {
+        const candidate = target && Reflect.get(target, member);
+        if (typeof candidate === "function") {
+            const result = candidate.apply(target, args);
+            if (result && typeof result.then === "function") {
+                void Promise.resolve(result).catch(() => undefined);
+            }
+        }
+    }
+    catch {
+        // Resource cleanup is intentionally best effort.
+    }
+}
+function safeBooleanCall(target, member) {
+    try {
+        const candidate = Reflect.get(target, member);
+        return typeof candidate === "function" && Boolean(candidate.call(target));
+    }
+    catch {
+        return false;
+    }
+}
+function asObject(value) {
+    return isObjectLike(value) ? value : undefined;
+}
+function createFacadeModuleProxy(target, overrides) {
+    return new Proxy(overrides, {
+        get: (overrideTarget, property) => {
+            if (Reflect.has(overrideTarget, property)) {
+                return Reflect.get(overrideTarget, property);
+            }
+            const value = target && Reflect.get(target, property);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+        has: (overrideTarget, property) => Reflect.has(overrideTarget, property) || Boolean(target && Reflect.has(target, property))
+    });
+}
+function isObjectLike(value) {
+    return (typeof value === "object" && value !== null) || typeof value === "function";
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isElectronEvent(value) {
+    return isPlainRecord(value)
+        && typeof safeGet(value, "preventDefault") === "function"
+        && Reflect.has(value, "sender");
+}
+function safeGet(target, property) {
+    try {
+        return Reflect.get(target, property);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPathInside(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith(".." + path.sep) && relative !== ".." && !path.isAbsolute(relative));
+}