@aiot-nexus/plugin-sdk 2.0.2 → 2.1.0

package/dist/internal/src-electron/plugin-host-bootstrap.js

@@ -0,0 +1,417 @@
+"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.runPluginHostBootstrap = exports.pluginHostBootstrapProtocolVersion = void 0;
+const path = __importStar(require("path"));
+const plugin_rpc_1 = require("./shared/plugin-rpc");
+const plugin_electron_facade_client_1 = require("./shared/plugin-electron-facade-client");
+const implementedPermissions = new Set(["businessLog", "settings"]);
+const hostControlPermissions = new Set(["electronHostControl"]);
+const routeGuardPermissions = new Set(["filesystem", "udp", "serial", "dialog"]);
+exports.pluginHostBootstrapProtocolVersion = plugin_rpc_1.PLUGIN_RPC_PROTOCOL_VERSION;
+function runPluginHostBootstrap(port, options = {}) {
+    if (!port) {
+        return () => undefined;
+    }
+    const controller = new PluginHostController(port, options);
+    controller.start();
+    return () => controller.dispose();
+}
+exports.runPluginHostBootstrap = runPluginHostBootstrap;
+class PluginHostController {
+    constructor(port, options) {
+        this.port = port;
+        this.operations = new Map();
+        this.pendingHostRequests = new Map();
+        this.inFlightOperations = new Set();
+        this.initialized = false;
+        this.ready = false;
+        this.shuttingDown = false;
+        this.exiting = false;
+        this.pluginId = "";
+        this.pluginDirectory = "";
+        this.pluginDataDirectory = "";
+        this.hostVersion = "";
+        this.hostApiVersion = "";
+        this.requestSequence = 0;
+        this.now = options.now || (() => new Date().toISOString());
+        this.exit = options.exit || ((code) => process.exit(code));
+        this.requireModule = options.requireModule || loadPluginMainModule;
+        this.installProcessHandlers = options.installProcessHandlers === true;
+        this.messageListener = (event) => {
+            void this.handleMessage(readMessageData(event));
+        };
+    }
+    start() {
+        this.port.on("message", this.messageListener);
+        if (this.installProcessHandlers) {
+            process.once("uncaughtException", (error) => {
+                this.failProcess(error instanceof Error ? error.message : String(error));
+            });
+            process.once("unhandledRejection", (reason) => {
+                this.failProcess(reason instanceof Error ? reason.message : String(reason));
+            });
+        }
+    }
+    dispose() {
+        this.port.removeListener?.("message", this.messageListener);
+        const error = createPluginRpcFailure(plugin_rpc_1.PluginRpcErrorCodes.ProcessExited, "Plugin host process stopped.");
+        for (const pending of this.pendingHostRequests.values()) {
+            pending.resolve(error);
+        }
+        this.pendingHostRequests.clear();
+        this.electronFacadeClient?.dispose();
+        this.electronFacadeClient = undefined;
+    }
+    async handleMessage(message) {
+        if (this.exiting) {
+            return;
+        }
+        if (!(0, plugin_rpc_1.isPluginRpcMessage)(message)) {
+            this.failProcess("Plugin RPC message is invalid.");
+            return;
+        }
+        if (message.type === "initialize") {
+            await this.handleInitialize(message);
+            return;
+        }
+        if (message.type === "hostResult") {
+            this.handleHostResult(message.requestId, message.result);
+            return;
+        }
+        if (message.type === "electronCallback") {
+            await this.handleElectronCallback(message.requestId, message.payload.callbackId, message.payload.args);
+            return;
+        }
+        if (message.type === "electronEvent") {
+            this.electronFacadeClient?.emitEvent(message.payload.callbackId, message.payload.args);
+            return;
+        }
+        if (message.type === "invoke") {
+            await this.handleTrackedInvoke(message);
+            return;
+        }
+        if (message.type === "shutdown") {
+            await this.handleShutdown(message.requestId, message.payload.reason);
+            return;
+        }
+        if (message.type === "fatal") {
+            return;
+        }
+        this.failProcess("Plugin RPC message direction is invalid.");
+    }
+    async handleInitialize(message) {
+        if (this.initialized || this.shuttingDown) {
+            this.failProcess("Plugin host process was initialized more than once.");
+            return;
+        }
+        const payload = message.payload;
+        this.initialized = true;
+        this.pluginId = payload.pluginId;
+        this.pluginDirectory = payload.pluginDirectory;
+        this.pluginDataDirectory = payload.pluginDataDirectory;
+        this.manifest = payload.manifest;
+        this.hostVersion = payload.hostVersion;
+        this.hostApiVersion = payload.hostApiVersion;
+        try {
+            if (!payload.manifest.mainEntry) {
+                throw new Error("Plugin manifest does not declare mainEntry.");
+            }
+            const mainEntryPath = path.resolve(payload.pluginDirectory, payload.manifest.mainEntry);
+            this.module = this.requireModule(mainEntryPath);
+            const activate = typeof this.module.activate === "function" ? this.module.activate : this.module.default?.activate;
+            if (typeof activate === "function") {
+                await activate({
+                    pluginId: this.pluginId,
+                    pluginDirectory: this.pluginDirectory,
+                    manifest: this.manifest,
+                    host: this.createHostApi()
+                });
+            }
+            if (this.exiting || this.shuttingDown) {
+                return;
+            }
+            this.ready = true;
+            this.port.postMessage({
+                protocolVersion: plugin_rpc_1.PLUGIN_RPC_PROTOCOL_VERSION,
+                type: "ready",
+                requestId: message.requestId,
+                payload: {
+                    operations: Array.from(this.operations.keys()),
+                    activatedAtUtc: this.now()
+                }
+            });
+        }
+        catch (error) {
+            this.failProcess(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async handleInvoke(message) {
+        if (!this.ready || this.shuttingDown) {
+            this.sendResult(message.requestId, createPluginRpcFailure(plugin_rpc_1.PluginRpcErrorCodes.NotReady, "Plugin host process is not ready."));
+            return;
+        }
+        const handler = this.operations.get(message.payload.operation);
+        if (!handler) {
+            this.sendResult(message.requestId, createPluginRpcFailure("NotFound", "Plugin renderer operation was not registered.", {
+                pluginId: this.pluginId,
+                operation: message.payload.operation
+            }));
+            return;
+        }
+        try {
+            const result = await handler({
+                pluginId: this.pluginId,
+                surface: message.payload.surface,
+                contributionId: message.payload.contributionId,
+                operation: message.payload.operation,
+                input: message.payload.input
+            });
+            this.sendResult(message.requestId, normalizePluginResult(result));
+        }
+        catch (error) {
+            const messageText = error instanceof Error ? error.message : String(error);
+            this.sendResult(message.requestId, createPluginRpcFailure("UnexpectedFailure", "Plugin renderer operation failed.", {
+                pluginId: this.pluginId,
+                operation: message.payload.operation,
+                message: messageText
+            }));
+        }
+    }
+    async handleTrackedInvoke(message) {
+        const operation = this.handleInvoke(message);
+        this.inFlightOperations.add(operation);
+        try {
+            await operation;
+        }
+        finally {
+            this.inFlightOperations.delete(operation);
+        }
+    }
+    async handleShutdown(requestId, reason) {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        try {
+            await Promise.allSettled(Array.from(this.inFlightOperations));
+            const deactivate = this.module && (typeof this.module.deactivate === "function" ? this.module.deactivate : this.module.default?.deactivate);
+            if (typeof deactivate === "function") {
+                await deactivate(reason);
+            }
+            this.sendResult(requestId, { ok: true, value: true });
+        }
+        catch (error) {
+            this.sendResult(requestId, createPluginRpcFailure("UnexpectedFailure", "Plugin shutdown failed.", error instanceof Error ? error.message : String(error)));
+        }
+        this.dispose();
+        setImmediate(() => this.exit(0));
+    }
+    createHostApi() {
+        const manifest = this.manifest;
+        const unsupported = (permission) => {
+            const supportState = hostControlPermissions.has(permission)
+                ? "hostControl"
+                : implementedPermissions.has(permission)
+                    ? "implemented"
+                    : routeGuardPermissions.has(permission)
+                        ? "routeGuard"
+                        : "reserved";
+            const target = {
+                permission,
+                supportState,
+                describe: () => this.requestHost("getCapabilityStatus", { permission }),
+                unsupported: (operation) => this.requestHost("unsupportedCapability", { permission, ...(typeof operation === "string" ? { operation } : {}) })
+            };
+            return new Proxy(target, {
+                get: (apiTarget, property) => {
+                    if (property in apiTarget) {
+                        return Reflect.get(apiTarget, property);
+                    }
+                    if (typeof property === "symbol" || property === "then") {
+                        return undefined;
+                    }
+                    return () => apiTarget.unsupported(property);
+                }
+            });
+        };
+        this.electronFacadeClient?.dispose();
+        this.electronFacadeClient = (0, plugin_electron_facade_client_1.createPluginElectronFacadeClient)((request) => this.requestHost("electronFacade", request));
+        const electron = this.electronFacadeClient.electron;
+        return {
+            hostVersion: this.hostVersion,
+            hostApiVersion: this.hostApiVersion,
+            pluginId: this.pluginId,
+            pluginDataDirectory: this.pluginDataDirectory,
+            hasPermission: (permission) => manifest.permissions.includes(permission),
+            registerRendererMethod: async (name, handler) => {
+                if (!(0, plugin_rpc_1.isPluginRpcOperationName)(name) || typeof handler !== "function") {
+                    return createPluginRpcFailure("InvalidRequest", "Plugin renderer operation registration is invalid.");
+                }
+                if (this.operations.has(name)) {
+                    return createPluginRpcFailure("InvalidRequest", "Plugin renderer operation is already registered.");
+                }
+                this.operations.set(name, handler);
+                return { ok: true, value: true };
+            },
+            getCapabilityStatus: (permission) => this.requestHost("getCapabilityStatus", { permission: typeof permission === "string" ? permission : String(permission) }),
+            unsupportedCapability: (permission, operation) => this.requestHost("unsupportedCapability", { permission: typeof permission === "string" ? permission : String(permission), ...(typeof operation === "string" ? { operation } : {}) }),
+            log: (level, message, exception) => this.requestHost("log", {
+                level,
+                message,
+                ...(exception ? { exception } : {})
+            }),
+            getSettings: () => this.requestHost("getSettings"),
+            updateSettings: (values) => this.requestHost("updateSettings", { values: (0, plugin_rpc_1.sanitizePluginRpcValue)(values) }),
+            electron,
+            filesystem: unsupported("filesystem"),
+            udp: unsupported("udp"),
+            serial: unsupported("serial"),
+            dialog: unsupported("dialog"),
+            externalProcess: unsupported("externalProcess")
+        };
+    }
+    requestHost(method, params) {
+        if (this.exiting) {
+            return Promise.resolve(createPluginRpcFailure(plugin_rpc_1.PluginRpcErrorCodes.ProcessExited, "Plugin host process is stopping."));
+        }
+        const requestId = (0, plugin_rpc_1.createPluginRpcRequestId)(this.pluginId + "-host", ++this.requestSequence);
+        return new Promise((resolve, reject) => {
+            this.pendingHostRequests.set(requestId, { resolve, reject });
+            try {
+                this.port.postMessage({
+                    protocolVersion: plugin_rpc_1.PLUGIN_RPC_PROTOCOL_VERSION,
+                    type: "hostRequest",
+                    requestId,
+                    payload: { method, ...(params ? { params: (0, plugin_rpc_1.sanitizePluginRpcValue)(params) } : {}) }
+                });
+            }
+            catch (error) {
+                this.pendingHostRequests.delete(requestId);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    handleHostResult(requestId, result) {
+        const pending = this.pendingHostRequests.get(requestId);
+        if (!pending) {
+            return;
+        }
+        this.pendingHostRequests.delete(requestId);
+        pending.resolve(result);
+    }
+    async handleElectronCallback(requestId, callbackId, args) {
+        const result = this.electronFacadeClient
+            ? await this.electronFacadeClient.invokeCallback(callbackId, args)
+            : createPluginRpcFailure(plugin_rpc_1.PluginRpcErrorCodes.NotReady, "Electron facade client is not ready.");
+        this.port.postMessage({
+            protocolVersion: plugin_rpc_1.PLUGIN_RPC_PROTOCOL_VERSION,
+            type: "electronCallbackResult",
+            requestId,
+            result
+        });
+    }
+    sendResult(requestId, result) {
+        this.port.postMessage({
+            protocolVersion: plugin_rpc_1.PLUGIN_RPC_PROTOCOL_VERSION,
+            type: "result",
+            requestId,
+            result: normalizePluginResult(result)
+        });
+    }
+    sendFatal(message) {
+        try {
+            this.port.postMessage({
+                protocolVersion: plugin_rpc_1.PLUGIN_RPC_PROTOCOL_VERSION,
+                type: "fatal",
+                payload: { message: message || "Plugin host process failed." }
+            });
+        }
+        catch {
+            // The parent may already have closed the transport.
+        }
+    }
+    failProcess(message) {
+        if (this.exiting) {
+            return;
+        }
+        this.exiting = true;
+        this.sendFatal(message);
+        setImmediate(() => this.exit(1));
+    }
+}
+function readMessageData(event) {
+    if (isRecordWithData(event)) {
+        return event.data;
+    }
+    return event;
+}
+function isRecordWithData(value) {
+    return typeof value === "object" && value !== null && "data" in value;
+}
+function loadPluginMainModule(mainEntryPath) {
+    const moduleApi = module.require("module");
+    const pluginRequire = moduleApi.createRequire(mainEntryPath);
+    return pluginRequire(mainEntryPath);
+}
+function normalizePluginResult(value) {
+    if (isNexusResult(value)) {
+        if (!value.ok) {
+            return {
+                ok: false,
+                error: {
+                    code: value.error.code,
+                    message: value.error.message,
+                    ...(value.error.details === undefined ? {} : { details: (0, plugin_rpc_1.sanitizePluginRpcValue)(value.error.details) })
+                }
+            };
+        }
+        return { ok: true, value: (0, plugin_rpc_1.sanitizePluginRpcValue)(value.value) };
+    }
+    return { ok: true, value: (0, plugin_rpc_1.sanitizePluginRpcValue)(value) };
+}
+function isNexusResult(value) {
+    return isRecord(value)
+        && typeof value.ok === "boolean"
+        && (value.ok
+            ? "value" in value
+            : isRecord(value.error) && typeof value.error.code === "string" && typeof value.error.message === "string");
+}
+function createPluginRpcFailure(code, message, details) {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+            ...(details === undefined ? {} : { details: (0, plugin_rpc_1.sanitizePluginRpcValue)(details) })
+        }
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+if (process.type === "utility" && process.parentPort) {
+    runPluginHostBootstrap(process.parentPort, { installProcessHandlers: true });
+}

package/dist/internal/src-electron/shared/contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/src-electron/shared/plugin-electron-facade-client.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginElectronFacade = exports.createPluginElectronFacadeClient = void 0;
+const plugin_electron_facade_1 = require("./plugin-electron-facade");
+function createPluginElectronFacadeClient(request) {
+    const remoteHandles = new WeakMap();
+    const callbacks = new Map();
+    let callbackSequence = 0;
+    let disposed = false;
+    const registerCallback = (callback, once = false) => {
+        if (disposed) {
+            throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade client is disposed.");
+        }
+        const callbackId = "electron-callback:" + String(++callbackSequence);
+        callbacks.set(callbackId, { callback, once });
+        return { $nexusElectron: "callback", callbackId };
+    };
+    const encodeArgument = (value) => (0, plugin_electron_facade_1.encodeElectronFacadeValue)(value, {
+        encodeFunction: (functionValue) => {
+            const metadata = remoteHandles.get(functionValue);
+            return metadata ? handleTag(metadata) : registerCallback(functionValue);
+        },
+        encodeObject: (objectValue) => {
+            const metadata = remoteHandles.get(objectValue);
+            if (metadata) {
+                return handleTag(metadata);
+            }
+            throw new plugin_electron_facade_1.ElectronFacadeCodecError("Only Electron remote handles can cross the facade boundary.");
+        }
+    });
+    const createTarget = (target, metadata) => {
+        const callable = () => undefined;
+        const proxy = new Proxy(callable, {
+            get: (_proxyTarget, property) => {
+                if (property === "then") {
+                    return undefined;
+                }
+                if (property === "$typeName") {
+                    return metadata?.typeName;
+                }
+                if (property === "$construct") {
+                    return (...args) => invoke(target, "construct", undefined, args);
+                }
+                if (property === "$get") {
+                    return (member) => invoke(target, "get", requireMember(member));
+                }
+                if (property === "$set") {
+                    return (member, value) => invoke(target, "set", requireMember(member), [value]);
+                }
+                if (property === "$on" || property === "$once") {
+                    return (event, listener) => subscribe(target, property === "$once" ? "once" : "on", event, listener);
+                }
+                if (property === "$release") {
+                    return async () => {
+                        if (!target.handleId) {
+                            return;
+                        }
+                        try {
+                            await invoke(target, "release");
+                        }
+                        finally {
+                            if (metadata?.callbackId) {
+                                callbacks.delete(metadata.callbackId);
+                            }
+                        }
+                    };
+                }
+                if (typeof property === "symbol") {
+                    return undefined;
+                }
+                return (...args) => invoke(target, "call", property, args);
+            }
+        });
+        if (metadata) {
+            remoteHandles.set(proxy, metadata);
+        }
+        return proxy;
+    };
+    const decodeValue = (value) => (0, plugin_electron_facade_1.decodeElectronFacadeValue)(value, {
+        decodeHandle: (handleId, typeName, callbackId) => createTarget({ handleId }, { handleId, typeName, callbackId })
+    });
+    const invoke = async (target, operation, member, args) => {
+        if (disposed) {
+            throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade client is disposed.");
+        }
+        const result = await request({
+            operation,
+            ...target,
+            ...(member ? { member } : {}),
+            ...(args ? { args: args.map(encodeArgument) } : {})
+        });
+        return (0, plugin_electron_facade_1.unwrapElectronFacadeResult)(result, {
+            decodeHandle: (handleId, typeName, callbackId) => createTarget({ handleId }, { handleId, typeName, callbackId })
+        });
+    };
+    const subscribe = async (target, operation, event, listener) => {
+        const member = requireMember(event);
+        if (typeof listener !== "function") {
+            throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade event listener must be a function.");
+        }
+        const callbackTag = registerCallback(listener, operation === "once");
+        const callbackId = callbackTag.callbackId;
+        try {
+            return await invokeEncoded(target, operation, member, [callbackTag]);
+        }
+        catch (error) {
+            callbacks.delete(callbackId);
+            throw error;
+        }
+    };
+    const invokeEncoded = async (target, operation, member, args) => {
+        if (disposed) {
+            throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade client is disposed.");
+        }
+        const result = await request({ operation, ...target, member, args });
+        return (0, plugin_electron_facade_1.unwrapElectronFacadeResult)(result, {
+            decodeHandle: (handleId, typeName, callbackId) => createTarget({ handleId }, { handleId, typeName, callbackId })
+        });
+    };
+    const invokeRegisteredCallback = async (callbackId, args) => {
+        const record = callbacks.get(callbackId);
+        if (!record || disposed) {
+            throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade callback is unavailable or released.");
+        }
+        if (record.once) {
+            callbacks.delete(callbackId);
+        }
+        return record.callback(...args.map(decodeValue));
+    };
+    const electron = new Proxy({}, {
+        get: (_target, property) => {
+            if (property === "then" || typeof property === "symbol") {
+                return undefined;
+            }
+            return createTarget({ module: property });
+        }
+    });
+    return {
+        electron,
+        async invokeCallback(callbackId, args) {
+            try {
+                return { ok: true, value: encodeArgument(await invokeRegisteredCallback(callbackId, args)) };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: {
+                        code: error instanceof plugin_electron_facade_1.ElectronFacadeCodecError ? error.code : plugin_electron_facade_1.ElectronFacadeErrorCodes.InvocationFailed,
+                        message: error instanceof Error ? error.message : String(error)
+                    }
+                };
+            }
+        },
+        emitEvent(callbackId, args) {
+            void Promise.resolve(invokeRegisteredCallback(callbackId, args)).catch(() => undefined);
+        },
+        dispose() {
+            disposed = true;
+            callbacks.clear();
+        }
+    };
+}
+exports.createPluginElectronFacadeClient = createPluginElectronFacadeClient;
+function createPluginElectronFacade(request) {
+    return createPluginElectronFacadeClient(request).electron;
+}
+exports.createPluginElectronFacade = createPluginElectronFacade;
+function handleTag(metadata) {
+    return {
+        $nexusElectron: "handle",
+        handleId: metadata.handleId,
+        typeName: metadata.typeName,
+        ...(metadata.callbackId ? { callbackId: metadata.callbackId } : {})
+    };
+}
+function requireMember(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new plugin_electron_facade_1.ElectronFacadeCodecError("Electron facade member name is required.");
+    }
+    return value;
+}

package/dist/internal/src-electron/shared/plugin-electron-facade-descriptors.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElectronFacadeSpecialMemberDescriptor = exports.getElectronFacadeExportDescriptor = exports.electronFacadeSpecialMemberDescriptors = exports.electronFacadeExportDescriptors = void 0;
+// Runtime values exported by Electron 22.3.27's Common/Main/CrossProcessExports namespaces.
+exports.electronFacadeExportDescriptors = [
+    { name: "clipboard", process: "common", kind: "module", defaultAccess: "basic", cleanup: "none" },
+    { name: "crashReporter", process: "common", kind: "module", defaultAccess: "hostControl", cleanup: "irreversible" },
+    { name: "nativeImage", process: "common", kind: "module", defaultAccess: "basic", cleanup: "none" },
+    { name: "shell", process: "common", kind: "module", defaultAccess: "basic", cleanup: "none" },
+    { name: "app", process: "main", kind: "module", defaultAccess: "basic", cleanup: "irreversible" },
+    { name: "autoUpdater", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "irreversible" },
+    { name: "BrowserView", process: "main", kind: "constructor", defaultAccess: "owned", cleanup: "owned" },
+    { name: "BrowserWindow", process: "main", kind: "constructor", defaultAccess: "owned", cleanup: "owned" },
+    { name: "contentTracing", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "bestEffort" },
+    { name: "desktopCapturer", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "none" },
+    { name: "dialog", process: "main", kind: "module", defaultAccess: "basic", cleanup: "none" },
+    { name: "globalShortcut", process: "main", kind: "module", defaultAccess: "owned", cleanup: "tracked" },
+    { name: "inAppPurchase", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "irreversible" },
+    { name: "ipcMain", process: "main", kind: "module", defaultAccess: "owned", cleanup: "tracked" },
+    { name: "Menu", process: "main", kind: "constructor", defaultAccess: "owned", cleanup: "bestEffort" },
+    { name: "MenuItem", process: "main", kind: "constructor", defaultAccess: "hostControl", cleanup: "owned" },
+    { name: "MessageChannelMain", process: "main", kind: "constructor", defaultAccess: "hostControl", cleanup: "owned" },
+    { name: "nativeTheme", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "bestEffort" },
+    { name: "net", process: "main", kind: "module", defaultAccess: "owned", cleanup: "tracked" },
+    { name: "netLog", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "bestEffort" },
+    { name: "Notification", process: "main", kind: "constructor", defaultAccess: "owned", cleanup: "owned" },
+    { name: "powerMonitor", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "tracked" },
+    { name: "powerSaveBlocker", process: "main", kind: "module", defaultAccess: "owned", cleanup: "tracked" },
+    { name: "protocol", process: "main", kind: "module", defaultAccess: "owned", cleanup: "tracked" },
+    { name: "pushNotifications", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "tracked" },
+    { name: "safeStorage", process: "main", kind: "module", defaultAccess: "basic", cleanup: "none" },
+    { name: "screen", process: "main", kind: "module", defaultAccess: "basic", cleanup: "none" },
+    { name: "session", process: "main", kind: "module", defaultAccess: "owned", cleanup: "owned" },
+    { name: "ShareMenu", process: "main", kind: "constructor", defaultAccess: "hostControl", cleanup: "owned" },
+    { name: "systemPreferences", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "bestEffort" },
+    { name: "TouchBar", process: "main", kind: "constructor", defaultAccess: "hostControl", cleanup: "owned" },
+    { name: "Tray", process: "main", kind: "constructor", defaultAccess: "owned", cleanup: "owned" },
+    { name: "utilityProcess", process: "main", kind: "module", defaultAccess: "owned", cleanup: "owned" },
+    { name: "webContents", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "tracked" },
+    { name: "webFrameMain", process: "main", kind: "module", defaultAccess: "hostControl", cleanup: "none" },
+    { name: "contextBridge", process: "renderer", kind: "module", defaultAccess: "unavailable", cleanup: "none" },
+    { name: "ipcRenderer", process: "renderer", kind: "module", defaultAccess: "unavailable", cleanup: "none" },
+    { name: "webFrame", process: "renderer", kind: "module", defaultAccess: "unavailable", cleanup: "none" }
+];
+exports.electronFacadeSpecialMemberDescriptors = [
+    { owner: "app", member: "disableDomainBlockingFor3DAPIs", behavior: "lifecycle", reason: "must run before app ready" },
+    { owner: "app", member: "disableHardwareAcceleration", behavior: "lifecycle", reason: "must run before app ready" },
+    { owner: "app", member: "enableSandbox", behavior: "lifecycle", reason: "must run before app ready" },
+    { owner: "protocol", member: "registerSchemesAsPrivileged", behavior: "lifecycle", reason: "must run before app ready" },
+    { owner: "WebContents", member: "setWindowOpenHandler", behavior: "synchronousCallback", reason: "Electron requires an immediate decision" },
+    { owner: "Session", member: "setPermissionCheckHandler", behavior: "synchronousCallback", reason: "Electron requires an immediate decision" },
+    { owner: "Session", member: "setDevicePermissionHandler", behavior: "synchronousCallback", reason: "Electron requires an immediate decision" },
+    { owner: "Session", member: "setBluetoothPairingHandler", behavior: "synchronousCallback", reason: "Electron native continuation callbacks cannot cross the asynchronous RPC boundary" },
+    { owner: "Session", member: "setCertificateVerifyProc", behavior: "synchronousCallback", reason: "Electron native continuation callbacks cannot cross the asynchronous RPC boundary" },
+    { owner: "Session", member: "setDisplayMediaRequestHandler", behavior: "synchronousCallback", reason: "Electron native continuation callbacks cannot cross the asynchronous RPC boundary" },
+    { owner: "Session", member: "setPermissionRequestHandler", behavior: "synchronousCallback", reason: "Electron native continuation callbacks cannot cross the asynchronous RPC boundary" },
+    { owner: "WebRequest", member: "onBeforeRequest", behavior: "synchronousCallback", reason: "Electron callback continuation is not RPC-safe" },
+    { owner: "WebRequest", member: "onBeforeSendHeaders", behavior: "synchronousCallback", reason: "Electron callback continuation is not RPC-safe" },
+    { owner: "WebRequest", member: "onHeadersReceived", behavior: "synchronousCallback", reason: "Electron callback continuation is not RPC-safe" }
+];
+const exportDescriptorsByName = new Map(exports.electronFacadeExportDescriptors.map((descriptor) => [descriptor.name, descriptor]));
+const specialMembersByKey = new Map(exports.electronFacadeSpecialMemberDescriptors.map((descriptor) => [descriptor.owner + "." + descriptor.member, descriptor]));
+function getElectronFacadeExportDescriptor(name) {
+    return exportDescriptorsByName.get(name);
+}
+exports.getElectronFacadeExportDescriptor = getElectronFacadeExportDescriptor;
+function getElectronFacadeSpecialMemberDescriptor(owner, member) {
+    return specialMembersByKey.get(owner + "." + member);
+}
+exports.getElectronFacadeSpecialMemberDescriptor = getElectronFacadeSpecialMemberDescriptor;