@lvce-editor/main-process 5.1.0 → 6.0.0

package/dist/mainProcessMain.js

@@ -1063,54 +1063,54 @@ var hasRequiredLib$1;
 function requireLib$1 () {
 	if (hasRequiredLib$1) return lib;
 	hasRequiredLib$1 = 1;
-	(function (exports$1) {
+	(function (exports) {
 
-		Object.defineProperty(exports$1, "__esModule", {
+		Object.defineProperty(exports, "__esModule", {
 		  value: true
 		});
-		Object.defineProperty(exports$1, "isIdentifierChar", {
+		Object.defineProperty(exports, "isIdentifierChar", {
 		  enumerable: true,
 		  get: function () {
 		    return _identifier.isIdentifierChar;
 		  }
 		});
-		Object.defineProperty(exports$1, "isIdentifierName", {
+		Object.defineProperty(exports, "isIdentifierName", {
 		  enumerable: true,
 		  get: function () {
 		    return _identifier.isIdentifierName;
 		  }
 		});
-		Object.defineProperty(exports$1, "isIdentifierStart", {
+		Object.defineProperty(exports, "isIdentifierStart", {
 		  enumerable: true,
 		  get: function () {
 		    return _identifier.isIdentifierStart;
 		  }
 		});
-		Object.defineProperty(exports$1, "isKeyword", {
+		Object.defineProperty(exports, "isKeyword", {
 		  enumerable: true,
 		  get: function () {
 		    return _keyword.isKeyword;
 		  }
 		});
-		Object.defineProperty(exports$1, "isReservedWord", {
+		Object.defineProperty(exports, "isReservedWord", {
 		  enumerable: true,
 		  get: function () {
 		    return _keyword.isReservedWord;
 		  }
 		});
-		Object.defineProperty(exports$1, "isStrictBindOnlyReservedWord", {
+		Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
 		  enumerable: true,
 		  get: function () {
 		    return _keyword.isStrictBindOnlyReservedWord;
 		  }
 		});
-		Object.defineProperty(exports$1, "isStrictBindReservedWord", {
+		Object.defineProperty(exports, "isStrictBindReservedWord", {
 		  enumerable: true,
 		  get: function () {
 		    return _keyword.isStrictBindReservedWord;
 		  }
 		});
-		Object.defineProperty(exports$1, "isStrictReservedWord", {
+		Object.defineProperty(exports, "isStrictReservedWord", {
 		  enumerable: true,
 		  get: function () {
 		    return _keyword.isStrictReservedWord;
@@ -1343,12 +1343,12 @@ function requireLib () {
 
 var libExports = requireLib();
 
-const NewLine$3 = '\n';
-const splitLines$2 = lines => {
-  return lines.split(NewLine$3);
+const NewLine$4 = '\n';
+const splitLines$3 = lines => {
+  return lines.split(NewLine$4);
 };
-const RE_AT$1 = /^\s+at/;
-const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
+const RE_AT$2 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$2 = /^\s*at async Promise.all \(index \d+\)$/;
 const RE_OBJECT_AS = /^\s*at (async )?Object\.\w+ \[as ([\w\.]+)\]/;
 const RE_GET_RESPONSE = /^\s*at async getResponse/;
 const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/;
@@ -1356,7 +1356,7 @@ const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/;
 const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/;
 const RE_ASSERT = /^\s*at .*\/Assert\.js/;
 const isInternalLine = line => {
-  return line.includes('node:') || RE_AT_PROMISE_INDEX$1.test(line) || line.includes('node_modules/ws');
+  return line.includes('node:') || RE_AT_PROMISE_INDEX$2.test(line) || line.includes('node_modules/ws');
 };
 const isRelevantLine = line => {
   return !isInternalLine(line);
@@ -1382,8 +1382,8 @@ const isApplicationUsefulLine = (line, index) => {
   }
   return true;
 };
-const isNormalStackLine$1 = line => {
-  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
+const isNormalStackLine$2 = line => {
+  return RE_AT$2.test(line) && !RE_AT_PROMISE_INDEX$2.test(line);
 };
 const cleanLine = line => {
   if (line.startsWith('    at exports.')) {
@@ -1408,8 +1408,8 @@ const cleanLine = line => {
   }
   return line;
 };
-const getDetails$1 = lines => {
-  const index = lines.findIndex(isNormalStackLine$1);
+const getDetails$2 = lines => {
+  const index = lines.findIndex(isNormalStackLine$2);
   return {
     custom: lines.slice(0, index),
     actualStack: lines.slice(index).map(cleanLine)
@@ -1427,25 +1427,25 @@ const mergeCustom = (custom, relevantStack) => {
   return relevantStack;
 };
 const cleanStack = stack => {
-  const lines = splitLines$2(stack);
+  const lines = splitLines$3(stack);
   const {
     custom,
     actualStack
-  } = getDetails$1(lines);
+  } = getDetails$2(lines);
   const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine);
   const merged = mergeCustom(custom, relevantStack);
   return merged;
 };
 const Utf8 = 'utf8';
-const ERR_MODULE_NOT_FOUND$1 = 'ERR_MODULE_NOT_FOUND';
+const ERR_MODULE_NOT_FOUND$2 = 'ERR_MODULE_NOT_FOUND';
 const getActualPath$1 = fileUri => {
   if (fileUri.startsWith('file://')) {
     return fileURLToPath(fileUri);
   }
   return fileUri;
 };
-const joinLines$2 = lines => {
-  return lines.join(NewLine$3);
+const joinLines$3 = lines => {
+  return lines.join(NewLine$4);
 };
 const warn$1 = (...args) => {
   console.warn(...args);
@@ -1468,7 +1468,7 @@ const prepareModuleNotFoundError = error => {
   const rawLines = readFileSync(importedFrom, Utf8);
   let line = 0;
   let column = 0;
-  const splittedLines = splitLines$2(rawLines);
+  const splittedLines = splitLines$3(rawLines);
   for (let i = 0; i < splittedLines.length; i++) {
     const splittedLine = splittedLines[i];
     const index = splittedLine.indexOf(notFoundModule);
@@ -1485,9 +1485,9 @@ const prepareModuleNotFoundError = error => {
     }
   };
   const codeFrame = libExports.codeFrameColumns(rawLines, location);
-  const stackLines = splitLines$2(error.stack);
+  const stackLines = splitLines$3(error.stack);
   const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)];
-  const newStack = joinLines$2(newStackLines);
+  const newStack = joinLines$3(newStackLines);
   return {
     message,
     stack: newStack,
@@ -1496,7 +1496,7 @@ const prepareModuleNotFoundError = error => {
 };
 const prepare = error => {
   try {
-    if (error && error.code === ERR_MODULE_NOT_FOUND$1) {
+    if (error && error.code === ERR_MODULE_NOT_FOUND$2) {
       return prepareModuleNotFoundError(error);
     }
     const {
@@ -1531,7 +1531,7 @@ const prepare = error => {
         codeFrame = libExports.codeFrameColumns(rawLines, location);
       }
     }
-    const relevantStack = joinLines$2(lines);
+    const relevantStack = joinLines$3(lines);
     return {
       message,
       stack: relevantStack,
@@ -1708,9 +1708,9 @@ const getCombinedMessage = (error, message) => {
   }
   return stringifiedError;
 };
-const NewLine$2 = '\n';
+const NewLine$3 = '\n';
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
+  return string.indexOf(NewLine$3, startIndex);
 };
 const mergeStacks = (parent, child) => {
   if (!child) {
@@ -1748,31 +1748,31 @@ class VError extends Error {
   }
 }
 
-const isMessagePort = value => {
+const isMessagePort$1 = value => {
   return value && value instanceof MessagePort;
 };
-const isMessagePortMain = value => {
+const isMessagePortMain$1 = value => {
   return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-const isOffscreenCanvas = value => {
+const isOffscreenCanvas$1 = value => {
   return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-const isInstanceOf = (value, constructorName) => {
+const isInstanceOf$1 = (value, constructorName) => {
   return value?.constructor?.name === constructorName;
 };
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
+const isSocket$1 = value => {
+  return isInstanceOf$1(value, 'Socket');
 };
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
+const transferrables$1 = [isMessagePort$1, isMessagePortMain$1, isOffscreenCanvas$1, isSocket$1];
+const isTransferrable$1 = value => {
+  for (const fn of transferrables$1) {
     if (fn(value)) {
       return true;
     }
   }
   return false;
 };
-const walkValue = (value, transferrables, isTransferrable) => {
+const walkValue$1 = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
@@ -1782,23 +1782,23 @@ const walkValue = (value, transferrables, isTransferrable) => {
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
+      walkValue$1(item, transferrables, isTransferrable);
     }
     return;
   }
   if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
+      walkValue$1(property, transferrables, isTransferrable);
     }
     return;
   }
 };
-const getTransferrables = value => {
+const getTransferrables$1 = value => {
   const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
+  walkValue$1(value, transferrables, isTransferrable$1);
   return transferrables;
 };
-const removeValues = (value, toRemove) => {
+const removeValues$1 = (value, toRemove) => {
   if (!value) {
     return value;
   }
@@ -1806,7 +1806,7 @@ const removeValues = (value, toRemove) => {
     const newItems = [];
     for (const item of value) {
       if (!toRemove.includes(item)) {
-        newItems.push(removeValues(item, toRemove));
+        newItems.push(removeValues$1(item, toRemove));
       }
     }
     return newItems;
@@ -1815,7 +1815,7 @@ const removeValues = (value, toRemove) => {
     const newObject = Object.create(null);
     for (const [key, property] of Object.entries(value)) {
       if (!toRemove.includes(property)) {
-        newObject[key] = removeValues(property, toRemove);
+        newObject[key] = removeValues$1(property, toRemove);
       }
     }
     return newObject;
@@ -1826,15 +1826,15 @@ const removeValues = (value, toRemove) => {
 // workaround for electron not supporting transferrable objects
 // as parameters. If the transferrable object is a parameter, in electron
 // only an empty objected is received in the main process
-const fixElectronParameters = value => {
-  const transfer = getTransferrables(value);
-  const newValue = removeValues(value, transfer);
+const fixElectronParameters$1 = value => {
+  const transfer = getTransferrables$1(value);
+  const newValue = removeValues$1(value, transfer);
   return {
     newValue,
     transfer
   };
 };
-const getActualDataElectron = event => {
+const getActualDataElectron$1 = event => {
   const {
     data,
     ports
@@ -1847,7 +1847,7 @@ const getActualDataElectron = event => {
     params: [...ports, ...data.params]
   };
 };
-const attachEvents = that => {
+const attachEvents$1 = that => {
   const handleMessage = (...args) => {
     const data = that.getData(...args);
     that.dispatchEvent(new MessageEvent('message', {
@@ -1860,36 +1860,36 @@ const attachEvents = that => {
   };
   that.onClose(handleClose);
 };
-class Ipc extends EventTarget {
+let Ipc$1 = class Ipc extends EventTarget {
   constructor(rawIpc) {
     super();
     this._rawIpc = rawIpc;
-    attachEvents(this);
+    attachEvents$1(this);
   }
-}
-const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
-const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
-const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
 };
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+const E_INCOMPATIBLE_NATIVE_MODULE$1 = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON$1 = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND$1 = 'ERR_MODULE_NOT_FOUND';
+const NewLine$2 = '\n';
+const joinLines$2 = lines => {
+  return lines.join(NewLine$2);
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
+const RE_AT$1 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine$1 = line => {
+  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
+};
+const getDetails$1 = lines => {
+  const index = lines.findIndex(isNormalStackLine$1);
   if (index === -1) {
     return {
-      actualMessage: joinLines$1(lines),
+      actualMessage: joinLines$2(lines),
       rest: []
     };
   }
   let lastIndex = index - 1;
   while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
+    if (!isNormalStackLine$1(lines[lastIndex])) {
       break;
     }
   }
@@ -1898,89 +1898,89 @@ const getDetails = lines => {
     rest: lines.slice(index, lastIndex)
   };
 };
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
+const splitLines$2 = lines => {
+  return lines.split(NewLine$2);
 };
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+const RE_MESSAGE_CODE_BLOCK_START$1 = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END$1 = /^\s* at/;
+const isMessageCodeBlockStartIndex$1 = line => {
+  return RE_MESSAGE_CODE_BLOCK_START$1.test(line);
 };
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+const isMessageCodeBlockEndIndex$1 = line => {
+  return RE_MESSAGE_CODE_BLOCK_END$1.test(line);
 };
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines$1(stderr);
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+const getMessageCodeBlock$1 = stderr => {
+  const lines = splitLines$2(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex$1);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex$1, startIndex);
   const relevantLines = lines.slice(startIndex, endIndex);
   const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
   return relevantMessage;
 };
-const isModuleNotFoundMessage = line => {
+const isModuleNotFoundMessage$1 = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines$1(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+const getModuleNotFoundError$1 = stderr => {
+  const lines = splitLines$2(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage$1);
   const message = lines[messageIndex];
   return {
-    code: ERR_MODULE_NOT_FOUND,
+    code: ERR_MODULE_NOT_FOUND$1,
     message
   };
 };
-const isModuleNotFoundError = stderr => {
+const isModuleNotFoundError$1 = stderr => {
   if (!stderr) {
     return false;
   }
   return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-const isModulesSyntaxError = stderr => {
+const isModulesSyntaxError$1 = stderr => {
   if (!stderr) {
     return false;
   }
   return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+const RE_NATIVE_MODULE_ERROR$1 = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2$1 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError$1 = stderr => {
+  return RE_NATIVE_MODULE_ERROR$1.test(stderr) && RE_NATIVE_MODULE_ERROR_2$1.test(stderr);
 };
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
+const getNativeModuleErrorMessage$1 = stderr => {
+  const message = getMessageCodeBlock$1(stderr);
   return {
-    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    code: E_INCOMPATIBLE_NATIVE_MODULE$1,
     message: `Incompatible native node module: ${message}`
   };
 };
-const getModuleSyntaxError = () => {
+const getModuleSyntaxError$1 = () => {
   return {
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON$1,
     message: `ES Modules are not supported in electron`
   };
 };
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
+const getHelpfulChildProcessError$1 = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError$1(stderr)) {
+    return getNativeModuleErrorMessage$1(stderr);
   }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
+  if (isModulesSyntaxError$1(stderr)) {
+    return getModuleSyntaxError$1();
   }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
+  if (isModuleNotFoundError$1(stderr)) {
+    return getModuleNotFoundError$1(stderr);
   }
-  const lines = splitLines$1(stderr);
+  const lines = splitLines$2(stderr);
   const {
     actualMessage,
     rest
-  } = getDetails(lines);
+  } = getDetails$1(lines);
   return {
     code: '',
     message: actualMessage,
     stack: rest
   };
 };
-class IpcError extends VError {
+let IpcError$1 = class IpcError extends VError {
   // @ts-ignore
   constructor(betterMessage, stdout = '', stderr = '') {
     if (stdout || stderr) {
@@ -1989,7 +1989,7 @@ class IpcError extends VError {
         code,
         message,
         stack
-      } = getHelpfulChildProcessError(stdout, stderr);
+      } = getHelpfulChildProcessError$1(stdout, stderr);
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
@@ -2005,20 +2005,20 @@ class IpcError extends VError {
     // @ts-ignore
     this.stderr = stderr;
   }
-}
-const listen$b = ({
+};
+const listen$b$1 = ({
   messagePort
 }) => {
-  if (!isMessagePortMain(messagePort)) {
-    throw new IpcError('port must be of type MessagePortMain');
+  if (!isMessagePortMain$1(messagePort)) {
+    throw new IpcError$1('port must be of type MessagePortMain');
   }
   return messagePort;
 };
-const signal$c = messagePort => {
+const signal$c$1 = messagePort => {
   messagePort.start();
 };
-class IpcChildWithElectronMessagePort extends Ipc {
-  getData = getActualDataElectron;
+let IpcChildWithElectronMessagePort$2 = class IpcChildWithElectronMessagePort extends Ipc$1 {
+  getData = getActualDataElectron$1;
   send(message) {
     this._rawIpc.postMessage(message);
   }
@@ -2026,7 +2026,7 @@ class IpcChildWithElectronMessagePort extends Ipc {
     const {
       newValue,
       transfer
-    } = fixElectronParameters(message);
+    } = fixElectronParameters$1(message);
     this._rawIpc.postMessage(newValue, transfer);
   }
   dispose() {
@@ -2038,48 +2038,161 @@ class IpcChildWithElectronMessagePort extends Ipc {
   onClose(callback) {
     this._rawIpc.on('close', callback);
   }
-}
-const wrap$j = messagePort => {
-  return new IpcChildWithElectronMessagePort(messagePort);
 };
-const IpcChildWithElectronMessagePort$1 = {
+const wrap$j$1 = messagePort => {
+  return new IpcChildWithElectronMessagePort$2(messagePort);
+};
+const IpcChildWithElectronMessagePort$1$1 = {
   __proto__: null,
-  listen: listen$b,
-  signal: signal$c,
-  wrap: wrap$j
+  listen: listen$b$1,
+  signal: signal$c$1,
+  wrap: wrap$j$1
 };
-
-// @ts-ignore
-const getUtilityProcessPortData = event => {
+const preloadChannelType$1 = 'port';
+const listen$2$1 = ({
+  webContents
+}) => {
+  return webContents;
+};
+const getData$1$1 = (event, message) => {
   const {
-    data,
-    ports
+    ports,
+    sender
   } = event;
-  if (ports.length === 0) {
-    return data;
+  const data = {
+    ...message,
+    params: [...message.params, ...ports, sender.id]
+  };
+  return data;
+};
+let IpcChildWithRendererProcess2$2 = class IpcChildWithRendererProcess2 extends Ipc$1 {
+  getData(event, message) {
+    return getData$1$1(event, message);
+  }
+  send(message) {
+    this._rawIpc.postMessage(preloadChannelType$1, message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables$1(message);
+    this._rawIpc.postMessage(preloadChannelType$1, message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.ipc.on(preloadChannelType$1, callback);
+  }
+  onClose(callback) {
+    this._rawIpc.on('destroyed', callback);
   }
+};
+const wrap$a$1 = webContents => {
+  return new IpcChildWithRendererProcess2$2(webContents);
+};
+const IpcChildWithRendererProcess2$1$1 = {
+  __proto__: null,
+  listen: listen$2$1,
+  wrap: wrap$a$1
+};
+const Exit$1 = 1;
+const Message$1$1 = 3;
+const getFirstUtilityProcessEvent$1 = async utilityProcess => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  let stdout = '';
+  let stderr = '';
+  const cleanup = value => {
+    // @ts-ignore
+    utilityProcess.stderr.off('data', handleStdErrData);
+    // @ts-ignore
+    utilityProcess.stdout.off('data', handleStdoutData);
+    utilityProcess.off('message', handleMessage);
+    utilityProcess.off('exit', handleExit);
+    resolve(value);
+  };
+  const handleStdErrData = data => {
+    stderr += data;
+  };
+  const handleStdoutData = data => {
+    stdout += data;
+  };
+  const handleMessage = event => {
+    cleanup({
+      event,
+      stderr,
+      stdout,
+      type: Message$1$1
+    });
+  };
+  const handleExit = event => {
+    cleanup({
+      event,
+      stderr,
+      stdout,
+      type: Exit$1
+    });
+  };
+  // @ts-ignore
+  utilityProcess.stderr.on('data', handleStdErrData);
+  // @ts-ignore
+  utilityProcess.stdout.on('data', handleStdoutData);
+  utilityProcess.on('message', handleMessage);
+  utilityProcess.on('exit', handleExit);
+  const {
+    event,
+    type
+  } = await promise;
   return {
-    ...data,
-    params: [...ports, ...data.params]
+    event,
+    stderr,
+    stdout,
+    type
   };
 };
-const readyMessage = 'ready';
-const listen$a = () => {
+const create$6$1 = async ({
+  argv = [],
+  env = process.env,
+  execArgv = [],
+  name,
+  path
+}) => {
+  string(path);
+  const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
+  const {
+    utilityProcess
+  } = await import('electron');
+  const childProcess = utilityProcess.fork(path, actualArgv, {
+    env,
+    execArgv,
+    serviceName: name,
+    stdio: 'pipe'
+  });
+  const handleExit = () => {
+    // @ts-ignore
+    childProcess.stdout.unpipe(process.stdout);
+    // @ts-ignore
+    childProcess.stderr.unpipe(process.stderr);
+  };
+  childProcess.once('exit', handleExit);
   // @ts-ignore
+  childProcess.stdout.pipe(process.stdout);
   const {
-    parentPort
-  } = process;
-  if (!parentPort) {
-    throw new IpcError('parent port must be defined');
+    stderr,
+    stdout,
+    type
+  } = await getFirstUtilityProcessEvent$1(childProcess);
+  if (type === Exit$1) {
+    throw new IpcError$1(`Utility process exited before ipc connection was established`, stdout, stderr);
   }
-  return parentPort;
-};
-const signal$b = parentPort => {
-  parentPort.postMessage(readyMessage);
+  // @ts-ignore
+  childProcess.stderr.pipe(process.stderr);
+  return childProcess;
 };
-class IpcChildWithElectronUtilityProcess extends Ipc {
-  getData(event) {
-    return getUtilityProcessPortData(event);
+let IpcParentWithElectronUtilityProcess$2 = class IpcParentWithElectronUtilityProcess extends Ipc$1 {
+  getData(data) {
+    return data;
   }
   send(message) {
     this._rawIpc.postMessage(message);
@@ -2088,1574 +2201,950 @@ class IpcChildWithElectronUtilityProcess extends Ipc {
     const {
       newValue,
       transfer
-    } = fixElectronParameters(message);
+    } = fixElectronParameters$1(message);
     this._rawIpc.postMessage(newValue, transfer);
   }
   dispose() {
-    this._rawIpc.close();
+    this._rawIpc.kill();
   }
   onClose(callback) {
-    this._rawIpc.on('close', callback);
+    this._rawIpc.on('exit', callback);
   }
   onMessage(callback) {
     this._rawIpc.on('message', callback);
   }
-}
-const wrap$i = parentPort => {
-  return new IpcChildWithElectronUtilityProcess(parentPort);
-};
-const IpcChildWithElectronUtilityProcess$1 = {
-  __proto__: null,
-  listen: listen$a,
-  signal: signal$b,
-  wrap: wrap$i
-};
-const getActualData = (message, handle) => {
-  if (handle) {
-    return {
-      ...message,
-      params: [handle, ...message.params]
-    };
-  }
-  return message;
-};
-const getTransferrablesNode = value => {
-  const transferrables = getTransferrables(value);
-  if (transferrables.length === 0) {
-    throw new Error(`no transferrables found`);
-  }
-  return transferrables[0];
 };
-const listen$5 = async () => {
-  if (!process.send) {
-    throw new IpcError('process.send must be defined');
-  }
-  return process;
+const wrap$6$1 = process => {
+  return new IpcParentWithElectronUtilityProcess$2(process);
 };
-const signal$7 = process => {
-  process.send(readyMessage);
+const IpcParentWithElectronUtilityProcess$1$2 = {
+  __proto__: null,
+  create: create$6$1,
+  wrap: wrap$6$1
 };
-class IpcChildWithNodeForkedProcess extends Ipc {
-  getData(message, handle) {
-    return getActualData(message, handle);
-  }
-  onClose(callback) {
-    this._rawIpc.on('close', callback);
-  }
-  send(message) {
-    this._rawIpc.send(message);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrablesNode(message);
-    this._rawIpc.send(message, transfer);
-  }
-  dispose() {
-    // ignore
+
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
   }
 }
-const wrap$d = process => {
-  return new IpcChildWithNodeForkedProcess(process);
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const IpcChildWithNodeForkedProcess$1 = {
-  __proto__: null,
-  listen: listen$5,
-  signal: signal$7,
-  wrap: wrap$d
+const getCommand = key => {
+  return commands[key];
 };
-const listen$3 = async () => {
-  const {
-    parentPort
-  } = await import('node:worker_threads');
-  if (!parentPort) {
-    throw new IpcError('parentPort is required for node worker threads ipc');
+const execute$1 = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
   }
-  return parentPort;
+  return fn(...args);
 };
-const signal$5 = parentPort => {
-  parentPort.postMessage(readyMessage);
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
+const set$2 = (id, fn) => {
+  callbacks[id] = fn;
 };
-class IpcChildWithNodeWorker extends Ipc {
-  getData(data) {
-    return data;
-  }
-  onClose(callback) {
-    this._rawIpc.on('close', callback);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrablesNode(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    this._rawIpc.close();
-  }
-}
-const wrap$b = parentPort => {
-  return new IpcChildWithNodeWorker(parentPort);
+const get$4 = id => {
+  return callbacks[id];
 };
-const IpcChildWithNodeWorker$1 = {
-  __proto__: null,
-  listen: listen$3,
-  signal: signal$5,
-  wrap: wrap$b
+const remove$2 = id => {
+  delete callbacks[id];
 };
-const preloadChannelType = 'port';
-const listen$2 = ({
-  webContents
-}) => {
-  return webContents;
+let id$1 = 0;
+const create$3$1 = () => {
+  return ++id$1;
 };
-const getData$1 = (event, message) => {
+const registerPromise$1 = () => {
+  const id = create$3$1();
   const {
-    ports,
-    sender
-  } = event;
-  const data = {
-    ...message,
-    params: [...message.params, ...ports, sender.id]
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  set$2(id, resolve);
+  return {
+    id,
+    promise
   };
-  return data;
 };
-class IpcChildWithRendererProcess2 extends Ipc {
-  getData(event, message) {
-    return getData$1(event, message);
+const create$2$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise$1();
+  const message = {
+    id,
+    jsonrpc: Two$1,
+    method,
+    params
+  };
+  return {
+    message,
+    promise
+  };
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
   }
-  send(message) {
-    this._rawIpc.postMessage(preloadChannelType, message);
+}
+const NewLine$1 = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case ReferenceError$1:
+        return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
+      default:
+        return Error;
+    }
   }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(preloadChannelType, message, transfer);
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
   }
-  dispose() {
-    // ignore
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
   }
-  onMessage(callback) {
-    this._rawIpc.ipc.on(preloadChannelType, callback);
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
   }
-  onClose(callback) {
-    this._rawIpc.on('destroyed', callback);
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
   }
-}
-const wrap$a = webContents => {
-  return new IpcChildWithRendererProcess2(webContents);
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
 };
-const IpcChildWithRendererProcess2$1 = {
-  __proto__: null,
-  listen: listen$2,
-  wrap: wrap$a
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
 };
-const addListener = (emitter, type, callback) => {
-  if ('addEventListener' in emitter) {
-    emitter.addEventListener(type, callback);
-  } else {
-    emitter.on(type, callback);
-  }
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
 };
-const removeListener = (emitter, type, callback) => {
-  if ('removeEventListener' in emitter) {
-    emitter.removeEventListener(type, callback);
-  } else {
-    emitter.off(type, callback);
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$1 + parentStack;
   }
+  return parentStack;
 };
-const getFirstEvent = (eventEmitter, eventMap) => {
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  const listenerMap = Object.create(null);
-  const cleanup = value => {
-    for (const event of Object.keys(eventMap)) {
-      removeListener(eventEmitter, event, listenerMap[event]);
+const MethodNotFound = -32601;
+const Custom = -32001;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine$1 + currentStack;
     }
-    resolve(value);
-  };
-  for (const [event, type] of Object.entries(eventMap)) {
-    const listener = event => {
-      cleanup({
-        event,
-        type
-      });
-    };
-    addListener(eventEmitter, event, listener);
-    listenerMap[event] = listener;
+    return error;
   }
-  return promise;
-};
-const create$7$1 = ({
-  messagePort
-}) => {
-  if (!isMessagePortMain(messagePort)) {
-    throw new IpcError('port must be of type MessagePortMain');
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine$1 + currentStack;
+    return restoredError;
   }
-  return messagePort;
-};
-const signal$2 = messagePort => {
-  messagePort.start();
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$1 + error.data.stack + NewLine$1 + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
 };
-class IpcParentWithElectronMessagePort extends Ipc {
-  getData = getActualDataElectron;
-  send(message) {
-    this._rawIpc.postMessage(message);
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
   }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, transfer);
+  if ('result' in responseMessage) {
+    return responseMessage.result;
   }
-  dispose() {
-    this._rawIpc.close();
+  throw new JsonRpcError('unexpected response message');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$4(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
   }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
+  fn(response);
+  remove$2(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
   }
-  onClose(callback) {
-    this._rawIpc.on('close', callback);
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
   }
-}
-const wrap$7 = messagePort => {
-  return new IpcParentWithElectronMessagePort(messagePort);
+  return undefined;
 };
-const IpcParentWithElectronMessagePort$1 = {
-  __proto__: null,
-  create: create$7$1,
-  signal: signal$2,
-  wrap: wrap$7
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
 };
-const Exit = 1;
-const Error$2 = 2;
-const Message$1 = 3;
-const getFirstUtilityProcessEvent = async utilityProcess => {
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  let stdout = '';
-  let stderr = '';
-  const cleanup = value => {
-    // @ts-ignore
-    utilityProcess.stderr.off('data', handleStdErrData);
-    // @ts-ignore
-    utilityProcess.stdout.off('data', handleStdoutData);
-    utilityProcess.off('message', handleMessage);
-    utilityProcess.off('exit', handleExit);
-    resolve(value);
-  };
-  const handleStdErrData = data => {
-    stderr += data;
-  };
-  const handleStdoutData = data => {
-    stdout += data;
-  };
-  const handleMessage = event => {
-    cleanup({
-      event,
-      stderr,
-      stdout,
-      type: Message$1
-    });
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      data: error.stack,
+      message: error.message
+    };
+  }
+  return {
+    code: Custom,
+    data: {
+      code: prettyError.code,
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
-  const handleExit = event => {
-    cleanup({
-      event,
-      stderr,
-      stdout,
-      type: Exit
-    });
+};
+const create$1$2 = (id, error) => {
+  return {
+    error,
+    id,
+    jsonrpc: Two$1
   };
-  // @ts-ignore
-  utilityProcess.stderr.on('data', handleStdErrData);
-  // @ts-ignore
-  utilityProcess.stdout.on('data', handleStdoutData);
-  utilityProcess.on('message', handleMessage);
-  utilityProcess.on('exit', handleExit);
-  const {
-    event,
-    type
-  } = await promise;
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$2(id, errorProperty);
+};
+const create$c = (message, result) => {
   return {
-    event,
-    stderr,
-    stdout,
-    type
+    id: message.id,
+    jsonrpc: Two$1,
+    result: result ?? null
   };
 };
-const create$6$1 = async ({
-  argv = [],
-  env = process.env,
-  execArgv = [],
-  name,
-  path
-}) => {
-  string(path);
-  const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
-  const {
-    utilityProcess
-  } = await import('electron');
-  const childProcess = utilityProcess.fork(path, actualArgv, {
-    env,
-    execArgv,
-    serviceName: name,
-    stdio: 'pipe'
-  });
-  const handleExit = () => {
-    // @ts-ignore
-    childProcess.stdout.unpipe(process.stdout);
-    // @ts-ignore
-    childProcess.stderr.unpipe(process.stderr);
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$c(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error,
+      // @ts-ignore
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
-  childProcess.once('exit', handleExit);
-  // @ts-ignore
-  childProcess.stdout.pipe(process.stdout);
-  const {
-    stderr,
-    stdout,
-    type
-  } = await getFirstUtilityProcessEvent(childProcess);
-  if (type === Exit) {
-    throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
-  }
-  // @ts-ignore
-  childProcess.stderr.pipe(process.stderr);
-  return childProcess;
 };
-let IpcParentWithElectronUtilityProcess$1 = class IpcParentWithElectronUtilityProcess extends Ipc {
-  getData(data) {
-    return data;
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, transfer);
-  }
-  dispose() {
-    this._rawIpc.kill();
-  }
-  onClose(callback) {
-    this._rawIpc.on('exit', callback);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
-const wrap$6 = process => {
-  return new IpcParentWithElectronUtilityProcess$1(process);
+const defaultPreparePrettyError = error => {
+  return error;
 };
-const IpcParentWithElectronUtilityProcess$1$1 = {
-  __proto__: null,
-  create: create$6$1,
-  wrap: wrap$6
+const defaultLogError = () => {
+  // ignore
 };
-class ChildProcessError extends Error {
-  // @ts-ignore
-  constructor(stderr) {
-    // @ts-ignore
-    const {
-      code,
-      message,
-      stack
-    } = getHelpfulChildProcessError('', stderr);
-    super(message || 'child process error');
-    this.name = 'ChildProcessError';
-    if (code) {
-      // @ts-ignore
-      this.code = code;
-    }
-    if (stack) {
-      // @ts-ignore
-      const lines = splitLines$1(this.stack);
-      const [firstLine, ...stackLines] = lines;
-      const newStackLines = [firstLine, ...stack, ...stackLines];
-      const newStack = joinLines$1(newStackLines);
-      this.stack = newStack;
-    }
-  }
-}
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
 
-// workaround for node not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter,
-// it is received as a plain object is received in the receiving process
-const fixNodeChildProcessParameters = value => {
-  const transfer = getTransferrables(value);
-  if (transfer.length === 0) {
-    throw new IpcError('no transferrables found');
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      execute: options.execute,
+      ipc: options.ipc,
+      logError: options.logError || defaultLogError,
+      message: options.message,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
+    };
   }
-  const newValue = removeValues(value, transfer);
   return {
-    newValue,
-    transfer: transfer[0]
+    execute: args[2],
+    ipc: args[0],
+    logError: args[5],
+    message: args[1],
+    preparePrettyError: args[4],
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
-const getFirstNodeChildProcessEvent = async childProcess => {
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
   const {
-    event,
-    stderr,
-    stdout,
-    type
-  } = await new Promise((resolve, reject) => {
-    let stderr = '';
-    let stdout = '';
-    const cleanup = value => {
-      if (childProcess.stdout && childProcess.stderr) {
-        childProcess.stderr.off('data', handleStdErrData);
-        childProcess.stdout.off('data', handleStdoutData);
+    execute,
+    ipc,
+    logError,
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
       }
-      childProcess.off('message', handleMessage);
-      childProcess.off('exit', handleExit);
-      childProcess.off('error', handleError);
-      resolve(value);
-    };
-    const handleStdErrData = data => {
-      stderr += data;
-    };
-    const handleStdoutData = data => {
-      stdout += data;
-    };
-    const handleMessage = event => {
-      cleanup({
-        event,
-        stderr,
-        stdout,
-        type: Message$1
-      });
-    };
-    const handleExit = event => {
-      cleanup({
-        event,
-        stderr,
-        stdout,
-        type: Exit
-      });
-    };
-    const handleError = event => {
-      cleanup({
-        event,
-        stderr,
-        stdout,
-        type: Error$2
-      });
-    };
-    if (childProcess.stdout && childProcess.stderr) {
-      childProcess.stderr.on('data', handleStdErrData);
-      childProcess.stdout.on('data', handleStdoutData);
+      return;
     }
-    childProcess.on('message', handleMessage);
-    childProcess.on('exit', handleExit);
-    childProcess.on('error', handleError);
-  });
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+const invokeHelper$1 = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  if (ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
+  return invokeHelper$1(ipc, method, params);
+};
+
+const Two = '2.0';
+
+const create$b = (method, params) => {
   return {
-    event,
-    stderr,
-    stdout,
-    type
+    jsonrpc: Two,
+    method,
+    params
   };
 };
 
-// @ts-ignore
-const create$2$2 = async ({
-  argv = [],
-  env,
-  execArgv = [],
-  name = 'child process',
-  path,
-  stdio = 'inherit'
-}) => {
-  try {
-    string(path);
-    const actualArgv = ['--ipc-type=node-forked-process', ...argv];
-    const {
-      fork
-    } = await import('node:child_process');
-    const childProcess = fork(path, actualArgv, {
-      env,
-      execArgv,
-      stdio: 'pipe'
-    });
-    const {
-      event,
-      stderr,
-      type
-    } = await getFirstNodeChildProcessEvent(childProcess);
-    if (type === Exit) {
-      throw new ChildProcessError(stderr);
-    }
-    if (type === Error$2) {
-      throw new IpcError(`child process had an error ${event}`);
-    }
-    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
-      childProcess.stdout.pipe(process.stdout);
-      childProcess.stderr.pipe(process.stderr);
-    }
-    return childProcess;
-  } catch (error) {
-    throw new VError(error, `Failed to launch ${name}`);
-  }
-};
-class IpcParentWithNodeForkedProcess extends Ipc {
-  constructor(childProcess) {
-    super(childProcess);
-    this.pid = childProcess.pid;
-  }
-  getData(message) {
-    return message;
-  }
-  send(message) {
-    this._rawIpc.send(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixNodeChildProcessParameters(message);
-    this._rawIpc.send(newValue, transfer);
-  }
-  dispose() {
-    this._rawIpc.kill();
-  }
-  onClose(callback) {
-    this._rawIpc.on('close', callback);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-}
-const wrap$2 = childProcess => {
-  return new IpcParentWithNodeForkedProcess(childProcess);
-};
-const IpcParentWithNodeForkedProcess$1 = {
-  __proto__: null,
-  create: create$2$2,
-  wrap: wrap$2
-};
-const fixNodeWorkerParameters = value => {
-  const transfer = getTransferrables(value);
-  if (transfer.length === 0) {
-    throw new IpcError('no transferrables found');
-  }
-  return {
-    newValue: value,
-    transfer: transfer
-  };
-};
-const getFirstNodeWorkerEvent = worker => {
-  return getFirstEvent(worker, {
-    error: Error$2,
-    exit: Exit,
-    message: Message$1
-  });
-};
-const create$1$2 = async ({
-  argv = [],
-  env = process.env,
-  execArgv = [],
-  name,
-  path,
-  stdio
-}) => {
-  string(path);
-  const actualArgv = ['--ipc-type=node-worker', ...argv];
-  const actualEnv = {
-    ...env,
-    ELECTRON_RUN_AS_NODE: '1'
+const create$a = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
   };
-  const ignoreStdio = stdio === 'inherit' ? undefined : true;
-  const {
-    Worker
-  } = await import('node:worker_threads');
-  const worker = new Worker(path, {
-    argv: actualArgv,
-    env: actualEnv,
-    execArgv,
-    name,
-    stderr: ignoreStdio,
-    stdout: ignoreStdio
-  });
-  const {
-    event,
-    type
-  } = await getFirstNodeWorkerEvent(worker);
-  if (type === Exit) {
-    throw new IpcError(`Worker exited before ipc connection was established`);
-  }
-  if (type === Error$2) {
-    throw new IpcError(`Worker threw an error before ipc connection was established: ${event}`);
-  }
-  if (event !== readyMessage) {
-    throw new IpcError('unexpected first message from worker');
-  }
-  return worker;
-};
-class IpcParentWithNodeWorker extends Ipc {
-  getData(message) {
-    return message;
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixNodeWorkerParameters(message);
-    this._rawIpc.postMessage(newValue, transfer);
-  }
-  async dispose() {
-    await this._rawIpc.terminate();
-  }
-  onClose(callback) {
-    this._rawIpc.on('exit', callback);
-  }
-  onMessage(callback) {
-    this._rawIpc.on('message', callback);
-  }
-}
-const wrap$1 = worker => {
-  return new IpcParentWithNodeWorker(worker);
-};
-const IpcParentWithNodeWorker$1 = {
-  __proto__: null,
-  create: create$1$2,
-  wrap: wrap$1
+  return message;
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute$1 = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
+let id = 0;
+const create$9 = () => {
+  return ++id;
 };
 
-const Two$1 = '2.0';
-const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get$4 = id => {
-  return callbacks[id];
-};
-const remove$2 = id => {
-  delete callbacks[id];
-};
-let id$1 = 0;
-const create$3$1 = () => {
-  return ++id$1;
-};
-const registerPromise$1 = () => {
-  const id = create$3$1();
+const registerPromise = map => {
+  const id = create$9();
   const {
     promise,
     resolve
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  map[id] = resolve;
   return {
     id,
     promise
   };
 };
-const create$2$1 = (method, params) => {
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
-  } = registerPromise$1();
-  const message = {
-    id,
-    jsonrpc: Two$1,
-    method,
-    params
+  } = registerPromise(callbacks);
+  const message = create$a(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
   };
-  return {
-    message,
-    promise
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$b(method, params);
+      ipc.send(message);
+    }
   };
+  return rpc;
 };
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
+
+const requiresSocket$1 = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError$1 = () => {
+  // handled by renderer worker
+};
+const handleMessage$1 = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
+  const actualExecute = event?.target?.execute || execute$1;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+};
+
+const handleIpc$1 = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage$1);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage$1);
   }
-}
-const NewLine = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case ReferenceError$1:
-        return ReferenceError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case TypeError$1:
-        return TypeError;
-      default:
-        return Error;
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
-  }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
-  }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
-    }
-    return error;
-  }
-  return new ErrorConstructor(message);
-};
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
-const getCurrentStack = () => {
-  const stackLinesToSkip = 3;
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
-  return currentStack;
-};
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
 };
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
+
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
   }
-  return parentStack;
+  const ipc = module.wrap(rawIpc);
+  return ipc;
 };
-const MethodNotFound = -32601;
-const Custom = -32001;
-const restoreJsonRpcError = error => {
-  const currentStack = getCurrentStack();
-  if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
-  }
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
+
+const create$8 = async ({
+  commandMap,
+  messagePort,
+  requiresSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithElectronMessagePort$1$1, {
+    messagePort
+  });
+  if (requiresSocket) {
+    ipc.requiresSocket = requiresSocket;
   }
-  return new Error(`JsonRpc Error: ${error}`);
+  handleIpc$1(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
+
+const create$5 = async ({
+  argv,
+  commandMap,
+  env,
+  execArgv,
+  name,
+  path,
+  requiresSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithElectronUtilityProcess$1$2.create({
+    argv,
+    env,
+    execArgv,
+    name,
+    path
+  });
+  const ipc = IpcParentWithElectronUtilityProcess$1$2.wrap(rawIpc);
+  if (requiresSocket) {
+    // @ts-ignore
+    ipc.requiresSocket = requiresSocket;
   }
-  throw new JsonRpcError('unexpected response message');
-};
-const warn = (...args) => {
-  console.warn(...args);
+  handleIpc$1(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
-const resolve = (id, response) => {
-  const fn = get$4(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
+
+const create$4 = async ({
+  commandMap,
+  requiresSocket,
+  webContents
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = IpcChildWithRendererProcess2$1$1.wrap(webContents);
+  if (requiresSocket) {
+    // @ts-ignore
+    ipc.requiresSocket = requiresSocket;
   }
-  fn(response);
-  remove$2(id);
+  handleIpc$1(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
-  }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
-  }
-  return undefined;
+
+const commandMapRef = Object.create(null);
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannelMain();
+  return {
+    port1,
+    port2
+  };
 };
-const isAlreadyStack = line => {
-  return line.trim().startsWith('at ');
+
+const getSharedProcessArgv = isProduction => {
+  return [];
 };
-const getStack = prettyError => {
-  const stackString = prettyError.stack || '';
-  const newLineIndex = stackString.indexOf('\n');
-  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
-    return stackString.slice(newLineIndex + 1);
-  }
-  return stackString;
+
+const EmbedsProcess = 2;
+const MainProcess = -5;
+
+const mark = key => {
+  performance.mark(key);
 };
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      data: error.stack,
-      message: error.message
-    };
-  }
+const toUiEntry = performanceEntry => {
   return {
-    code: Custom,
-    data: {
-      code: prettyError.code,
-      codeFrame: prettyError.codeFrame,
-      name: prettyError.name,
-      stack: getStack(prettyError),
-      type: getErrorType(prettyError)
-    },
-    message: prettyError.message
+    detail: performanceEntry.detail,
+    duration: performanceEntry.duration,
+    entryType: performanceEntry.entryType,
+    name: performanceEntry.name,
+    startTime: performanceEntry.startTime
   };
 };
-const create$1$1 = (id, error) => {
-  return {
-    error,
-    id,
-    jsonrpc: Two$1
-  };
+const getEntries = () => {
+  const entries = performance.getEntries();
+  const uiEntries = entries.map(toUiEntry);
+  return uiEntries;
 };
-const getErrorResponse = (id, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
-};
-const create$9 = (message, result) => {
-  return {
-    id: message.id,
-    jsonrpc: Two$1,
-    result: result ?? null
-  };
+const {
+  timeOrigin
+} = performance;
+
+const Performance = {
+	__proto__: null,
+	getEntries,
+	mark,
+	timeOrigin
 };
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+
+const WillLoadUrl = 'code/willLoadUrl';
+const DidLoadUrl = 'code/didLoadUrl';
+const AppReady = 'code/appReady';
+const WillStartSharedProcess = 'code/willStartSharedProcess';
+const DidStartSharedProcess = 'code/didStartSharedProcess';
+const WillCreateCodeWindow = 'code/willCreateCodeWindow';
+const DidCreateCodeWindow = 'code/didCreateCodeWindow';
+
+const join = (...paths) => {
+  return NodePath.join(...paths);
 };
-const getErrorResponseSimple = (id, error) => {
-  return {
-    error: {
-      code: Custom,
-      data: error,
-      // @ts-ignore
-      message: error.message
-    },
-    id,
-    jsonrpc: Two$1
-  };
+
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+const root = process.env.LVCE_ROOT || join(__dirname$1, '../../../../..');
+
+const {
+  env,
+  platform
+} = process;
+const isLinux = platform === 'linux';
+const isProduction = false;
+const homeDirectory = homedir();
+
+const xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? join(homeDirectory, '.cache') : undefined);
+const xdgData = env.XDG_DATA_HOME || (homeDirectory ? join(homeDirectory, '.local', 'share') : undefined);
+join(xdgData || tmpdir(), applicationName);
+const chromeUserDataPath = xdgCache ? join(xdgCache, applicationName, 'userdata') : '';
+
+const useIpcForResponse = true;
+const getSessionId = () => {
+  return process.env.SESSION_ID || `persist:${scheme}`;
 };
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    if (ipc.canUseSimpleErrorResponse) {
-      return getErrorResponseSimple(message.id, error);
-    }
-    return getErrorResponse(message.id, error, preparePrettyError, logError);
+const getSharedProcessPath = () => {
+  if (process.env.LVCE_SHARED_PROCESS_PATH) {
+    return process.env.LVCE_SHARED_PROCESS_PATH;
   }
+  return join(root, 'packages', 'shared-process', 'src', 'sharedProcessMain.ts');
 };
-const defaultPreparePrettyError = error => {
-  return error;
-};
-const defaultLogError = () => {
-  // ignore
-};
-const defaultRequiresSocket = () => {
+
+const requiresSocket = () => {
   return false;
 };
-const defaultResolve = resolve;
 
-// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
-const normalizeParams = args => {
-  if (args.length === 1) {
-    const options = args[0];
-    return {
-      execute: options.execute,
-      ipc: options.ipc,
-      logError: options.logError || defaultLogError,
-      message: options.message,
-      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket,
-      resolve: options.resolve || defaultResolve
-    };
-  }
-  return {
-    execute: args[2],
-    ipc: args[0],
-    logError: args[5],
-    message: args[1],
-    preparePrettyError: args[4],
-    requiresSocket: args[6],
-    resolve: args[3]
-  };
-};
-const handleJsonRpcMessage = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    execute,
-    ipc,
-    logError,
-    message,
-    preparePrettyError,
-    requiresSocket,
-    resolve
-  } = options;
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
-  }
-  throw new JsonRpcError('unexpected message');
+const handleChildError = error => {
+  exit$1(Error$3);
 };
-const invokeHelper$1 = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
+const handleChildExit = code => {
+  info(`[main process] shared process exited with code ${code}`);
+  exit$1(code);
 };
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper$1(ipc, method, params);
+const handleChildDisconnect = () => {
+  info('[main process] shared process disconnected');
 };
-
-const Two = '2.0';
-
-const create$8 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
+const launchSharedProcess = async ({
+  env = {},
+  method
+}) => {
+  mark(WillStartSharedProcess);
+  const sharedProcessPath = getSharedProcessPath();
+  const execArgv = getSharedProcessArgv();
+  const fullEnv = {
+    ...process.env,
+    ...env
   };
-};
+  const sharedProcessRpc = await create$5({
+    argv: [],
+    commandMap: commandMapRef,
+    env: fullEnv,
+    execArgv,
+    name: 'shared-process',
+    path: sharedProcessPath,
+    // @ts-ignore
+    requiresSocket: requiresSocket
+  });
 
-const create$7 = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
-  };
-  return message;
-};
+  // @ts-ignore
+  const sharedProcess = sharedProcessRpc.ipc;
+  // @ts-ignore
+  sharedProcess._rawIpc.on('error', handleChildError);
+  // @ts-ignore
+  sharedProcess._rawIpc.on('exit', handleChildExit);
+  // @ts-ignore
+  sharedProcess._rawIpc.on('disconnect', handleChildDisconnect);
 
-let id = 0;
-const create$6 = () => {
-  return ++id;
+  // create secondary ipc to support transferring objects
+  // from shared process to main process
+  // TODO let shared process ask for secondary
+  // ipc instead of sending it directly?
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await sharedProcessRpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port2, MainProcess);
+  await create$8({
+    commandMap: commandMapRef,
+    messagePort: port1,
+    requiresSocket: requiresSocket
+  });
+  mark(DidStartSharedProcess);
+  return sharedProcessRpc;
 };
 
-const registerPromise = map => {
-  const id = create$6();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  map[id] = resolve;
-  return {
-    id,
-    promise
-  };
+const state$5 = {
+  /**
+   * @type {any}
+   */
+  promise: undefined
 };
 
-const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
-  const {
-    id,
-    promise
-  } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
+const getOrCreate = async ({
+  env = {},
+  method
+}) => {
+  if (!state$5.promise) {
+    // @ts-ignore
+    state$5.promise = launchSharedProcess({
+      env,
+      method
+    });
   }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
+  return state$5.promise;
 };
-const createRpc = ipc => {
-  const callbacks = Object.create(null);
-  ipc._resolve = (id, response) => {
-    const fn = callbacks[id];
-    if (!fn) {
-      console.warn(`callback ${id} may already be disposed`);
-      return;
-    }
-    fn(response);
-    delete callbacks[id];
-  };
-  const rpc = {
-    async dispose() {
-      await ipc?.dispose();
-    },
-    invoke(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, false);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, true);
-    },
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      const message = create$8(method, params);
-      ipc.send(message);
+const send$1 = async (method, ...params) => {
+  const rpc = await getOrCreate({
+    method: ElectronUtilityProcess$1
+  });
+  rpc.send(method, ...params);
+};
+const invoke = async (method, ...params) => {
+  const rpc = await getOrCreate({
+    method: ElectronUtilityProcess$1
+  });
+  return rpc.invoke(method, ...params);
+};
+const invokeAndTransfer = async (method, ...params) => {
+  const rpc = await getOrCreate({
+    method: ElectronUtilityProcess$1
+  });
+  return rpc.invokeAndTransfer(method, ...params);
+};
+
+const handleCliArgs = async parsedArgs => {
+  try {
+    await invoke('HandleCliArgs.handleCliArgs', parsedArgs);
+  } catch (error) {
+    setExitCode(Error$3);
+    if (error && error instanceof Error && error.stack && error.stack.includes('shared-process')) ; else {
+      handleError(error);
     }
-  };
-  return rpc;
+  } finally {
+    exit();
+  }
 };
 
-const requiresSocket$1 = () => {
-  return false;
+const CliForwardToSharedProcess = {
+	__proto__: null,
+	handleCliArgs
 };
-const preparePrettyError = error => {
-  return error;
+
+const SharedProcess = 4;
+const None = 0;
+
+const on = (event, listener) => {
+  app.on(event, listener);
 };
-const logError$1 = () => {
-  // handled by renderer worker
+const whenReady = () => {
+  return app.whenReady();
 };
-const handleMessage$1 = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
-  const actualExecute = event?.target?.execute || execute$1;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+const appendCommandLineSwitch = (commandLineSwitch, value) => {
+  app.commandLine.appendSwitch(commandLineSwitch, value);
 };
 
-const handleIpc$1 = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage$1);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage$1);
-  }
-};
+const Version = 'version';
+const Help = 'help';
+const Wait = 'wait';
+const BuiltinSelfTest = 'built-in-self-test';
+const Web = 'web';
+const SandBox = 'sandbox';
+const Install = 'install';
+const List = 'list';
+const Link = 'link';
+const Unlink = 'unlink';
+const Status = 'status';
 
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
+const getCliModuleId = parsedArgs => {
+  const arg0 = parsedArgs._[0];
+  if (arg0 === Install || arg0 === List || arg0 === Link || arg0 === Unlink || parsedArgs[Status] || parsedArgs[Version] || parsedArgs[Help] || parsedArgs[Web] || parsedArgs[BuiltinSelfTest]) {
+    return SharedProcess;
   }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
+  return None;
 };
 
-const create$5 = async ({
-  commandMap,
-  messagePort,
-  requiresSocket
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
-    messagePort
-  });
-  if (requiresSocket) {
-    ipc.requiresSocket = requiresSocket;
+const getModule$3 = moduleId => {
+  switch (moduleId) {
+    case SharedProcess:
+      return CliForwardToSharedProcess;
+    default:
+      throw new Error('module not found');
   }
-  handleIpc$1(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
 };
-
-const create$4 = async ({
-  argv,
-  commandMap,
-  env,
-  execArgv,
-  name,
-  path,
-  requiresSocket
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithElectronUtilityProcess$1$1.create({
-    argv,
-    env,
-    execArgv,
-    name,
-    path
-  });
-  const ipc = IpcParentWithElectronUtilityProcess$1$1.wrap(rawIpc);
-  if (requiresSocket) {
-    // @ts-ignore
-    ipc.requiresSocket = requiresSocket;
-  }
-  handleIpc$1(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+const handleArgs = (moduleId, parsedArgs) => {
+  const module = getModule$3(moduleId);
+  return module.handleCliArgs(parsedArgs);
 };
-
-const create$3 = async ({
-  commandMap,
-  requiresSocket,
-  webContents
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = IpcChildWithRendererProcess2$1.wrap(webContents);
-  if (requiresSocket) {
-    // @ts-ignore
-    ipc.requiresSocket = requiresSocket;
+const canHandleFastCliArgs = parsedArgs => {
+  const moduleId = getCliModuleId(parsedArgs);
+  return moduleId;
+};
+const handleFastCliArgs = async (moduleId, parsedArgs) => {
+  if (moduleId) {
+    await whenReady();
+    return handleArgs(moduleId, parsedArgs);
   }
-  handleIpc$1(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+  return false;
 };
 
-const commandMapRef = Object.create(null);
+const setLocale = locale => {
+  app.commandLine.appendSwitch('lang', locale);
+};
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannelMain();
-  return {
-    port1,
-    port2
-  };
+const enableSandbox = () => {
+  app.enableSandbox();
 };
 
-const getSharedProcessArgv = isProduction => {
-  return [];
+const enable$1 = parsedCliArgs => {
+  // command line switches
+  if (parsedCliArgs.sandbox) {
+    enableSandbox();
+  } else {
+    // see https://github.com/microsoft/vscode/issues/151187#issuecomment-1221475319
+    if (isLinux) {
+      // @ts-ignore
+      appendCommandLineSwitch('--disable-gpu-sandbox');
+    }
+  }
+  setLocale('en');
 };
 
-const EmbedsProcess = 2;
-const MainProcess = -5;
+const BeforeQuit = 'before-quit';
+const SecondInstance = 'second-instance';
+const WindowAllClosed = 'window-all-closed';
+const WebContentsCreated = 'web-contents-created';
 
-const mark = key => {
-  performance.mark(key);
+/* eslint-disable @typescript-eslint/no-misused-promises */
+const setMenu = menu => {
+  Menu.setApplicationMenu(menu);
 };
-const toUiEntry = performanceEntry => {
+const click = async (menuItem, browserWindow, keys) => {
+  if (!browserWindow) {
+    return;
+  }
+  await send$1('TitleBar.handleElectronMenuClick', browserWindow.id, menuItem.label);
+};
+const addClickListener = item => {
+  if (item.submenu) {
+    return {
+      ...item,
+      click,
+      submenu: item.submenu.map(addClickListener)
+    };
+  }
   return {
-    detail: performanceEntry.detail,
-    duration: performanceEntry.duration,
-    entryType: performanceEntry.entryType,
-    name: performanceEntry.name,
-    startTime: performanceEntry.startTime
+    ...item,
+    click,
+    submenu: undefined
   };
 };
-const getEntries = () => {
-  const entries = performance.getEntries();
-  const uiEntries = entries.map(toUiEntry);
-  return uiEntries;
+const setItems = items => {
+  array(items);
+  const itemsWithClickListeners = items.map(addClickListener);
+  const menu = Menu.buildFromTemplate(itemsWithClickListeners);
+  setMenu(menu);
 };
-const {
-  timeOrigin
-} = performance;
-
-const Performance = {
-	__proto__: null,
-	getEntries,
-	mark,
-	timeOrigin
-};
-
-const WillLoadUrl = 'code/willLoadUrl';
-const DidLoadUrl = 'code/didLoadUrl';
-const AppReady = 'code/appReady';
-const WillStartSharedProcess = 'code/willStartSharedProcess';
-const DidStartSharedProcess = 'code/didStartSharedProcess';
-const WillCreateCodeWindow = 'code/willCreateCodeWindow';
-const DidCreateCodeWindow = 'code/didCreateCodeWindow';
-
-const join = (...paths) => {
-  return NodePath.join(...paths);
-};
-
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-const root = process.env.LVCE_ROOT || join(__dirname$1, '../../../../..');
-
-const {
-  env,
-  platform
-} = process;
-const isLinux = platform === 'linux';
-const isProduction = false;
-const homeDirectory = homedir();
-
-const xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? join(homeDirectory, '.cache') : undefined);
-const xdgData = env.XDG_DATA_HOME || (homeDirectory ? join(homeDirectory, '.local', 'share') : undefined);
-join(xdgData || tmpdir(), applicationName);
-const chromeUserDataPath = xdgCache ? join(xdgCache, applicationName, 'userdata') : '';
-
-const useIpcForResponse = true;
-const getSessionId = () => {
-  return process.env.SESSION_ID || `persist:${scheme}`;
-};
-const getSharedProcessPath = () => {
-  if (process.env.LVCE_SHARED_PROCESS_PATH) {
-    return process.env.LVCE_SHARED_PROCESS_PATH;
-  }
-  return join(root, 'packages', 'shared-process', 'src', 'sharedProcessMain.ts');
-};
-
-const requiresSocket = () => {
-  return false;
-};
-
-const handleChildError = error => {
-  exit$1(Error$3);
-};
-const handleChildExit = code => {
-  info(`[main process] shared process exited with code ${code}`);
-  exit$1(code);
-};
-const handleChildDisconnect = () => {
-  info('[main process] shared process disconnected');
-};
-const launchSharedProcess = async ({
-  env = {},
-  method
-}) => {
-  mark(WillStartSharedProcess);
-  const sharedProcessPath = getSharedProcessPath();
-  const execArgv = getSharedProcessArgv();
-  const fullEnv = {
-    ...process.env,
-    ...env
-  };
-  const sharedProcessRpc = await create$4({
-    argv: [],
-    commandMap: commandMapRef,
-    env: fullEnv,
-    execArgv,
-    name: 'shared-process',
-    path: sharedProcessPath,
-    // @ts-ignore
-    requiresSocket: requiresSocket
-  });
-
-  // @ts-ignore
-  const sharedProcess = sharedProcessRpc.ipc;
-  // @ts-ignore
-  sharedProcess._rawIpc.on('error', handleChildError);
-  // @ts-ignore
-  sharedProcess._rawIpc.on('exit', handleChildExit);
-  // @ts-ignore
-  sharedProcess._rawIpc.on('disconnect', handleChildDisconnect);
-
-  // create secondary ipc to support transferring objects
-  // from shared process to main process
-  // TODO let shared process ask for secondary
-  // ipc instead of sending it directly?
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sharedProcessRpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port2, MainProcess);
-  await create$5({
-    commandMap: commandMapRef,
-    messagePort: port1,
-    requiresSocket: requiresSocket
-  });
-  mark(DidStartSharedProcess);
-  return sharedProcessRpc;
-};
-
-const state$5 = {
-  /**
-   * @type {any}
-   */
-  promise: undefined
-};
-
-const getOrCreate = async ({
-  env = {},
-  method
-}) => {
-  if (!state$5.promise) {
-    // @ts-ignore
-    state$5.promise = launchSharedProcess({
-      env,
-      method
-    });
-  }
-  return state$5.promise;
-};
-const send$1 = async (method, ...params) => {
-  const rpc = await getOrCreate({
-    method: ElectronUtilityProcess$1
-  });
-  rpc.send(method, ...params);
-};
-const invoke = async (method, ...params) => {
-  const rpc = await getOrCreate({
-    method: ElectronUtilityProcess$1
-  });
-  return rpc.invoke(method, ...params);
-};
-const invokeAndTransfer = async (method, ...params) => {
-  const rpc = await getOrCreate({
-    method: ElectronUtilityProcess$1
-  });
-  return rpc.invokeAndTransfer(method, ...params);
-};
-
-const handleCliArgs = async parsedArgs => {
-  try {
-    await invoke('HandleCliArgs.handleCliArgs', parsedArgs);
-  } catch (error) {
-    setExitCode(Error$3);
-    if (error && error instanceof Error && error.stack && error.stack.includes('shared-process')) ; else {
-      handleError(error);
-    }
-  } finally {
-    exit();
-  }
-};
-
-const CliForwardToSharedProcess = {
-	__proto__: null,
-	handleCliArgs
+const createTitleBar = items => {
+  const menuBar = Menu.buildFromTemplate(items);
+  return menuBar;
 };
 
-const SharedProcess = 4;
-const None = 0;
-
-const on = (event, listener) => {
-  app.on(event, listener);
-};
-const whenReady = () => {
-  return app.whenReady();
+const PHASE_DEFAULT = 0;
+const PHASE_SHUTDOWN = -1;
+const state$4 = {
+  phase: PHASE_DEFAULT
 };
-const appendCommandLineSwitch = (commandLineSwitch, value) => {
-  app.commandLine.appendSwitch(commandLineSwitch, value);
+const isShutDown = () => {
+  return state$4.phase === PHASE_SHUTDOWN;
 };
-
-const Version = 'version';
-const Help = 'help';
-const Wait = 'wait';
-const BuiltinSelfTest = 'built-in-self-test';
-const Web = 'web';
-const SandBox = 'sandbox';
-const Install = 'install';
-const List = 'list';
-const Link = 'link';
-const Unlink = 'unlink';
-const Status = 'status';
-
-const getCliModuleId = parsedArgs => {
-  const arg0 = parsedArgs._[0];
-  if (arg0 === Install || arg0 === List || arg0 === Link || arg0 === Unlink || parsedArgs[Status] || parsedArgs[Version] || parsedArgs[Help] || parsedArgs[Web] || parsedArgs[BuiltinSelfTest]) {
-    return SharedProcess;
-  }
-  return None;
+const setShutDown = () => {
+  state$4.phase = PHASE_SHUTDOWN;
 };
 
-const getModule$3 = moduleId => {
-  switch (moduleId) {
-    case SharedProcess:
-      return CliForwardToSharedProcess;
-    default:
-      throw new Error('module not found');
-  }
-};
-const handleArgs = (moduleId, parsedArgs) => {
-  const module = getModule$3(moduleId);
-  return module.handleCliArgs(parsedArgs);
-};
-const canHandleFastCliArgs = parsedArgs => {
-  const moduleId = getCliModuleId(parsedArgs);
-  return moduleId;
-};
-const handleFastCliArgs = async (moduleId, parsedArgs) => {
-  if (moduleId) {
-    await whenReady();
-    return handleArgs(moduleId, parsedArgs);
-  }
-  return false;
+// TODO move this function to shared process
+const handleBeforeQuit = () => {
+  setShutDown();
 };
 
-const setLocale = locale => {
-  app.commandLine.appendSwitch('lang', locale);
+const handleReady = async (parsedArgs, workingDirectory) => {
+  await invoke('HandleElectronReady.handleElectronReady', parsedArgs, workingDirectory);
 };
 
-const enableSandbox = () => {
-  app.enableSandbox();
-};
+var minimist$1;
+var hasRequiredMinimist;
 
-const enable$1 = parsedCliArgs => {
-  // command line switches
-  if (parsedCliArgs.sandbox) {
-    enableSandbox();
-  } else {
-    // see https://github.com/microsoft/vscode/issues/151187#issuecomment-1221475319
-    if (isLinux) {
-      // @ts-ignore
-      appendCommandLineSwitch('--disable-gpu-sandbox');
-    }
-  }
-  setLocale('en');
-};
-
-const BeforeQuit = 'before-quit';
-const SecondInstance = 'second-instance';
-const WindowAllClosed = 'window-all-closed';
-const WebContentsCreated = 'web-contents-created';
-
-/* eslint-disable @typescript-eslint/no-misused-promises */
-const setMenu = menu => {
-  Menu.setApplicationMenu(menu);
-};
-const click = async (menuItem, browserWindow, keys) => {
-  if (!browserWindow) {
-    return;
-  }
-  await send$1('TitleBar.handleElectronMenuClick', browserWindow.id, menuItem.label);
-};
-const addClickListener = item => {
-  if (item.submenu) {
-    return {
-      ...item,
-      click,
-      submenu: item.submenu.map(addClickListener)
-    };
-  }
-  return {
-    ...item,
-    click,
-    submenu: undefined
-  };
-};
-const setItems = items => {
-  array(items);
-  const itemsWithClickListeners = items.map(addClickListener);
-  const menu = Menu.buildFromTemplate(itemsWithClickListeners);
-  setMenu(menu);
-};
-const createTitleBar = items => {
-  const menuBar = Menu.buildFromTemplate(items);
-  return menuBar;
-};
-
-const PHASE_DEFAULT = 0;
-const PHASE_SHUTDOWN = -1;
-const state$4 = {
-  phase: PHASE_DEFAULT
-};
-const isShutDown = () => {
-  return state$4.phase === PHASE_SHUTDOWN;
-};
-const setShutDown = () => {
-  state$4.phase = PHASE_SHUTDOWN;
-};
-
-// TODO move this function to shared process
-const handleBeforeQuit = () => {
-  setShutDown();
-};
-
-const handleReady = async (parsedArgs, workingDirectory) => {
-  await invoke('HandleElectronReady.handleElectronReady', parsedArgs, workingDirectory);
-};
-
-var minimist$1;
-var hasRequiredMinimist;
-
-function requireMinimist () {
-	if (hasRequiredMinimist) return minimist$1;
-	hasRequiredMinimist = 1;
+function requireMinimist () {
+	if (hasRequiredMinimist) return minimist$1;
+	hasRequiredMinimist = 1;
 
 	function hasKey(obj, keys) {
 	  var o = obj;
@@ -3924,10 +3413,7 @@ const Allow = 'allow';
 const Deny = 'deny';
 
 const shouldOpenExternal = url => {
-  if (url.startsWith('http:') || url.startsWith('https:')) {
-    return true;
-  }
-  return false;
+  return url.startsWith('http:') || url.startsWith('https:');
 };
 
 const openExternal = async url => {
@@ -3976,10 +3462,7 @@ const setCanceled = id => {
 };
 
 const shouldAllowNavigation = webContentsId => {
-  if (hasWebContents(webContentsId)) {
-    return true;
-  }
-  return false;
+  return hasWebContents(webContentsId);
 };
 
 const handleWebContentsWindowOpen = ({
@@ -4019,10 +3502,7 @@ const handleWindowAllClosed = async () => {
 };
 
 const isProtocolHandleApiSupported = protocol => {
-  if (protocol.handle) {
-    return true;
-  }
-  return false;
+  return !!protocol.handle;
 };
 
 
@@ -4231,10 +3711,10 @@ const getElectronFileResponseConfig = async (url, request) => {
     return getElectronFileResponseIpc(url, request);
   }
   const actual = getActualPath(relative);
-  const match = files[actual];
-  if (match === undefined) {
+  if (!(actual in files)) {
     return getNotFoundResponse();
   }
+  const match = files[actual];
   const responseHeaders = headers[match];
   const absolutePath = getAbsolutePath(actual);
   if (!existsSync(absolutePath)) {
@@ -4308,7 +3788,7 @@ const set$1 = value => {
   state$2.session = value;
 };
 
-const create$2 = rpc => {
+const create$3 = rpc => {
   const handleRequest = async request => {
     const {
       method,
@@ -4331,13 +3811,13 @@ const get$1 = () => {
 };
 const registerWebviewProtocol = async port => {
   object(port);
-  const rpc = await create$5({
+  const rpc = await create$8({
     commandMap: {},
     messagePort: port,
     requiresSocket: requiresSocket
   });
   const session = get$1();
-  const handleRequest = create$2(rpc);
+  const handleRequest = create$3(rpc);
   handle(session.protocol, WebView, handleRequest);
 };
 
@@ -4400,7 +3880,7 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
     }
   };
   window.on('close', handleWindowClose);
-  await create$3({
+  await create$4({
     commandMap: commandMapRef,
     webContents: window.webContents
   });
@@ -4540,7 +4020,6 @@ const getByName = name => {
 
 const createPidMap = () => {
   const browserWindows = BrowserWindow.getAllWindows();
-  const browserViews = [];
   const utilityProcesses = getAll();
   const pidWindowMap = Object.create(null);
   for (const browserWindow of browserWindows) {
@@ -4564,17 +4043,6 @@ const createPidMap = () => {
       pidWindowMap[pid] = displayName;
     }
   }
-  for (const {
-    view
-  } of browserViews) {
-    // @ts-ignore
-    const viewWebContents = view.webContents;
-    const pid = viewWebContents.getOSProcessId();
-    if (pid in pidWindowMap) {
-      continue;
-    }
-    pidWindowMap[pid] = `hidden-browser-view-${viewWebContents.id}`;
-  }
   for (const [pid, value] of utilityProcesses) {
     // @ts-ignore
     pidWindowMap[pid] = value.name;
@@ -4591,7 +4059,7 @@ const get = id => {
 };
 
 const createUtilityProcessRpc = async options => {
-  const rpc = await create$4({
+  const rpc = await create$5({
     commandMap: commandMapRef,
     ...options
   });
@@ -4758,18 +4226,87 @@ const getWindowById = windowId => {
   return Electron.BrowserWindow.fromId(windowId);
 };
 
-const executeWindowFunction = (browserWindowId, key) => {
+const devtoolsBeforeInputListeners = new WeakMap();
+const isToggleDevtoolsInput = input => {
+  if (input.type !== 'keyDown') {
+    return false;
+  }
+  if (!input.shift) {
+    return false;
+  }
+  if (!input.control && !input.meta) {
+    return false;
+  }
+  return input.code === 'KeyI' || input.key === 'I' || input.key === 'i';
+};
+const removeDevtoolsKeyListener = devtoolsWebContents => {
+  const listener = devtoolsBeforeInputListeners.get(devtoolsWebContents);
+  if (!listener) {
+    return;
+  }
+  devtoolsBeforeInputListeners.delete(devtoolsWebContents);
+  devtoolsWebContents.off('before-input-event', listener);
+};
+const attachDevtoolsKeyListener = browserWindow => {
+  const devtoolsWebContents = browserWindow.webContents.devToolsWebContents;
+  if (!devtoolsWebContents) {
+    return;
+  }
+  if (devtoolsBeforeInputListeners.has(devtoolsWebContents)) {
+    return;
+  }
+  const listener = (event, input) => {
+    if (!isToggleDevtoolsInput(input)) {
+      return;
+    }
+    event.preventDefault();
+    browserWindow.webContents.closeDevTools();
+  };
+  devtoolsBeforeInputListeners.set(devtoolsWebContents, listener);
+  devtoolsWebContents.on('before-input-event', listener);
+  devtoolsWebContents.once('destroyed', () => {
+    removeDevtoolsKeyListener(devtoolsWebContents);
+  });
+  browserWindow.webContents.once('devtools-closed', () => {
+    removeDevtoolsKeyListener(devtoolsWebContents);
+  });
+};
+const getBrowserWindow = browserWindowId => {
   const browserWindow = getWindowById(browserWindowId);
   if (!browserWindow) {
     info(`[main-process] browser window not found ${browserWindow}`);
+    return undefined;
+  }
+  return browserWindow;
+};
+const toggleDevtools = browserWindow => {
+  if (browserWindow.webContents.isDevToolsOpened()) {
+    browserWindow.webContents.closeDevTools();
+    return;
+  }
+  if (browserWindow.webContents.devToolsWebContents) {
+    attachDevtoolsKeyListener(browserWindow);
+  } else {
+    browserWindow.webContents.once('devtools-opened', () => {
+      attachDevtoolsKeyListener(browserWindow);
+    });
+  }
+  browserWindow.webContents.openDevTools();
+};
+const executeWindowFunction = (browserWindowId, key) => {
+  const browserWindow = getBrowserWindow(browserWindowId);
+  if (!browserWindow) {
+    return;
+  }
+  if (key === 'toggleDevtools') {
+    toggleDevtools(browserWindow);
     return;
   }
   browserWindow[key]();
 };
 const executeWebContentsFunction = (browserWindowId, key, ...args) => {
-  const browserWindow = getWindowById(browserWindowId);
+  const browserWindow = getBrowserWindow(browserWindowId);
   if (!browserWindow) {
-    info(`[main-process] browser window not found ${browserWindow}`);
     return;
   }
   browserWindow.webContents[key](...args);
@@ -5206,187 +4743,98 @@ const Quote = 93;
 const Star = 131;
 const Plus = 132;
 
+const keyCodeMap = {
+  [Backquote$1]: Backquote,
+  [Backslash$1]: Backslash,
+  [Backspace$1]: Backspace,
+  [BracketLeft$1]: BracketLeft,
+  [BracketRight$1]: BracketRight,
+  [Comma$1]: Comma,
+  [Delete$1]: Delete,
+  [Digit0$1]: Digit0,
+  [Digit1$1]: Digit1,
+  [Digit2$1]: Digit2,
+  [Digit3$1]: Digit3,
+  [Digit4$1]: Digit4,
+  [Digit5$1]: Digit5,
+  [Digit6$1]: Digit6,
+  [Digit7$1]: Digit7,
+  [Digit8$1]: Digit8,
+  [Digit9$1]: Digit9,
+  [DownArrow$1]: DownArrow,
+  [End$1]: End,
+  [Enter$1]: Enter,
+  [Equal$1]: Equal,
+  [Escape$1]: Escape,
+  [F1$1]: F1,
+  [F10$1]: F10,
+  [F11$1]: F11,
+  [F12$1]: F12,
+  [F13$1]: F13,
+  [F14$1]: F14,
+  [F15$1]: F15,
+  [F16$1]: F16,
+  [F17$1]: F17,
+  [F18$1]: F18,
+  [F19$1]: F19,
+  [F2$1]: F2,
+  [F20$1]: F20,
+  [F21$1]: F21,
+  [F22$1]: F22,
+  [F23$1]: F23,
+  [F24$1]: F24,
+  [F3$1]: F3,
+  [F4$1]: F4,
+  [F5$1]: F5,
+  [F6$1]: F6,
+  [F7$1]: F7,
+  [F8$1]: F8,
+  [F9$1]: F9,
+  [Home$1]: Home,
+  [Insert$1]: Insert,
+  [KeyA$1]: KeyA,
+  [KeyB$1]: KeyB,
+  [KeyC$1]: KeyC,
+  [KeyD$1]: KeyD,
+  [KeyE$1]: KeyE,
+  [KeyF$1]: KeyF,
+  [KeyG$1]: KeyG,
+  [KeyH$1]: KeyH,
+  [KeyI$1]: KeyI,
+  [KeyJ$1]: KeyJ,
+  [KeyK$1]: KeyK,
+  [KeyL$1]: KeyL,
+  [KeyM$1]: KeyM,
+  [KeyN$1]: KeyN,
+  [KeyO$1]: KeyO,
+  [KeyP$1]: KeyP,
+  [KeyQ$1]: KeyQ,
+  [KeyR$1]: KeyR,
+  [KeyS$1]: KeyS,
+  [KeyT$1]: KeyT,
+  [KeyU$1]: KeyU,
+  [KeyV$1]: KeyV,
+  [KeyW$1]: KeyW,
+  [KeyX$1]: KeyX,
+  [KeyY$1]: KeyY,
+  [KeyZ$1]: KeyZ,
+  [LeftArrow$1]: LeftArrow,
+  [Minus$1]: Minus,
+  [PageDown$1]: PageDown,
+  [PageUp$1]: PageUp,
+  [Period$1]: Period,
+  [Plus$1]: Plus,
+  [Quote$1]: Quote,
+  [RightArrow$1]: RightArrow,
+  [SemiColon$1]: SemiColon,
+  [Slash$1]: Slash,
+  [Space$2]: Space$1,
+  [Star$1]: Star,
+  [Tab$1]: Tab,
+  [UpArrow$1]: UpArrow
+};
 const getKeyCode = key => {
-  switch (key) {
-    case Backquote$1:
-      return Backquote;
-    case Backslash$1:
-      return Backslash;
-    case Backspace$1:
-      return Backspace;
-    case BracketLeft$1:
-      return BracketLeft;
-    case BracketRight$1:
-      return BracketRight;
-    case Comma$1:
-      return Comma;
-    case Delete$1:
-      return Delete;
-    case Digit0$1:
-      return Digit0;
-    case Digit1$1:
-      return Digit1;
-    case Digit2$1:
-      return Digit2;
-    case Digit3$1:
-      return Digit3;
-    case Digit4$1:
-      return Digit4;
-    case Digit5$1:
-      return Digit5;
-    case Digit6$1:
-      return Digit6;
-    case Digit7$1:
-      return Digit7;
-    case Digit8$1:
-      return Digit8;
-    case Digit9$1:
-      return Digit9;
-    case DownArrow$1:
-      return DownArrow;
-    case End$1:
-      return End;
-    case Enter$1:
-      return Enter;
-    case Equal$1:
-      return Equal;
-    case Escape$1:
-      return Escape;
-    case F1$1:
-      return F1;
-    case F10$1:
-      return F10;
-    case F11$1:
-      return F11;
-    case F12$1:
-      return F12;
-    case F13$1:
-      return F13;
-    case F14$1:
-      return F14;
-    case F15$1:
-      return F15;
-    case F16$1:
-      return F16;
-    case F17$1:
-      return F17;
-    case F18$1:
-      return F18;
-    case F19$1:
-      return F19;
-    case F2$1:
-      return F2;
-    case F20$1:
-      return F20;
-    case F21$1:
-      return F21;
-    case F22$1:
-      return F22;
-    case F23$1:
-      return F23;
-    case F24$1:
-      return F24;
-    case F3$1:
-      return F3;
-    case F4$1:
-      return F4;
-    case F5$1:
-      return F5;
-    case F6$1:
-      return F6;
-    case F7$1:
-      return F7;
-    case F8$1:
-      return F8;
-    case F9$1:
-      return F9;
-    case Home$1:
-      return Home;
-    case Insert$1:
-      return Insert;
-    case KeyA$1:
-      return KeyA;
-    case KeyB$1:
-      return KeyB;
-    case KeyC$1:
-      return KeyC;
-    case KeyD$1:
-      return KeyD;
-    case KeyE$1:
-      return KeyE;
-    case KeyF$1:
-      return KeyF;
-    case KeyG$1:
-      return KeyG;
-    case KeyH$1:
-      return KeyH;
-    case KeyI$1:
-      return KeyI;
-    case KeyJ$1:
-      return KeyJ;
-    case KeyK$1:
-      return KeyK;
-    case KeyL$1:
-      return KeyL;
-    case KeyM$1:
-      return KeyM;
-    case KeyN$1:
-      return KeyN;
-    case KeyO$1:
-      return KeyO;
-    case KeyP$1:
-      return KeyP;
-    case KeyQ$1:
-      return KeyQ;
-    case KeyR$1:
-      return KeyR;
-    case KeyS$1:
-      return KeyS;
-    case KeyT$1:
-      return KeyT;
-    case KeyU$1:
-      return KeyU;
-    case KeyV$1:
-      return KeyV;
-    case KeyW$1:
-      return KeyW;
-    case KeyX$1:
-      return KeyX;
-    case KeyY$1:
-      return KeyY;
-    case KeyZ$1:
-      return KeyZ;
-    case LeftArrow$1:
-      return LeftArrow;
-    case Minus$1:
-      return Minus;
-    case PageDown$1:
-      return PageDown;
-    case PageUp$1:
-      return PageUp;
-    case Period$1:
-      return Period;
-    case Plus$1:
-      return Plus;
-    case Quote$1:
-      return Quote;
-    case RightArrow$1:
-      return RightArrow;
-    case SemiColon$1:
-      return SemiColon;
-    case Slash$1:
-      return Slash;
-    case Space$2:
-      return Space$1;
-    case Star$1:
-      return Star;
-    case Tab$1:
-      return Tab;
-    case UpArrow$1:
-      return UpArrow;
-    default:
-      return Unknown;
-  }
+  return keyCodeMap[key] ?? Unknown;
 };
 
 const CtrlCmd = 1 << 11 >>> 0;
@@ -5903,14 +5351,16 @@ const getSlimCode = html => {
   result = result.replaceAll(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style\s*>/gi, '');
   return result;
 };
-const getDomTree = async view => {
+const getBodyOuterHtml = async view => {
   const {
     webContents
   } = view;
   const code = `document.body.outerHTML`;
-  const result = await webContents.executeJavaScript(code);
-  const slimCode = getSlimCode(result);
-  return slimCode;
+  return webContents.executeJavaScript(code);
+};
+const getDomTree = async view => {
+  const result = await getBodyOuterHtml(view);
+  return getSlimCode(result);
 };
 const insertCss = async (view, code) => {
   const {
@@ -5955,138 +5405,1123 @@ const cancelNavigation = view => {
     webContents.navigationHistory.goBack();
   }
 };
-const show = id => {
-  // console.log('[main-process] show browser view', id)
-  const state = get$3(id);
-  if (!state) {
-    return;
+const show = id => {
+  // console.log('[main-process] show browser view', id)
+  const state = get$3(id);
+  if (!state) {
+    return;
+  }
+  const {
+    browserWindow,
+    view
+  } = state;
+  browserWindow.contentView.addChildView(view);
+};
+const addToWindow = (browserWindowId, browserViewId) => {
+  const state = get$3(browserViewId);
+  const {
+    view
+  } = state;
+  const browserWindow = BrowserWindow.fromId(browserWindowId);
+  if (!browserWindow) {
+    return;
+  }
+  browserWindow.contentView.addChildView(view);
+};
+const hide = id => {
+  const state = get$3(id);
+  if (!state) {
+    return;
+  }
+  const {
+    browserWindow,
+    view
+  } = state;
+  browserWindow.contentView.removeChildView(view);
+};
+
+/**
+ *
+ * @param {Electron.BrowserView} view
+ * @param {number} x
+ * @param {number} y
+ */
+const inspectElement = (view, x, y) => {
+  number(x);
+  number(y);
+  const {
+    webContents
+  } = view;
+  webContents.inspectElement(x, y);
+};
+
+/**
+ *
+ * @param {Electron.BrowserView} view
+ * @param {string} backgroundColor
+ */
+const setBackgroundColor = (view, backgroundColor) => {
+  view.setBackgroundColor(backgroundColor);
+};
+
+/**
+ *
+ * @param {Electron.BrowserView} view
+ * @param {number} x
+ * @param {number} y
+ */
+const copyImageAt = (view, x, y) => {
+  number(x);
+  number(y);
+  const {
+    webContents
+  } = view;
+  webContents.copyImageAt(x, y);
+};
+const setFallThroughKeyBindings = fallthroughKeyBindings => {
+  setFallthroughKeyBindings(fallthroughKeyBindings);
+};
+
+// TODO maybe move some of these to webContentFunctions
+
+/**
+ * @param {Electron.BrowserView} view
+ */
+const getStats = view => {
+  const {
+    webContents
+  } = view;
+  const canGoBack = webContents.navigationHistory.canGoBack();
+  const canGoForward = webContents.navigationHistory.canGoForward();
+  const url = webContents.getURL();
+  const title = webContents.getTitle();
+  return {
+    canGoBack,
+    canGoForward,
+    title,
+    url
+  };
+};
+
+const printPrettyError = (prettyError, prefix = '') => {
+  error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
+};
+
+const execute = (method, ...params) => {
+  const fn = commandMapRef[method];
+  if (!fn) {
+    throw new Error(`command not found: ${method}`);
+  }
+  return fn(...params);
+};
+const logError = (error, prettyError) => {
+  printPrettyError(prettyError, '[main-process] ');
+};
+const handleMessage = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, prepare,
+  // @ts-ignore
+  logError, requiresSocket);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const unhandleIpc = ipc => {
+  if ('removeEventListener' in ipc) {
+    ipc.removeEventListener('message', handleMessage);
+  } else if ('off' in ipc) {
+    ipc.off('message', handleMessage);
+  }
+};
+
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const removeValues = (value, toRemove) => {
+  if (!value) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      if (!toRemove.includes(item)) {
+        newItems.push(removeValues(item, toRemove));
+      }
+    }
+    return newItems;
+  }
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      if (!toRemove.includes(property)) {
+        newObject[key] = removeValues(property, toRemove);
+      }
+    }
+    return newObject;
+  }
+  return value;
+};
+
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
+  return {
+    newValue,
+    transfer
+  };
+};
+const getActualDataElectron = event => {
+  const {
+    data,
+    ports
+  } = event;
+  if (ports.length === 0) {
+    return data;
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params]
+  };
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine = '\n';
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    code: ERR_MODULE_NOT_FOUND,
+    message
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    code: '',
+    message: actualMessage,
+    stack: rest
+  };
+};
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        code,
+        message,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+}
+const listen$b = ({
+  messagePort
+}) => {
+  if (!isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain');
+  }
+  return messagePort;
+};
+const signal$c = messagePort => {
+  messagePort.start();
+};
+class IpcChildWithElectronMessagePort extends Ipc {
+  getData = getActualDataElectron;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+}
+const wrap$j = messagePort => {
+  return new IpcChildWithElectronMessagePort(messagePort);
+};
+const IpcChildWithElectronMessagePort$1 = {
+  __proto__: null,
+  listen: listen$b,
+  signal: signal$c,
+  wrap: wrap$j
+};
+
+// @ts-ignore
+const getUtilityProcessPortData = event => {
+  const {
+    data,
+    ports
+  } = event;
+  if (ports.length === 0) {
+    return data;
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params]
+  };
+};
+const readyMessage = 'ready';
+const listen$a = () => {
+  // @ts-ignore
+  const {
+    parentPort
+  } = process;
+  if (!parentPort) {
+    throw new IpcError('parent port must be defined');
+  }
+  return parentPort;
+};
+const signal$b = parentPort => {
+  parentPort.postMessage(readyMessage);
+};
+class IpcChildWithElectronUtilityProcess extends Ipc {
+  getData(event) {
+    return getUtilityProcessPortData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+}
+const wrap$i = parentPort => {
+  return new IpcChildWithElectronUtilityProcess(parentPort);
+};
+const IpcChildWithElectronUtilityProcess$1 = {
+  __proto__: null,
+  listen: listen$a,
+  signal: signal$b,
+  wrap: wrap$i
+};
+const getActualData = (message, handle) => {
+  if (handle) {
+    return {
+      ...message,
+      params: [handle, ...message.params]
+    };
+  }
+  return message;
+};
+const getTransferrablesNode = value => {
+  const transferrables = getTransferrables(value);
+  if (transferrables.length === 0) {
+    throw new Error(`no transferrables found`);
+  }
+  return transferrables[0];
+};
+const listen$5 = async () => {
+  if (!process.send) {
+    throw new IpcError('process.send must be defined');
+  }
+  return process;
+};
+const signal$7 = process => {
+  process.send(readyMessage);
+};
+class IpcChildWithNodeForkedProcess extends Ipc {
+  getData(message, handle) {
+    return getActualData(message, handle);
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+  send(message) {
+    this._rawIpc.send(message);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrablesNode(message);
+    this._rawIpc.send(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+}
+const wrap$d = process => {
+  return new IpcChildWithNodeForkedProcess(process);
+};
+const IpcChildWithNodeForkedProcess$1 = {
+  __proto__: null,
+  listen: listen$5,
+  signal: signal$7,
+  wrap: wrap$d
+};
+const listen$3 = async () => {
+  const {
+    parentPort
+  } = await import('node:worker_threads');
+  if (!parentPort) {
+    throw new IpcError('parentPort is required for node worker threads ipc');
+  }
+  return parentPort;
+};
+const signal$5 = parentPort => {
+  parentPort.postMessage(readyMessage);
+};
+class IpcChildWithNodeWorker extends Ipc {
+  getData(data) {
+    return data;
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrablesNode(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+}
+const wrap$b = parentPort => {
+  return new IpcChildWithNodeWorker(parentPort);
+};
+const IpcChildWithNodeWorker$1 = {
+  __proto__: null,
+  listen: listen$3,
+  signal: signal$5,
+  wrap: wrap$b
+};
+const preloadChannelType = 'port';
+const listen$2 = ({
+  webContents
+}) => {
+  return webContents;
+};
+const getData$1 = (event, message) => {
+  const {
+    ports,
+    sender
+  } = event;
+  const data = {
+    ...message,
+    params: [...message.params, ...ports, sender.id]
+  };
+  return data;
+};
+class IpcChildWithRendererProcess2 extends Ipc {
+  getData(event, message) {
+    return getData$1(event, message);
+  }
+  send(message) {
+    this._rawIpc.postMessage(preloadChannelType, message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(preloadChannelType, message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.ipc.on(preloadChannelType, callback);
+  }
+  onClose(callback) {
+    this._rawIpc.on('destroyed', callback);
+  }
+}
+const wrap$a = webContents => {
+  return new IpcChildWithRendererProcess2(webContents);
+};
+const IpcChildWithRendererProcess2$1 = {
+  __proto__: null,
+  listen: listen$2,
+  wrap: wrap$a
+};
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const create$7 = ({
+  messagePort
+}) => {
+  if (!isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain');
+  }
+  return messagePort;
+};
+const signal$2 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithElectronMessagePort extends Ipc {
+  getData = getActualDataElectron;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+}
+const wrap$7 = messagePort => {
+  return new IpcParentWithElectronMessagePort(messagePort);
+};
+const IpcParentWithElectronMessagePort$1 = {
+  __proto__: null,
+  create: create$7,
+  signal: signal$2,
+  wrap: wrap$7
+};
+const Exit = 1;
+const Error$2 = 2;
+const Message$1 = 3;
+const getFirstUtilityProcessEvent = async utilityProcess => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  let stdout = '';
+  let stderr = '';
+  const cleanup = value => {
+    // @ts-ignore
+    utilityProcess.stderr.off('data', handleStdErrData);
+    // @ts-ignore
+    utilityProcess.stdout.off('data', handleStdoutData);
+    utilityProcess.off('message', handleMessage);
+    utilityProcess.off('exit', handleExit);
+    resolve(value);
+  };
+  const handleStdErrData = data => {
+    stderr += data;
+  };
+  const handleStdoutData = data => {
+    stdout += data;
+  };
+  const handleMessage = event => {
+    cleanup({
+      event,
+      stderr,
+      stdout,
+      type: Message$1
+    });
+  };
+  const handleExit = event => {
+    cleanup({
+      event,
+      stderr,
+      stdout,
+      type: Exit
+    });
+  };
+  // @ts-ignore
+  utilityProcess.stderr.on('data', handleStdErrData);
+  // @ts-ignore
+  utilityProcess.stdout.on('data', handleStdoutData);
+  utilityProcess.on('message', handleMessage);
+  utilityProcess.on('exit', handleExit);
+  const {
+    event,
+    type
+  } = await promise;
+  return {
+    event,
+    stderr,
+    stdout,
+    type
+  };
+};
+const create$6 = async ({
+  argv = [],
+  env = process.env,
+  execArgv = [],
+  name,
+  path
+}) => {
+  string(path);
+  const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
+  const {
+    utilityProcess
+  } = await import('electron');
+  const childProcess = utilityProcess.fork(path, actualArgv, {
+    env,
+    execArgv,
+    serviceName: name,
+    stdio: 'pipe'
+  });
+  const handleExit = () => {
+    // @ts-ignore
+    childProcess.stdout.unpipe(process.stdout);
+    // @ts-ignore
+    childProcess.stderr.unpipe(process.stderr);
+  };
+  childProcess.once('exit', handleExit);
+  // @ts-ignore
+  childProcess.stdout.pipe(process.stdout);
+  const {
+    stderr,
+    stdout,
+    type
+  } = await getFirstUtilityProcessEvent(childProcess);
+  if (type === Exit) {
+    throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
+  }
+  // @ts-ignore
+  childProcess.stderr.pipe(process.stderr);
+  return childProcess;
+};
+let IpcParentWithElectronUtilityProcess$1 = class IpcParentWithElectronUtilityProcess extends Ipc {
+  getData(data) {
+    return data;
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.kill();
+  }
+  onClose(callback) {
+    this._rawIpc.on('exit', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+};
+const wrap$6 = process => {
+  return new IpcParentWithElectronUtilityProcess$1(process);
+};
+const IpcParentWithElectronUtilityProcess$1$1 = {
+  __proto__: null,
+  create: create$6,
+  wrap: wrap$6
+};
+class ChildProcessError extends Error {
+  // @ts-ignore
+  constructor(stderr) {
+    // @ts-ignore
+    const {
+      code,
+      message,
+      stack
+    } = getHelpfulChildProcessError('', stderr);
+    super(message || 'child process error');
+    this.name = 'ChildProcessError';
+    if (code) {
+      // @ts-ignore
+      this.code = code;
+    }
+    if (stack) {
+      // @ts-ignore
+      const lines = splitLines(this.stack);
+      const [firstLine, ...stackLines] = lines;
+      const newStackLines = [firstLine, ...stack, ...stackLines];
+      const newStack = joinLines(newStackLines);
+      this.stack = newStack;
+    }
+  }
+}
+
+// workaround for node not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter,
+// it is received as a plain object is received in the receiving process
+const fixNodeChildProcessParameters = value => {
+  const transfer = getTransferrables(value);
+  if (transfer.length === 0) {
+    throw new IpcError('no transferrables found');
+  }
+  const newValue = removeValues(value, transfer);
+  return {
+    newValue,
+    transfer: transfer[0]
+  };
+};
+const getFirstNodeChildProcessEvent = async childProcess => {
+  const {
+    event,
+    stderr,
+    stdout,
+    type
+  } = await new Promise((resolve, reject) => {
+    let stderr = '';
+    let stdout = '';
+    const cleanup = value => {
+      if (childProcess.stdout && childProcess.stderr) {
+        childProcess.stderr.off('data', handleStdErrData);
+        childProcess.stdout.off('data', handleStdoutData);
+      }
+      childProcess.off('message', handleMessage);
+      childProcess.off('exit', handleExit);
+      childProcess.off('error', handleError);
+      resolve(value);
+    };
+    const handleStdErrData = data => {
+      stderr += data;
+    };
+    const handleStdoutData = data => {
+      stdout += data;
+    };
+    const handleMessage = event => {
+      cleanup({
+        event,
+        stderr,
+        stdout,
+        type: Message$1
+      });
+    };
+    const handleExit = event => {
+      cleanup({
+        event,
+        stderr,
+        stdout,
+        type: Exit
+      });
+    };
+    const handleError = event => {
+      cleanup({
+        event,
+        stderr,
+        stdout,
+        type: Error$2
+      });
+    };
+    if (childProcess.stdout && childProcess.stderr) {
+      childProcess.stderr.on('data', handleStdErrData);
+      childProcess.stdout.on('data', handleStdoutData);
+    }
+    childProcess.on('message', handleMessage);
+    childProcess.on('exit', handleExit);
+    childProcess.on('error', handleError);
+  });
+  return {
+    event,
+    stderr,
+    stdout,
+    type
+  };
+};
+
+// @ts-ignore
+const create$2 = async ({
+  argv = [],
+  env,
+  execArgv = [],
+  name = 'child process',
+  path,
+  stdio = 'inherit'
+}) => {
+  try {
+    string(path);
+    const actualArgv = ['--ipc-type=node-forked-process', ...argv];
+    const {
+      fork
+    } = await import('node:child_process');
+    const childProcess = fork(path, actualArgv, {
+      env,
+      execArgv,
+      stdio: 'pipe'
+    });
+    const {
+      event,
+      stderr,
+      type
+    } = await getFirstNodeChildProcessEvent(childProcess);
+    if (type === Exit) {
+      throw new ChildProcessError(stderr);
+    }
+    if (type === Error$2) {
+      throw new IpcError(`child process had an error ${event}`);
+    }
+    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
+      childProcess.stdout.pipe(process.stdout);
+      childProcess.stderr.pipe(process.stderr);
+    }
+    return childProcess;
+  } catch (error) {
+    throw new VError(error, `Failed to launch ${name}`);
+  }
+};
+class IpcParentWithNodeForkedProcess extends Ipc {
+  constructor(childProcess) {
+    super(childProcess);
+    this.pid = childProcess.pid;
   }
-  const {
-    browserWindow,
-    view
-  } = state;
-  browserWindow.contentView.addChildView(view);
-};
-const addToWindow = (browserWindowId, browserViewId) => {
-  const state = get$3(browserViewId);
-  const {
-    view
-  } = state;
-  const browserWindow = BrowserWindow.fromId(browserWindowId);
-  if (!browserWindow) {
-    return;
+  getData(message) {
+    return message;
   }
-  browserWindow.contentView.addChildView(view);
-};
-const hide = id => {
-  const state = get$3(id);
-  if (!state) {
-    return;
+  send(message) {
+    this._rawIpc.send(message);
   }
-  const {
-    browserWindow,
-    view
-  } = state;
-  browserWindow.contentView.removeChildView(view);
-};
-
-/**
- *
- * @param {Electron.BrowserView} view
- * @param {number} x
- * @param {number} y
- */
-const inspectElement = (view, x, y) => {
-  number(x);
-  number(y);
-  const {
-    webContents
-  } = view;
-  webContents.inspectElement(x, y);
-};
-
-/**
- *
- * @param {Electron.BrowserView} view
- * @param {string} backgroundColor
- */
-const setBackgroundColor = (view, backgroundColor) => {
-  view.setBackgroundColor(backgroundColor);
-};
-
-/**
- *
- * @param {Electron.BrowserView} view
- * @param {number} x
- * @param {number} y
- */
-const copyImageAt = (view, x, y) => {
-  number(x);
-  number(y);
-  const {
-    webContents
-  } = view;
-  webContents.copyImageAt(x, y);
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixNodeChildProcessParameters(message);
+    this._rawIpc.send(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.kill();
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+}
+const wrap$2 = childProcess => {
+  return new IpcParentWithNodeForkedProcess(childProcess);
 };
-const setFallThroughKeyBindings = fallthroughKeyBindings => {
-  setFallthroughKeyBindings(fallthroughKeyBindings);
+const IpcParentWithNodeForkedProcess$1 = {
+  __proto__: null,
+  create: create$2,
+  wrap: wrap$2
 };
-
-// TODO maybe move some of these to webContentFunctions
-
-/**
- * @param {Electron.BrowserView} view
- */
-const getStats = view => {
-  const {
-    webContents
-  } = view;
-  const canGoBack = webContents.navigationHistory.canGoBack();
-  const canGoForward = webContents.navigationHistory.canGoForward();
-  const url = webContents.getURL();
-  const title = webContents.getTitle();
+const fixNodeWorkerParameters = value => {
+  const transfer = getTransferrables(value);
+  if (transfer.length === 0) {
+    throw new IpcError('no transferrables found');
+  }
   return {
-    canGoBack,
-    canGoForward,
-    title,
-    url
+    newValue: value,
+    transfer: transfer
   };
 };
-
-const printPrettyError = (prettyError, prefix = '') => {
-  error(`${prefix}${prettyError.type}: ${prettyError.message}\n\n${prettyError.codeFrame}\n\n${prettyError.stack}\n`);
+const getFirstNodeWorkerEvent = worker => {
+  return getFirstEvent(worker, {
+    error: Error$2,
+    exit: Exit,
+    message: Message$1
+  });
 };
-
-const execute = (method, ...params) => {
-  const fn = commandMapRef[method];
-  if (!fn) {
-    throw new Error(`command not found: ${method}`);
+const create$1$1 = async ({
+  argv = [],
+  env = process.env,
+  execArgv = [],
+  name,
+  path,
+  stdio
+}) => {
+  string(path);
+  const actualArgv = ['--ipc-type=node-worker', ...argv];
+  const actualEnv = {
+    ...env,
+    ELECTRON_RUN_AS_NODE: '1'
+  };
+  const ignoreStdio = stdio === 'inherit' ? undefined : true;
+  const {
+    Worker
+  } = await import('node:worker_threads');
+  const worker = new Worker(path, {
+    argv: actualArgv,
+    env: actualEnv,
+    execArgv,
+    name,
+    stderr: ignoreStdio,
+    stdout: ignoreStdio
+  });
+  const {
+    event,
+    type
+  } = await getFirstNodeWorkerEvent(worker);
+  if (type === Exit) {
+    throw new IpcError(`Worker exited before ipc connection was established`);
   }
-  return fn(...params);
-};
-const logError = (error, prettyError) => {
-  printPrettyError(prettyError, '[main-process] ');
-};
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, prepare,
-  // @ts-ignore
-  logError, requiresSocket);
-};
-
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
+  if (type === Error$2) {
+    throw new IpcError(`Worker threw an error before ipc connection was established: ${event}`);
+  }
+  if (event !== readyMessage) {
+    throw new IpcError('unexpected first message from worker');
   }
+  return worker;
 };
-const unhandleIpc = ipc => {
-  if ('removeEventListener' in ipc) {
-    ipc.removeEventListener('message', handleMessage);
-  } else if ('off' in ipc) {
-    ipc.off('message', handleMessage);
+class IpcParentWithNodeWorker extends Ipc {
+  getData(message) {
+    return message;
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixNodeWorkerParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  async dispose() {
+    await this._rawIpc.terminate();
+  }
+  onClose(callback) {
+    this._rawIpc.on('exit', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
   }
+}
+const wrap$1 = worker => {
+  return new IpcParentWithNodeWorker(worker);
+};
+const IpcParentWithNodeWorker$1 = {
+  __proto__: null,
+  create: create$1$1,
+  wrap: wrap$1
 };
 
 const getModule$1 = method => {
@@ -6179,7 +6614,7 @@ const getWindowId = webContentsId => {
 
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const rpc = await create$5({
+  const rpc = await create$8({
     commandMap: commandMapRef,
     messagePort: messagePort,
     requiresSocket: requiresSocket