@lvce-editor/shared-process 0.26.1 → 0.26.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,12 +18,12 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.26.1",
-    "@lvce-editor/ipc": "^5.1.0",
+    "@lvce-editor/extension-host-helper-process": "0.26.2",
+    "@lvce-editor/ipc": "^7.2.0",
     "@lvce-editor/json-rpc": "^1.3.0",
     "@lvce-editor/jsonc-parser": "^1.2.0",
     "@lvce-editor/pretty-error": "^1.5.0",
-    "@lvce-editor/pty-host": "0.26.1",
+    "@lvce-editor/pty-host": "0.26.2",
     "@lvce-editor/verror": "^1.2.0",
     "@lvce-editor/web-socket-server": "^1.1.0",
     "debug": "^4.3.4",

package/src/parts/ConnectIpcToElectron/ConnectIpcToElectron.js

@@ -1,8 +1,9 @@
 import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+import * as IpcId from '../IpcId/IpcId.js';
 import * as JsonRpc from '../JsonRpc/JsonRpc.js';
 import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 export const connectIpcToElectron = async (ipc) => {
     const { port1, port2 } = await GetPortTuple.getPortTuple();
-    await JsonRpc.invokeAndTransfer(ipc, [port1], 'HandleElectronMessagePort.handleElectronMessagePort', /* isElectron */ true);
+    await JsonRpc.invokeAndTransfer(ipc, [port1], 'HandleElectronMessagePort.handleElectronMessagePort', IpcId.MainProcess);
     await ParentIpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', [port2]);
 };

package/src/parts/EmbedsProcess/EmbedsProcess.js

@@ -1,4 +1,3 @@
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
 import * as LaunchEmbedsProcess from '../LaunchEmbedsProcess/LaunchEmbedsProcess.js';
 export const state = {
     /**
@@ -12,11 +11,3 @@ export const getOrCreate = async () => {
     }
     return state.ipc;
 };
-export const invoke = async (method, ...params) => {
-    const ipc = await getOrCreate();
-    return JsonRpc.invoke(ipc, method, ...params);
-};
-export const invokeAndTransfer = async (method, transfer, ...params) => {
-    const ipc = await getOrCreate();
-    return JsonRpc.invokeAndTransfer(ipc, transfer, method, ...params);
-};

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -1,22 +1,11 @@
-import * as Assert from '../Assert/Assert.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
-import * as IpcChild from '../IpcChild/IpcChild.js';
-import * as IpcChildType from '../IpcChildType/IpcChildType.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
-const mainProcessSpecialId = -5;
-export const handleElectronMessagePort = async (messagePort, ...params) => {
-    Assert.object(messagePort);
-    const ipc = await IpcChild.listen({
-        method: IpcChildType.ElectronMessagePort,
-        messagePort,
-    });
-    HandleIpc.handleIpc(ipc);
-    if (params[0] === mainProcessSpecialId) {
-        // update ipc with message port ipc that supports transferring objects
-        // @ts-ignore
-        ParentIpc.state.ipc = ipc;
-    }
-    // TODO find better way to associate configuration with ipc
-    // @ts-ignore
-    ipc.windowId = params[1];
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleElectronMessagePort = (messagePort, ...params) => {
+    const ipcId = params[0];
+    const windowId = params[1];
+    const message = {
+        ipcId,
+        windowId,
+    };
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.SharedProcess, messagePort, message);
 };

package/src/parts/HandleIncomingIpc/HandleIncomingIpc.js

@@ -0,0 +1,44 @@
+import * as Assert from '../Assert/Assert.js';
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as HandleIpcModule from '../HandleIpcModule/HandleIpcModule.js';
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
+import * as SendIncomingIpc from '../SendIncomingIpc/SendIncomingIpc.js';
+const handleIncomingIpcMessagePort = async (module, handle, message) => {
+    const target = await module.targetMessagePort(handle, message);
+    const response = module.upgradeMessagePort(handle, message);
+    return {
+        target,
+        response,
+    };
+};
+const handleIncomingIpcWebSocket = async (module, handle, message) => {
+    const target = await module.targetWebSocket(handle, message);
+    const response = module.upgradeWebSocket(handle, message);
+    return {
+        target,
+        response,
+    };
+};
+const getIpcAndResponse = (module, handle, message) => {
+    if (IsMessagePortMain.isMessagePortMain(handle)) {
+        return handleIncomingIpcMessagePort(module, handle, message);
+    }
+    return handleIncomingIpcWebSocket(module, handle, message);
+};
+const applyResponse = async (target, response, ipcId) => {
+    switch (response.type) {
+        case 'handle':
+            HandleIpc.handleIpc(target);
+            break;
+        case 'send':
+            return SendIncomingIpc.sendIncomingIpc(target, response, ipcId);
+        default:
+            throw new Error('unexpected response');
+    }
+};
+export const handleIncomingIpc = async (ipcId, handle, message) => {
+    Assert.number(ipcId);
+    const module = HandleIpcModule.getModule(ipcId);
+    const { target, response } = await getIpcAndResponse(module, handle, message);
+    await applyResponse(target, response, ipcId);
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -1,4 +1,25 @@
 import * as HandleMessage from '../HandleMessage/HandleMessage.js';
+const handled = new WeakSet();
 export const handleIpc = (ipc) => {
-    ipc.on('message', HandleMessage.handleMessage);
+    if (handled.has(ipc)) {
+        return;
+    }
+    handled.add(ipc);
+    if ('addEventListener' in ipc) {
+        ipc.addEventListener('message', HandleMessage.handleMessage);
+    }
+    else if ('on' in ipc) {
+        // deprecated
+        ipc.on('message', HandleMessage.handleMessage);
+    }
+};
+export const unhandleIpc = (ipc) => {
+    handled.delete(ipc);
+    if ('removeEventListener' in ipc) {
+        ipc.removeEventListener('message', HandleMessage.handleMessage);
+    }
+    else if ('off' in ipc) {
+        // deprecated
+        ipc.off('message', HandleMessage.handleMessage);
+    }
 };

package/src/parts/HandleIpcEmbedsProcess/HandleIpcEmbedsProcess.js

@@ -0,0 +1,12 @@
+import * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.js';
+export const targetMessagePort = () => {
+    return EmbedsProcess.getOrCreate();
+};
+export const upgradeMessagePort = (port, message) => {
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [message.ipcId],
+        transfer: [port],
+    };
+};

package/src/parts/HandleIpcExtensionHostHelperProcess/HandleIpcExtensionHostHelperProcess.js

@@ -0,0 +1,30 @@
+import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const targetWebSocket = async () => {
+    const ipc = await ExtensionHostHelperProcessIpc.create({
+        method: IpcParentType.NodeForkedProcess,
+    });
+    return ipc;
+};
+export const upgradeWebSocket = (handle, message) => {
+    return {
+        type: 'send',
+        method: 'HandleWebSocket.handleWebSocket',
+        params: [message],
+        transfer: handle,
+    };
+};
+export const targetMessagePort = async () => {
+    const ipc = await ExtensionHostHelperProcessIpc.create({
+        method: IpcParentType.ElectronUtilityProcess,
+    });
+    return ipc;
+};
+export const upgradeMessagePort = (port) => {
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [],
+        transfer: [port],
+    };
+};

package/src/parts/HandleIpcModule/HandleIpcModule.js

@@ -0,0 +1,27 @@
+import * as Assert from '../Assert/Assert.js';
+import * as HandleIpcEmbedsProcess from '../HandleIpcEmbedsProcess/HandleIpcEmbedsProcess.js';
+import * as HandleIpcExtensionHostHelperProcess from '../HandleIpcExtensionHostHelperProcess/HandleIpcExtensionHostHelperProcess.js';
+import * as HandleIpcProcessExplorer from '../HandleIpcProcessExplorer/HandleIpcProcessExplorer.js';
+import * as HandleIpcSearchProcess from '../HandleIpcSearchProcess/HandleIpcSearchProcess.js';
+import * as HandleIpcSharedProcess from '../HandleIpcSharedProcess/HandleIpcSharedProcess.js';
+import * as HandleIpcTerminalProcess from '../HandleIpcTerminalProcess/HandleIpcTerminalProcess.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const getModule = (ipcId) => {
+    Assert.number(ipcId);
+    switch (ipcId) {
+        case IpcId.SharedProcess:
+            return HandleIpcSharedProcess;
+        case IpcId.EmbedsProcess:
+            return HandleIpcEmbedsProcess;
+        case IpcId.TerminalProcess:
+            return HandleIpcTerminalProcess;
+        case IpcId.ExtensionHostHelperProcess:
+            return HandleIpcExtensionHostHelperProcess;
+        case IpcId.ProcessExplorer:
+            return HandleIpcProcessExplorer;
+        case IpcId.SearchProcess:
+            return HandleIpcSearchProcess;
+        default:
+            throw new Error(`unexpected incoming ipc`);
+    }
+};

package/src/parts/HandleIpcProcessExplorer/HandleIpcProcessExplorer.js

@@ -0,0 +1,14 @@
+import * as ProcessExplorer from '../ProcessExplorer/ProcessExplorer.js';
+import * as Assert from '../Assert/Assert.js';
+export const targetMessagePort = () => {
+    return ProcessExplorer.getOrCreate();
+};
+export const upgradeMessagePort = (port) => {
+    Assert.object(port);
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [],
+        transfer: [port],
+    };
+};

package/src/parts/HandleIpcSearchProcess/HandleIpcSearchProcess.js

@@ -0,0 +1 @@
+export {};

package/src/parts/HandleIpcSharedProcess/HandleIpcSharedProcess.js

@@ -0,0 +1,41 @@
+import * as Assert from '../Assert/Assert.js';
+import * as HandleSocketError from '../HandleSocketError/HandleSocketError.js';
+import * as IpcChild from '../IpcChild/IpcChild.js';
+import * as IpcChildType from '../IpcChildType/IpcChildType.js';
+import * as IpcId from '../IpcId/IpcId.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+export const targetWebSocket = async (handle, message) => {
+    handle.on('error', HandleSocketError.handleSocketError);
+    const ipc = await IpcChild.listen({
+        method: IpcChildType.WebSocket,
+        request: message,
+        handle,
+    });
+    return ipc;
+};
+export const upgradeWebSocket = () => {
+    return {
+        type: 'handle',
+    };
+};
+export const targetMessagePort = async (messagePort, message) => {
+    Assert.object(messagePort);
+    const ipc = await IpcChild.listen({
+        method: IpcChildType.ElectronMessagePort,
+        messagePort,
+    });
+    if (message.ipcId === IpcId.MainProcess) {
+        // update ipc with message port ipc that supports transferring objects
+        // @ts-ignore
+        ParentIpc.state.ipc = ipc;
+    }
+    // TODO find better way to associate configuration with ipc
+    // @ts-ignore
+    ipc.windowId = message.windowId;
+    return ipc;
+};
+export const upgradeMessagePort = () => {
+    return {
+        type: 'handle',
+    };
+};

package/src/parts/HandleIpcTerminalProcess/HandleIpcTerminalProcess.js

@@ -0,0 +1,24 @@
+import * as PtyHost from '../PtyHost/PtyHost.js';
+import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+export const targetWebSocket = () => {
+    return PtyHost.getOrCreate(IpcParentType.NodeForkedProcess);
+};
+export const upgradeWebSocket = (handle, message) => {
+    return {
+        type: 'send',
+        method: 'HandleWebSocket.handleWebSocket',
+        params: [message],
+        transfer: handle,
+    };
+};
+export const targetMessagePort = () => {
+    return PtyHost.getOrCreate(IpcParentType.ElectronUtilityProcess);
+};
+export const upgradeMessagePort = (port) => {
+    return {
+        type: 'send',
+        method: 'HandleElectronMessagePort.handleElectronMessagePort',
+        params: [],
+        transfer: [port],
+    };
+};

package/src/parts/HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.js

@@ -1,8 +1,7 @@
-import * as Assert from '../Assert/Assert.js';
-import * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-export const handleMessagePortForEmbedsProcess = async (port) => {
-    Assert.object(port);
-    const embedsProcess = await EmbedsProcess.getOrCreate();
-    await JsonRpc.invokeAndTransfer(embedsProcess, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForEmbedsProcess = (port, ipcId) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.EmbedsProcess, port, {
+        ipcId,
+    });
 };

package/src/parts/HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.js

@@ -15,9 +15,9 @@ export const handleMessagePortForExtensionHostHelperProcess = async (rendererWor
     });
     HandleIpc.handleIpc(ipc);
     await JsonRpc.invokeAndTransfer(ipc, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
-    const cleanup = () => {
-        ipc.dispose();
-        rendererWorkerIpc.off('close', cleanup);
-    };
-    rendererWorkerIpc.on('close', cleanup);
+    // const cleanup = () => {
+    //   ipc.dispose()
+    //   rendererWorkerIpc.off('close', cleanup)
+    // }
+    // rendererWorkerIpc.on('close', cleanup)
 };

package/src/parts/HandleMessagePortForProcessExplorer/HandleMessagePortForProcessExplorer.js

@@ -1,8 +1,5 @@
-import * as Assert from '../Assert/Assert.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as ProcessExplorer from '../ProcessExplorer/ProcessExplorer.js';
-export const handleMessagePortForProcessExplorer = async (port) => {
-    Assert.object(port);
-    const ipc = await ProcessExplorer.getOrCreate();
-    await JsonRpc.invokeAndTransfer(ipc, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForProcessExplorer = (port) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.ProcessExplorer, port, {});
 };

package/src/parts/HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.js

@@ -1,9 +1,5 @@
-import * as Assert from '../Assert/Assert.js';
-import * as IpcParentType from '../IpcParentType/IpcParentType.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as PtyHost from '../PtyHost/PtyHost.js';
-export const handleMessagePortForTerminalProcess = async (port) => {
-    Assert.object(port);
-    const ptyHost = await PtyHost.getOrCreate(IpcParentType.ElectronUtilityProcess);
-    await JsonRpc.invokeAndTransfer(ptyHost, [port], 'HandleElectronMessagePort.handleElectronMessagePort');
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForTerminalProcess = (port) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.TerminalProcess, port, {});
 };

package/src/parts/HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js

@@ -1,9 +1,5 @@
-import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js';
-import * as IpcParentType from '../IpcParentType/IpcParentType.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-export const handleWebSocket = async (message, handle) => {
-    const ipc = await ExtensionHostHelperProcessIpc.create({
-        method: IpcParentType.NodeForkedProcess,
-    });
-    await JsonRpc.invokeAndTransfer(ipc, handle, 'HandleWebSocket.handleWebSocket', message);
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleWebSocket = (message, handle) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.ExtensionHostHelperProcess, handle, message);
 };

package/src/parts/HandleWebSocketForSharedProcess/HandleWebSocketForSharedProcess.js

@@ -1,16 +1,5 @@
-import * as Assert from '../Assert/Assert.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
-import * as HandleSocketError from '../HandleSocketError/HandleSocketError.js';
-import * as IpcChild from '../IpcChild/IpcChild.js';
-import * as IpcChildType from '../IpcChildType/IpcChildType.js';
-export const handleWebSocket = async (request, handle) => {
-    Assert.object(request);
-    Assert.object(handle);
-    handle.on('error', HandleSocketError.handleSocketError);
-    const ipc = await IpcChild.listen({
-        method: IpcChildType.WebSocket,
-        request,
-        handle,
-    });
-    HandleIpc.handleIpc(ipc);
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleWebSocket = (request, handle) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.SharedProcess, handle, request);
 };

package/src/parts/HandleWebSocketForTerminalProcess/HandleWebSocketForTerminalProcess.js

@@ -1,18 +1,5 @@
-import * as PtyHost from '../PtyHost/PtyHost.js';
-export const handleWebSocket = async (message, handle) => {
-    const instance = await PtyHost.getOrCreate();
-    instance.sendAndTransfer({
-        jsonrpc: '2.0',
-        method: 'HandleWebSocket.handleWebSocket',
-        params: [message],
-    }, handle);
-    // console.log({ instance })
-    // const ipc = await PtyHost.getOrCreate()
-    // console.info('[sharedprocess] creating extension ipc')
-    // const rpc = await ExtensionHostRpc.create(ipc, handle)
-    // console.info('[sharedprocess] created extension host rpc')
-    // ipc._process.send(message, handle)
-    // rpc.send(message)
-    // console.log('spawned extension host')
-    // console.log(rpc)
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleWebSocket = (message, handle) => {
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.TerminalProcess, handle, message);
 };

package/src/parts/IpcId/IpcId.js

@@ -0,0 +1,8 @@
+export const SharedProcess = 1;
+export const MainProcess = -5;
+export const EmbedsProcess = 2;
+export const TerminalProcess = 7;
+export const ExtensionHostHelperProcess = 3;
+export const ProcessExplorer = 11;
+export const SearchProcess = 13;
+export const Unknown = 0;

package/src/parts/IpcParentWithElectronUtilityProcess/IpcParentWithElectronUtilityProcess.js

@@ -22,6 +22,7 @@ export const signal = (port) => {
 export const wrap = (port) => {
     return {
         port,
+        wrappedListener: undefined,
         send(message) {
             this.port.postMessage(message);
         },
@@ -34,20 +35,33 @@ export const wrap = (port) => {
                     this.port.on(event, listener);
                     break;
                 case 'message':
-                    const wrapped = (event) => {
+                    // @ts-ignore
+                    this.wrappedListener = (event) => {
                         const syntheticEvent = {
                             data: event.data,
                             target: this,
                         };
                         listener(syntheticEvent);
                     };
-                    this.port.on(event, wrapped);
+                    this.port.on(event, this.wrappedListener);
+                    break;
+                default:
+                    break;
+            }
+        },
+        off(event, listener) {
+            switch (event) {
+                case 'close':
+                    this.port.off(event, listener);
+                    break;
+                case 'message':
+                    this.port.off(event, this.wrappedListener);
+                    this.wrappedListener = undefined;
                     break;
                 default:
                     break;
             }
         },
-        off(event, listener) { },
         dispose() {
             this.port.close();
             ParentIpc.invoke('TemporaryMessagePort.dispose', this.port.name);

package/src/parts/LaunchEmbedsProcess/LaunchEmbedsProcess.js

@@ -13,5 +13,6 @@ export const launchEmbedsProcess = async () => {
     });
     HandleIpc.handleIpc(ipc);
     await ConnectIpcToElectron.connectIpcToElectron(ipc);
+    HandleIpc.unhandleIpc(ipc);
     return ipc;
 };

package/src/parts/LaunchProcessExplorer/LaunchProcessExplorer.js

@@ -13,5 +13,6 @@ export const launchProcessExplorer = async () => {
     });
     HandleIpc.handleIpc(ipc);
     await ConnectIpcToElectron.connectIpcToElectron(ipc);
+    HandleIpc.unhandleIpc(ipc);
     return ipc;
 };

package/src/parts/LaunchPtyHost/LaunchPtyHost.js

@@ -1,6 +1,5 @@
 import exitHook from 'exit-hook';
 import * as Debug from '../Debug/Debug.js';
-import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as PtyHostPath from '../PtyHostPath/PtyHostPath.js';
 import * as PtyHostState from '../PtyHostState/PtyHostState.js';
@@ -24,14 +23,16 @@ export const launchPtyHost = async (method) => {
         stdio: 'inherit',
         name: 'Terminal Process',
     });
-    HandleIpc.handleIpc(ptyHost);
-    const handleClose = () => {
-        // @ts-ignore
-        ptyHost.off('close', handleClose);
-        PtyHostState.state.ipc = undefined;
-        PtyHostState.state.ptyHostPromise = undefined;
-    };
-    ptyHost.on('close', handleClose);
+    // HandleIpc.handleIpc(ptyHost)
+    // TODO
+    // const handleClose = () => {
+    //   // @ts-ignore
+    //   ptyHost._rawIpc.off('close', handleClose)
+    //   PtyHostState.state.ipc = undefined
+    //   PtyHostState.state.ptyHostPromise = undefined
+    // }
+    // // @ts-ignore
+    // ptyHost._rawIpc.on('close', handleClose)
     PtyHostState.state.ipc = ptyHost;
     return ptyHost;
 };

package/src/parts/ModuleMap/ModuleMap.js

@@ -262,7 +262,7 @@ export const getModuleId = (commandId) => {
             return ModuleId.HandleWindowAllClosed;
         case 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess':
             return ModuleId.HandleMessagePortForTerminalProcess;
-        case 'TemporaryMessagePort.handlePort':
+        case 'TemporaryMessagePort.handlePorts':
             return ModuleId.TemporaryMessagePort;
         case 'GetElectronFileResponse.getElectronFileResponse':
             return ModuleId.GetElectronFileResponse;

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.26.1';
-export const commit = 'a044a77';
-export const date = '2024-04-21T08:08:58.000Z';
+export const version = '0.26.2';
+export const commit = 'efc5b0f';
+export const date = '2024-04-23T20:38:06.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/SendIncomingIpc/SendIncomingIpc.js

@@ -0,0 +1,46 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+const state = {
+    pendingCount: Object.create(null),
+};
+const addState = (ipcId) => {
+    state.pendingCount[ipcId] ||= 0;
+    state.pendingCount[ipcId]++;
+};
+const removeState = (ipcId) => {
+    state.pendingCount[ipcId]--;
+    if (state.pendingCount[ipcId] === 0) {
+        delete state.pendingCount[ipcId];
+    }
+};
+const hasState = (ipcId) => {
+    return ipcId in state.pendingCount;
+};
+const supportsPartialIpcHandling = (ipcId) => {
+    switch (ipcId) {
+        case IpcId.TerminalProcess:
+        case IpcId.ProcessExplorer:
+        case IpcId.EmbedsProcess:
+            return true;
+        default:
+            return false;
+    }
+};
+// TODO fork ipc object instead of ref counting
+// duplicated ipc object sends and receives one message
+// original ipc object is never used and can
+// be collected after being out of scope
+// duplicated ipc can also be collected
+// when it is out of scope
+export const sendIncomingIpc = async (target, response, ipcId) => {
+    if (!hasState(ipcId) && supportsPartialIpcHandling(ipcId)) {
+        HandleIpc.handleIpc(target);
+    }
+    addState(ipcId);
+    await JsonRpc.invokeAndTransfer(target, response.transfer, response.method, ...response.params);
+    removeState(ipcId);
+    if (!hasState(ipcId) && supportsPartialIpcHandling(ipcId)) {
+        HandleIpc.unhandleIpc(target);
+    }
+};

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.ipc.js

@@ -1,5 +1,5 @@
 import * as TemporaryMessagePort from './TemporaryMessagePort.js';
 export const name = 'TemporaryMessagePort';
 export const Commands = {
-    handlePort: TemporaryMessagePort.handlePort,
+    handlePorts: TemporaryMessagePort.handlePorts,
 };

package/src/parts/TemporaryMessagePort/TemporaryMessagePort.js

@@ -1,26 +1,17 @@
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 import * as Assert from '../Assert/Assert.js';
 import * as Id from '../Id/Id.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
 export const state = {
     ports: Object.create(null),
 };
-export const create = async (name) => {
-    Assert.string(name);
-    await ParentIpc.invoke('TemporaryMessagePort.create', name);
-    const port = state.ports[name];
-    if (!port) {
-        throw new Error(`port was not created`);
-    }
-    delete state.ports[name];
-    port.start();
-    return port;
-};
 export const getPortTuple = async () => {
-    const id1 = `${Id.create()}`;
-    const id2 = `${Id.create()}`;
+    const id1 = Id.create();
+    const id2 = Id.create();
     await ParentIpc.invoke('TemporaryMessagePort.createPortTuple', id1, id2);
     const port1 = state.ports[id1];
     const port2 = state.ports[id2];
+    delete state.ports[id1];
+    delete state.ports[id2];
     return {
         port1,
         port2,
@@ -31,8 +22,11 @@ export const sendTo = async (name, port) => {
     Assert.object(port);
     await ParentIpc.invokeAndTransfer('TemporaryMessagePort.sendTo', [port], name);
 };
-export const handlePort = (port, name) => {
-    Assert.string(name);
-    Assert.object(port);
-    state.ports[name] = port;
+export const handlePorts = (port1, port2, id1, id2) => {
+    Assert.number(id1);
+    Assert.number(id2);
+    Assert.object(port1);
+    Assert.object(port2);
+    state.ports[id1] = port1;
+    state.ports[id2] = port2;
 };