@lvce-editor/main-process 6.8.2 → 6.10.0

package/dist/mainProcessMain.js

@@ -1343,12 +1343,12 @@ function requireLib () {
 
 var libExports = requireLib();
 
-const NewLine$4 = '\n';
-const splitLines$3 = lines => {
-  return lines.split(NewLine$4);
+const NewLine$3 = '\n';
+const splitLines$2 = lines => {
+  return lines.split(NewLine$3);
 };
-const RE_AT$2 = /^\s+at/;
-const RE_AT_PROMISE_INDEX$2 = /^\s*at async Promise.all \(index \d+\)$/;
+const RE_AT$1 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$1 = /^\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$2.test(line) || line.includes('node_modules/ws');
+  return line.includes('node:') || RE_AT_PROMISE_INDEX$1.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$2 = line => {
-  return RE_AT$2.test(line) && !RE_AT_PROMISE_INDEX$2.test(line);
+const isNormalStackLine$1 = line => {
+  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
 };
 const cleanLine = line => {
   if (line.startsWith('    at exports.')) {
@@ -1408,8 +1408,8 @@ const cleanLine = line => {
   }
   return line;
 };
-const getDetails$2 = lines => {
-  const index = lines.findIndex(isNormalStackLine$2);
+const getDetails$1 = lines => {
+  const index = lines.findIndex(isNormalStackLine$1);
   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$3(stack);
+  const lines = splitLines$2(stack);
   const {
     custom,
     actualStack
-  } = getDetails$2(lines);
+  } = getDetails$1(lines);
   const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine);
   const merged = mergeCustom(custom, relevantStack);
   return merged;
 };
 const Utf8 = 'utf8';
-const ERR_MODULE_NOT_FOUND$2 = 'ERR_MODULE_NOT_FOUND';
+const ERR_MODULE_NOT_FOUND$1 = 'ERR_MODULE_NOT_FOUND';
 const getActualPath$1 = fileUri => {
   if (fileUri.startsWith('file://')) {
     return fileURLToPath(fileUri);
   }
   return fileUri;
 };
-const joinLines$3 = lines => {
-  return lines.join(NewLine$4);
+const joinLines$2 = lines => {
+  return lines.join(NewLine$3);
 };
 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$3(rawLines);
+  const splittedLines = splitLines$2(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$3(error.stack);
+  const stackLines = splitLines$2(error.stack);
   const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)];
-  const newStack = joinLines$3(newStackLines);
+  const newStack = joinLines$2(newStackLines);
   return {
     message,
     stack: newStack,
@@ -1496,7 +1496,7 @@ const prepareModuleNotFoundError = error => {
 };
 const prepare = error => {
   try {
-    if (error && error.code === ERR_MODULE_NOT_FOUND$2) {
+    if (error && error.code === ERR_MODULE_NOT_FOUND$1) {
       return prepareModuleNotFoundError(error);
     }
     const {
@@ -1531,7 +1531,7 @@ const prepare = error => {
         codeFrame = libExports.codeFrameColumns(rawLines, location);
       }
     }
-    const relevantStack = joinLines$3(lines);
+    const relevantStack = joinLines$2(lines);
     return {
       message,
       stack: relevantStack,
@@ -1638,6 +1638,14 @@ const getPid = () => {
 const getArgv = () => {
   return process.argv;
 };
+const writeStdout = value => {
+  string(value);
+  process.stdout.write(value);
+};
+const writeStderr = value => {
+  string(value);
+  process.stderr.write(value);
+};
 process;
 const {
   execPath
@@ -1682,8 +1690,12 @@ const handleUnhandledRejection = (reason, promise) => {
   }
 };
 
-const exit = () => {
-  app.quit();
+const exit = code => {
+  if (code === undefined) {
+    app.quit();
+    return;
+  }
+  app.exit(code);
 };
 
 const NodeWorker$1 = 1;
@@ -1708,9 +1720,9 @@ const getCombinedMessage = (error, message) => {
   }
   return stringifiedError;
 };
-const NewLine$3 = '\n';
+const NewLine$2 = '\n';
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, startIndex);
+  return string.indexOf(NewLine$2, startIndex);
 };
 const mergeStacks = (parent, child) => {
   if (!child) {
@@ -1748,31 +1760,31 @@ class VError extends Error {
   }
 }
 
-const isMessagePort$1 = value => {
+const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
-const isMessagePortMain$1 = value => {
+const isMessagePortMain = value => {
   return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-const isOffscreenCanvas$1 = value => {
+const isOffscreenCanvas = value => {
   return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-const isInstanceOf$1 = (value, constructorName) => {
+const isInstanceOf = (value, constructorName) => {
   return value?.constructor?.name === constructorName;
 };
-const isSocket$1 = value => {
-  return isInstanceOf$1(value, 'Socket');
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-const transferrables$1 = [isMessagePort$1, isMessagePortMain$1, isOffscreenCanvas$1, isSocket$1];
-const isTransferrable$1 = value => {
-  for (const fn of transferrables$1) {
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
     if (fn(value)) {
       return true;
     }
   }
   return false;
 };
-const walkValue$1 = (value, transferrables, isTransferrable) => {
+const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
@@ -1782,23 +1794,22 @@ const walkValue$1 = (value, transferrables, isTransferrable) => {
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue$1(item, transferrables, isTransferrable);
+      walkValue(item, transferrables, isTransferrable);
     }
     return;
   }
   if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue$1(property, transferrables, isTransferrable);
+      walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
-const getTransferrables$1 = value => {
+const getTransferrables = value => {
   const transferrables = [];
-  walkValue$1(value, transferrables, isTransferrable$1);
+  walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
-const removeValues$1 = (value, toRemove) => {
+const removeValues = (value, toRemove) => {
   if (!value) {
     return value;
   }
@@ -1806,7 +1817,7 @@ const removeValues$1 = (value, toRemove) => {
     const newItems = [];
     for (const item of value) {
       if (!toRemove.includes(item)) {
-        newItems.push(removeValues$1(item, toRemove));
+        newItems.push(removeValues(item, toRemove));
       }
     }
     return newItems;
@@ -1815,7 +1826,7 @@ const removeValues$1 = (value, toRemove) => {
     const newObject = Object.create(null);
     for (const [key, property] of Object.entries(value)) {
       if (!toRemove.includes(property)) {
-        newObject[key] = removeValues$1(property, toRemove);
+        newObject[key] = removeValues(property, toRemove);
       }
     }
     return newObject;
@@ -1826,15 +1837,15 @@ const removeValues$1 = (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$1 = value => {
-  const transfer = getTransferrables$1(value);
-  const newValue = removeValues$1(value, transfer);
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
   return {
     newValue,
     transfer
   };
 };
-const getActualDataElectron$1 = event => {
+const getActualDataElectron = event => {
   const {
     data,
     ports
@@ -1847,7 +1858,7 @@ const getActualDataElectron$1 = event => {
     params: [...ports, ...data.params]
   };
 };
-const attachEvents$1 = that => {
+const attachEvents = that => {
   const handleMessage = (...args) => {
     const data = that.getData(...args);
     that.dispatchEvent(new MessageEvent('message', {
@@ -1860,36 +1871,36 @@ const attachEvents$1 = that => {
   };
   that.onClose(handleClose);
 };
-let Ipc$1 = class Ipc extends EventTarget {
+class Ipc extends EventTarget {
   constructor(rawIpc) {
     super();
     this._rawIpc = rawIpc;
-    attachEvents$1(this);
+    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$1 = '\n';
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
 };
-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 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 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$1 = lines => {
-  const index = lines.findIndex(isNormalStackLine$1);
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
   if (index === -1) {
     return {
-      actualMessage: joinLines$2(lines),
+      actualMessage: joinLines$1(lines),
       rest: []
     };
   }
   let lastIndex = index - 1;
   while (++lastIndex < lines.length) {
-    if (!isNormalStackLine$1(lines[lastIndex])) {
+    if (!isNormalStackLine(lines[lastIndex])) {
       break;
     }
   }
@@ -1898,89 +1909,89 @@ const getDetails$1 = lines => {
     rest: lines.slice(index, lastIndex)
   };
 };
-const splitLines$2 = lines => {
-  return lines.split(NewLine$2);
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
 };
-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 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$1 = line => {
-  return RE_MESSAGE_CODE_BLOCK_END$1.test(line);
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
-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 getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(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$1 = line => {
+const isModuleNotFoundMessage = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
-const getModuleNotFoundError$1 = stderr => {
-  const lines = splitLines$2(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage$1);
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$1(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    code: ERR_MODULE_NOT_FOUND$1,
+    code: ERR_MODULE_NOT_FOUND,
     message
   };
 };
-const isModuleNotFoundError$1 = stderr => {
+const isModuleNotFoundError = stderr => {
   if (!stderr) {
     return false;
   }
   return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-const isModulesSyntaxError$1 = stderr => {
+const isModulesSyntaxError = stderr => {
   if (!stderr) {
     return false;
   }
   return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-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 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$1 = stderr => {
-  const message = getMessageCodeBlock$1(stderr);
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
   return {
-    code: E_INCOMPATIBLE_NATIVE_MODULE$1,
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
     message: `Incompatible native node module: ${message}`
   };
 };
-const getModuleSyntaxError$1 = () => {
+const getModuleSyntaxError = () => {
   return {
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON$1,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
     message: `ES Modules are not supported in electron`
   };
 };
-const getHelpfulChildProcessError$1 = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError$1(stderr)) {
-    return getNativeModuleErrorMessage$1(stderr);
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
   }
-  if (isModulesSyntaxError$1(stderr)) {
-    return getModuleSyntaxError$1();
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
   }
-  if (isModuleNotFoundError$1(stderr)) {
-    return getModuleNotFoundError$1(stderr);
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
   }
-  const lines = splitLines$2(stderr);
+  const lines = splitLines$1(stderr);
   const {
     actualMessage,
     rest
-  } = getDetails$1(lines);
+  } = getDetails(lines);
   return {
     code: '',
     message: actualMessage,
     stack: rest
   };
 };
-let IpcError$1 = class IpcError extends VError {
+class IpcError extends VError {
   // @ts-ignore
   constructor(betterMessage, stdout = '', stderr = '') {
     if (stdout || stderr) {
@@ -1989,11 +2000,18 @@ let IpcError$1 = class IpcError extends VError {
         code,
         message,
         stack
-      } = getHelpfulChildProcessError$1(stdout, stderr);
+      } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -2005,20 +2023,20 @@ let IpcError$1 = class IpcError extends VError {
     // @ts-ignore
     this.stderr = stderr;
   }
-};
-const listen$b$1 = ({
+}
+const listen$b = ({
   messagePort
 }) => {
-  if (!isMessagePortMain$1(messagePort)) {
-    throw new IpcError$1('port must be of type MessagePortMain');
+  if (!isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain');
   }
   return messagePort;
 };
-const signal$c$1 = messagePort => {
+const signal$c = messagePort => {
   messagePort.start();
 };
-let IpcChildWithElectronMessagePort$2 = class IpcChildWithElectronMessagePort extends Ipc$1 {
-  getData = getActualDataElectron$1;
+class IpcChildWithElectronMessagePort extends Ipc {
+  getData = getActualDataElectron;
   send(message) {
     this._rawIpc.postMessage(message);
   }
@@ -2026,7 +2044,7 @@ let IpcChildWithElectronMessagePort$2 = class IpcChildWithElectronMessagePort ex
     const {
       newValue,
       transfer
-    } = fixElectronParameters$1(message);
+    } = fixElectronParameters(message);
     this._rawIpc.postMessage(newValue, transfer);
   }
   dispose() {
@@ -2038,92 +2056,332 @@ let IpcChildWithElectronMessagePort$2 = class IpcChildWithElectronMessagePort ex
   onClose(callback) {
     this._rawIpc.on('close', callback);
   }
+}
+const wrap$j = messagePort => {
+  return new IpcChildWithElectronMessagePort(messagePort);
 };
-const wrap$j$1 = messagePort => {
-  return new IpcChildWithElectronMessagePort$2(messagePort);
-};
-const IpcChildWithElectronMessagePort$1$1 = {
+const IpcChildWithElectronMessagePort$1 = {
   __proto__: null,
-  listen: listen$b$1,
-  signal: signal$c$1,
-  wrap: wrap$j$1
-};
-const preloadChannelType$1 = 'port';
-const listen$2$1 = ({
-  webContents
-}) => {
-  return webContents;
+  listen: listen$b,
+  signal: signal$c,
+  wrap: wrap$j
 };
-const getData$1$1 = (event, message) => {
+
+// @ts-ignore
+const getUtilityProcessPortData = event => {
   const {
-    ports,
-    sender
+    data,
+    ports
   } = event;
-  const data = {
-    ...message,
-    params: [...message.params, ...ports, sender.id]
+  if (ports.length === 0) {
+    return data;
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params]
   };
-  return data;
 };
-let IpcChildWithRendererProcess2$2 = class IpcChildWithRendererProcess2 extends Ipc$1 {
-  getData(event, message) {
-    return getData$1$1(event, message);
+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(preloadChannelType$1, message);
+    this._rawIpc.postMessage(message);
   }
   sendAndTransfer(message) {
-    const transfer = getTransferrables$1(message);
-    this._rawIpc.postMessage(preloadChannelType$1, message, transfer);
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
   }
   dispose() {
-    // ignore
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
   }
   onMessage(callback) {
-    this._rawIpc.ipc.on(preloadChannelType$1, callback);
+    this._rawIpc.on('message', callback);
   }
-  onClose(callback) {
-    this._rawIpc.on('destroyed', 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);
 };
-const wrap$a$1 = webContents => {
-  return new IpcChildWithRendererProcess2$2(webContents);
+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 IpcChildWithRendererProcess2$1$1 = {
+const IpcChildWithNodeForkedProcess$1 = {
   __proto__: null,
-  listen: listen$2$1,
-  wrap: wrap$a$1
+  listen: listen$5,
+  signal: signal$7,
+  wrap: wrap$d
 };
-const Exit$1 = 1;
-const Message$1$1 = 3;
-const getFirstUtilityProcessEvent$1 = async utilityProcess => {
+const listen$3 = async () => {
   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;
+    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$1 = ({
+  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$1,
+  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$1
+      type: Message$1
     });
   };
   const handleExit = event => {
@@ -2131,7 +2389,7 @@ const getFirstUtilityProcessEvent$1 = async utilityProcess => {
       event,
       stderr,
       stdout,
-      type: Exit$1
+      type: Exit
     });
   };
   // @ts-ignore
@@ -2182,15 +2440,15 @@ const create$6$1 = async ({
     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);
+  } = 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$2 = class IpcParentWithElectronUtilityProcess extends Ipc$1 {
+let IpcParentWithElectronUtilityProcess$1 = class IpcParentWithElectronUtilityProcess extends Ipc {
   getData(data) {
     return data;
   }
@@ -2201,7 +2459,7 @@ let IpcParentWithElectronUtilityProcess$2 = class IpcParentWithElectronUtilityPr
     const {
       newValue,
       transfer
-    } = fixElectronParameters$1(message);
+    } = fixElectronParameters(message);
     this._rawIpc.postMessage(newValue, transfer);
   }
   dispose() {
@@ -2214,40 +2472,311 @@ let IpcParentWithElectronUtilityProcess$2 = class IpcParentWithElectronUtilityPr
     this._rawIpc.on('message', callback);
   }
 };
-const wrap$6$1 = process => {
-  return new IpcParentWithElectronUtilityProcess$2(process);
+const wrap$6 = process => {
+  return new IpcParentWithElectronUtilityProcess$1(process);
 };
-const IpcParentWithElectronUtilityProcess$1$2 = {
+const IpcParentWithElectronUtilityProcess$1$1 = {
   __proto__: null,
   create: create$6$1,
-  wrap: wrap$6$1
+  wrap: wrap$6
 };
-
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
+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 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);
-};
 
-const Two$1 = '2.0';
-const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
-  callbacks[id] = fn;
+// 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$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 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
+};
+
+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);
+};
+
+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];
@@ -2293,7 +2822,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine$1 = '\n';
+const NewLine = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -2338,78 +2867,102 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+const joinLines = lines => {
+  return lines.join(NewLine);
 };
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
+const splitLines = lines => {
+  return lines.split(NewLine);
 };
 const getCurrentStack = () => {
   const stackLinesToSkip = 3;
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$1 + parentStack;
+    parentStack = error.message + NewLine + parentStack;
   }
   return parentStack;
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    error.stack = error.stack + NewLine + currentStack;
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  restoredError.stack = parentStack + NewLine + currentStack;
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+    return;
+  }
+  if (error.data.stack) {
+    restoredError.stack = error.data.stack;
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  if (!error.data) {
+    return;
+  }
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  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;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    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;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine$1 + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   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 restoreMethodNotFoundError(error, currentStack);
   }
   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;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -2480,7 +3033,7 @@ const getErrorProperty = (error, prettyError) => {
     message: prettyError.message
   };
 };
-const create$1$2 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
     error,
     id,
@@ -2491,9 +3044,9 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$2(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$c = (message, result) => {
+const create$9 = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -2502,7 +3055,7 @@ const create$c = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$c(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -2612,7 +3165,7 @@ const invokeAndTransfer$1 = (ipc, method, ...params) => {
 
 const Two = '2.0';
 
-const create$b = (method, params) => {
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -2620,7 +3173,7 @@ const create$b = (method, params) => {
   };
 };
 
-const create$a = (id, method, params) => {
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -2631,12 +3184,12 @@ const create$a = (id, method, params) => {
 };
 
 let id = 0;
-const create$9 = () => {
+const create$6 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$9();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -2653,7 +3206,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$a(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -2689,7 +3242,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$b(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
@@ -2729,14 +3282,14 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$8 = async ({
+const create$5 = async ({
   commandMap,
   messagePort,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$1(IpcChildWithElectronMessagePort$1$1, {
+  const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
   if (requiresSocket) {
@@ -2747,7 +3300,7 @@ const create$8 = async ({
   return rpc;
 };
 
-const create$5 = async ({
+const create$4 = async ({
   argv,
   commandMap,
   env,
@@ -2758,14 +3311,14 @@ const create$5 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const rawIpc = await IpcParentWithElectronUtilityProcess$1$2.create({
+  const rawIpc = await IpcParentWithElectronUtilityProcess$1$1.create({
     argv,
     env,
     execArgv,
     name,
     path
   });
-  const ipc = IpcParentWithElectronUtilityProcess$1$2.wrap(rawIpc);
+  const ipc = IpcParentWithElectronUtilityProcess$1$1.wrap(rawIpc);
   if (requiresSocket) {
     // @ts-ignore
     ipc.requiresSocket = requiresSocket;
@@ -2775,14 +3328,14 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$3 = async ({
   commandMap,
   requiresSocket,
   webContents
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = IpcChildWithRendererProcess2$1$1.wrap(webContents);
+  const ipc = IpcChildWithRendererProcess2$1.wrap(webContents);
   if (requiresSocket) {
     // @ts-ignore
     ipc.requiresSocket = requiresSocket;
@@ -2860,7 +3413,7 @@ const trackUtilityProcess = (rawIpc, name) => {
 };
 
 const createElectronUtilityProcessRpc = async options => {
-  const rpc = await create$5(options);
+  const rpc = await create$4(options);
   const rpcWithRawIpc = rpc;
   trackUtilityProcess(rpcWithRawIpc.ipc?._rawIpc, options.name);
   return rpc;
@@ -3005,7 +3558,7 @@ const launchSharedProcess = async ({
     port2
   } = getPortTuple();
   await sharedProcessRpc.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port2, MainProcess);
-  await create$8({
+  await create$5({
     commandMap: commandMapRef,
     messagePort: port1,
     requiresSocket: requiresSocket
@@ -3093,6 +3646,7 @@ const Wait = 'wait';
 const BuiltinSelfTest = 'built-in-self-test';
 const Web = 'web';
 const SandBox = 'sandbox';
+const Prompt = 'prompt';
 const Install = 'install';
 const List = 'list';
 const Link = 'link';
@@ -3455,7 +4009,8 @@ const parseCliArgs = argv => {
     boolean: [Version, Help, Wait, BuiltinSelfTest, Web, SandBox],
     default: {
       sandbox: false
-    }
+    },
+    string: [Prompt]
   };
   const relevantArgv = argv.slice(1);
   const parsedArgs = minimist(relevantArgv, CLI_OPTIONS);
@@ -3576,6 +4131,10 @@ const handleWindowAllClosed = async () => {
   await send$1('HandleWindowAllClosed.handleWindowAllClosed');
 };
 
+const isPromptMode = parsedArgs => {
+  return typeof parsedArgs.prompt === 'string';
+};
+
 const isProtocolHandleApiSupported = protocol => {
   return !!protocol.handle;
 };
@@ -3640,6 +4199,7 @@ const hydrate = async (isLinux, chromeUserDataPath, argv) => {
   // see https://github.com/microsoft/playwright/issues/12345
 
   const parsedCliArgs = parseCliArgs(argv);
+  const isPromptMode$1 = isPromptMode(parsedCliArgs);
   const moduleId = canHandleFastCliArgs(parsedCliArgs);
   if (moduleId) {
     await handleFastCliArgs(moduleId, parsedCliArgs);
@@ -3651,14 +4211,16 @@ const hydrate = async (isLinux, chromeUserDataPath, argv) => {
     setCrashDumpsPath(chromeUserDataPath);
     setLogsPath(chromeUserDataPath);
   }
-  const hasLock = requestSingleInstanceLock(argv);
-  if (!hasLock) {
-    exit();
-    return;
+  if (!isPromptMode$1) {
+    const hasLock = requestSingleInstanceLock(argv);
+    if (!hasLock) {
+      exit();
+      return;
+    }
   }
 
   // TODO tree shake out the .env.DEV check: reading from env variables is expensive
-  if (process.stdout.isTTY && !parsedCliArgs.wait && !process.env.DEV) {
+  if (process.stdout.isTTY && !parsedCliArgs.wait && !isPromptMode$1 && !process.env.DEV) {
     spawn(execPath, argv.slice(1), {
       detached: true,
       stdio: 'ignore'
@@ -3863,7 +4425,7 @@ const set$1 = value => {
   state$1.session = value;
 };
 
-const create$3 = rpc => {
+const create$2 = rpc => {
   const handleRequest = async request => {
     const {
       method,
@@ -3886,13 +4448,13 @@ const get$1 = () => {
 };
 const registerWebviewProtocol = async port => {
   object(port);
-  const rpc = await create$8({
+  const rpc = await create$5({
     commandMap: {},
     messagePort: port,
     requiresSocket: requiresSocket
   });
   const session = get$1();
-  const handleRequest = create$3(rpc);
+  const handleRequest = create$2(rpc);
   handle(session.protocol, WebView, handleRequest);
 };
 
@@ -3956,7 +4518,9 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
     // window .webContents.setZoomLevel(zoomLevel)
     window.show();
   };
-  window.once('ready-to-show', handleReadyToShow);
+  if (!isPromptMode(parsedArgs)) {
+    window.once('ready-to-show', handleReadyToShow);
+  }
   // TODO query applicarion menu items from shared process
   const menu = createTitleBar(titleBarItems);
   setMenu(menu);
@@ -3973,7 +4537,7 @@ const createAppWindow = async (windowOptions, parsedArgs, workingDirectory, titl
     }
   };
   window.on('close', handleWindowClose);
-  await create$4({
+  await create$3({
     commandMap: commandMapRef,
     webContents: window.webContents
   });
@@ -4453,6 +5017,9 @@ const toggleDevtools = browserWindow => {
   }
   browserWindow.webContents.openDevTools(devtoolsOptions);
 };
+const toggleFullScreen = browserWindow => {
+  browserWindow.setFullScreen(!browserWindow.isFullScreen());
+};
 const executeWindowFunction = (browserWindowId, key) => {
   const browserWindow = getBrowserWindow(browserWindowId);
   if (!browserWindow) {
@@ -4462,6 +5029,10 @@ const executeWindowFunction = (browserWindowId, key) => {
     toggleDevtools(browserWindow);
     return;
   }
+  if (key === 'toggleFullScreen') {
+    toggleFullScreen(browserWindow);
+    return;
+  }
   browserWindow[key]();
 };
 const executeWebContentsFunction = (browserWindowId, key, ...args) => {
@@ -5729,991 +6300,6 @@ const unhandleIpc = ipc => {
   }
 };
 
-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;
-  }
-  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,
-  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$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`);
-  }
-  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$1,
-  wrap: wrap$1
-};
-
 const getModule$1 = method => {
   switch (method) {
     case ElectronMessagePort$1:
@@ -6804,7 +6390,7 @@ const getWindowId = webContentsId => {
 
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const rpc = await create$8({
+  const rpc = await create$5({
     commandMap: commandMapRef,
     messagePort: messagePort,
     requiresSocket: requiresSocket
@@ -7020,6 +6606,8 @@ const commandMap = {
   'Process.getNodeVersion': getNodeVersion,
   'Process.getPid': getPid,
   'Process.getV8Version': getV8Version,
+  'Process.writeStderr': writeStderr,
+  'Process.writeStdout': writeStdout,
   'TemporaryMessagePort.createPortTuple': createPortTuple,
   'TemporaryMessagePort.dispose': dispose,
   'TemporaryMessagePort.sendTo': sendTo,