@lvce-editor/embeds-process 4.0.0 → 4.3.0

package/dist/embedsProcessMain.js

@@ -14,17 +14,18 @@ const getAll = () => {
   return Object.entries(ipcMap);
 };
 
+const MainProcess$2 = -5;
+const SharedProcess$2 = 1;
+
 const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
-const create$6 = rpcId => {
+const create$5 = rpcId => {
   return {
     // @ts-ignore
     invoke(method, ...params) {
@@ -39,33 +40,14 @@ const create$6 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$7(rpcId, rpc);
+      set$5(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
     }
   };
 };
-const MainProcess$1 = -5;
-const SharedProcess$1 = 1;
-const {
-  invoke: invoke$3,
-  set: set$3
-} = create$6(MainProcess$1);
-const MainProcess$2 = {
-  __proto__: null,
-  invoke: invoke$3,
-  set: set$3
-};
-const {
-  set: set$4
-} = create$6(SharedProcess$1);
-const SharedProcess$2 = {
-  __proto__: null,
-  set: set$4
-};
-
-const {
-  invoke: invoke$1,
-  set: set$2
-} = MainProcess$2;
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
@@ -123,175 +105,55 @@ class VError extends Error {
   }
 }
 
-const dispose = async id => {
-  try {
-    await invoke$1('ElectronWebContents.dispose', id);
-  } catch (error) {
-    throw new VError(error, `Failed to dispose webcontents`);
-  }
-};
-const callFunction = (webContentsId, method, ...params) => {
-  return invoke$1(`ElectronWebContents.callFunction`, webContentsId, method, ...params);
-};
-const focus = webContentsId => {
-  return callFunction(webContentsId, 'focus');
-};
-const openDevtools = webContentsId => {
-  return callFunction(webContentsId, 'openDevTools');
-};
-const reload = webContentsId => {
-  return callFunction(webContentsId, 'reload');
-};
-const forward = webContentsId => {
-  return callFunction(webContentsId, 'goForward');
-};
-const backward = webContentsId => {
-  return callFunction(webContentsId, 'goBack');
-};
-const inspectElement = (webContentsId, x, y) => {
-  return callFunction(webContentsId, `inspectElement`, x, y);
-};
-
 class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
 }
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
-      return 'number';
+      return Number$1;
     case 'function':
-      return 'function';
+      return Function;
     case 'string':
-      return 'string';
+      return String;
     case 'object':
       if (value === null) {
-        return 'null';
+        return Null;
       }
       if (Array.isArray(value)) {
-        return 'array';
+        return Array$1;
       }
-      return 'object';
+      return Object$1;
     case 'boolean':
-      return 'boolean';
+      return Boolean;
     default:
-      return 'unknown';
+      return Unknown;
   }
 };
 const object = value => {
   const type = getType(value);
-  if (type !== 'object') {
+  if (type !== Object$1) {
     throw new AssertionError('expected value to be of type object');
   }
 };
 const number = value => {
   const type = getType(value);
-  if (type !== 'number') {
+  if (type !== Number$1) {
     throw new AssertionError('expected value to be of type number');
   }
 };
 
-const createWebContentsView = async (ipcId, restoreId, fallthroughKeyBindings) => {
-  number(restoreId);
-  // TODO race condition: ipc can be disposed while webcontents are being created
-  const webContentsId = await invoke$1('ElectronWebContentsView.createWebContentsView', restoreId);
-  add(webContentsId, ipcId);
-  // TODO get window id from renderer worker
-  await invoke$1('ElectronWebContentsView.attachEventListeners', webContentsId);
-  await invoke$1('ElectronWebContentsViewFunctions.setBackgroundColor', webContentsId, 'white');
-  return webContentsId;
-};
-const disposeWebContentsView = async id => {
-  await invoke$1('ElectronWebContentsView.disposeWebContentsView', id);
-  await dispose(id);
-};
-const resizeWebContentsView = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.resizeBrowserView', id, ...args);
-};
-const setIframeSrc = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.setIframeSrc', id, ...args);
-};
-const setIframeSrcFallback = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.setIframeSrcFallback', id, ...args);
-};
-const setFallthroughKeyBindings = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', id, ...args);
-};
-const getStats = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.getStats', id, ...args);
-};
-const getDomTree = async id => {
-  // @ts-ignore
-  return invoke$1('ElectronWebContentsViewFunctions.getDomTree', id);
-};
-const insertCss = async (id, css) => {
-  // @ts-ignore
-  return invoke$1('ElectronWebContentsViewFunctions.insertCss', id, css);
-};
-const insertJavaScript = async (id, css) => {
-  // @ts-ignore
-  return invoke$1('ElectronWebContentsViewFunctions.insertJavaScript', id, css);
-};
-const show = async (id, ...args) => {
-  return invoke$1('ElectronWebContentsViewFunctions.show', id, ...args);
-};
-const forwardIpcEvent = key => (id, ...args) => {
-  const ipc = get$2(id);
-  if (!ipc) {
-    return;
-  }
-  ipc.send(key, id, ...args);
-};
-const handleDidNavigate = forwardIpcEvent('ElectronWebContentsView.handleDidNavigate');
-const handleTitleUpdated = forwardIpcEvent('ElectronWebContentsView.handleTitleUpdated');
-const handleWillNavigate = forwardIpcEvent('ElectronWebContentsView.handleWillNavigate');
-const handleContextMenu = forwardIpcEvent('ElectronWebContentsView.handleContextMenu');
-const handleKeyBinding = forwardIpcEvent('ElectronWebContentsView.handleKeyBinding');
-const handleBrowserViewDestroyed = (id, ...args) => {
-  // TODO send to embeds worker?
-};
-
-const applyIncomingIpcResponse = async (target, response, ipcId) => {
-  switch (response.type) {
-    case 'handle':
-      break;
-    default:
-      throw new Error('unexpected response');
-  }
-};
-
-const handleIncomingIpcMessagePort = async (module, handle, message) => {
-  const target = await module.targetMessagePort(handle, message);
-  const response = module.upgradeMessagePort(handle, message);
-  return {
-    target,
-    response
-  };
-};
-
-const commandMapRef = {};
-
-const getIdsToDispose = ipc => {
-  const entries = getAll();
-  const toDispose = [];
-  for (const [id, value] of entries) {
-    if (value === ipc) {
-      toDispose.push(Number.parseInt(id));
-    }
-  }
-  return toDispose;
-};
-const handleIpcClosed = async event => {
-  const idsToDispose = getIdsToDispose(event.target);
-  for (const id of idsToDispose) {
-    remove$1(id);
-    await disposeWebContentsView(id);
-  }
-  // SharedProcessIpc.send('HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed')
-};
-
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -614,7 +476,7 @@ const listen$a = () => {
     parentPort
   } = process;
   if (!parentPort) {
-    throw new Error('parent port must be defined');
+    throw new IpcError('parent port must be defined');
   }
   return parentPort;
 };
@@ -672,7 +534,7 @@ const getTransferrablesNode = value => {
 };
 const listen$5 = async () => {
   if (!process.send) {
-    throw new Error('process.send must be defined');
+    throw new IpcError('process.send must be defined');
   }
   return process;
 };
@@ -714,7 +576,7 @@ const listen$3 = async () => {
     parentPort
   } = await import('node:worker_threads');
   if (!parentPort) {
-    throw new IpcError('parentPort is required');
+    throw new IpcError('parentPort is required for node worker threads ipc');
   }
   return parentPort;
 };
@@ -849,8 +711,6 @@ const handleUpgrade$1 = async (...args) => {
   // @ts-ignore
   return module.handleUpgrade(...args);
 };
-
-// @ts-ignore
 const listen$1$1 = async ({
   request,
   handle
@@ -871,8 +731,6 @@ const listen$1$1 = async ({
 const signal$4 = webSocket => {
   webSocket.resume();
 };
-
-// @ts-ignore
 const wrap$9 = webSocket => {
   return {
     webSocket,
@@ -927,7 +785,7 @@ const IpcChildWithWebSocket = {
 };
 
 const Two = '2.0';
-const create$4$1 = (method, params) => {
+const create$4 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -935,7 +793,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get = id => {
@@ -954,7 +812,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$1(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -1027,6 +885,17 @@ const constructError = (message, type, name) => {
   }
   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);
 };
@@ -1037,19 +906,16 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
 const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
     return error;
   }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -1130,6 +996,17 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+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 {
@@ -1142,7 +1019,7 @@ const getErrorProperty = (error, prettyError) => {
     code: Custom,
     message: prettyError.message,
     data: {
-      stack: prettyError.stack,
+      stack: getStack(prettyError),
       codeFrame: prettyError.codeFrame,
       type: getErrorType(prettyError),
       code: prettyError.code,
@@ -1150,18 +1027,18 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (message, error) => {
+const create$1 = (id, error) => {
   return {
     jsonrpc: Two,
-    id: message.id,
+    id,
     error
   };
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
+  return create$1(id, errorProperty);
 };
 const create = (message, result) => {
   return {
@@ -1174,12 +1051,27 @@ const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create(message, resultProperty);
 };
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
 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) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -1234,7 +1126,7 @@ const handleJsonRpcMessage = async (...args) => {
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -1262,16 +1154,22 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
+  const message = create$4(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+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);
@@ -1282,7 +1180,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -1298,10 +1196,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$3(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1339,7 +1237,7 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$e = async ({
+const create$k = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1358,9 +1256,9 @@ const create$e = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$e
+  create: create$k
 };
-const create$d = async ({
+const create$j = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1372,9 +1270,9 @@ const create$d = async ({
 };
 const ElectronUtilityProcessRpcClient = {
   __proto__: null,
-  create: create$d
+  create: create$j
 };
-const create$7 = async ({
+const create$a = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1386,9 +1284,9 @@ const create$7 = async ({
 };
 const NodeForkedProcessRpcClient = {
   __proto__: null,
-  create: create$7
+  create: create$a
 };
-const create$5 = async ({
+const create$8 = async ({
   commandMap,
   request,
   handle,
@@ -1409,9 +1307,9 @@ const create$5 = async ({
 };
 const NodeWebSocketRpcClient = {
   __proto__: null,
-  create: create$5
+  create: create$8
 };
-const create$4 = async ({
+const create$7 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1423,7 +1321,170 @@ const create$4 = async ({
 };
 const NodeWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$7
+};
+
+const {
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$3,
+  dispose: dispose$2
+} = create$5(MainProcess$2);
+
+const MainProcess$1 = {
+  __proto__: null,
+  dispose: dispose$2,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$3
+};
+
+const {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$2,
+  dispose: dispose$1
+} = create$5(SharedProcess$2);
+
+const SharedProcess$1 = {
+  __proto__: null,
+  dispose: dispose$1,
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$2
+};
+
+const {
+  invoke,
+  set: set$1
+} = MainProcess$1;
+
+const dispose = async id => {
+  try {
+    await invoke('ElectronWebContents.dispose', id);
+  } catch (error) {
+    throw new VError(error, `Failed to dispose webcontents`);
+  }
+};
+const callFunction = (webContentsId, method, ...params) => {
+  return invoke(`ElectronWebContents.callFunction`, webContentsId, method, ...params);
+};
+const focus = webContentsId => {
+  return callFunction(webContentsId, 'focus');
+};
+const openDevtools = webContentsId => {
+  return callFunction(webContentsId, 'openDevTools');
+};
+const reload = webContentsId => {
+  return callFunction(webContentsId, 'reload');
+};
+const forward = webContentsId => {
+  return callFunction(webContentsId, 'goForward');
+};
+const backward = webContentsId => {
+  return callFunction(webContentsId, 'goBack');
+};
+const inspectElement = (webContentsId, x, y) => {
+  return callFunction(webContentsId, `inspectElement`, x, y);
+};
+
+const createWebContentsView = async (ipcId, restoreId, fallthroughKeyBindings) => {
+  number(restoreId);
+  // TODO race condition: ipc can be disposed while webcontents are being created
+  const webContentsId = await invoke('ElectronWebContentsView.createWebContentsView', restoreId);
+  add(webContentsId, ipcId);
+  // TODO get window id from renderer worker
+  await invoke('ElectronWebContentsView.attachEventListeners', webContentsId);
+  await invoke('ElectronWebContentsViewFunctions.setBackgroundColor', webContentsId, 'white');
+  return webContentsId;
+};
+const disposeWebContentsView = async id => {
+  await invoke('ElectronWebContentsView.disposeWebContentsView', id);
+  await dispose(id);
+};
+const resizeWebContentsView = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.resizeBrowserView', id, ...args);
+};
+const setIframeSrc = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.setIframeSrc', id, ...args);
+};
+const setIframeSrcFallback = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.setIframeSrcFallback', id, ...args);
+};
+const setFallthroughKeyBindings = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', id, ...args);
+};
+const getStats = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.getStats', id, ...args);
+};
+const getDomTree = async id => {
+  // @ts-ignore
+  return invoke('ElectronWebContentsViewFunctions.getDomTree', id);
+};
+const insertCss = async (id, css) => {
+  // @ts-ignore
+  return invoke('ElectronWebContentsViewFunctions.insertCss', id, css);
+};
+const insertJavaScript = async (id, css) => {
+  // @ts-ignore
+  return invoke('ElectronWebContentsViewFunctions.insertJavaScript', id, css);
+};
+const show = async (id, ...args) => {
+  return invoke('ElectronWebContentsViewFunctions.show', id, ...args);
+};
+const forwardIpcEvent = key => (id, ...args) => {
+  const ipc = get$2(id);
+  if (!ipc) {
+    return;
+  }
+  ipc.send(key, id, ...args);
+};
+const handleDidNavigate = forwardIpcEvent('ElectronWebContentsView.handleDidNavigate');
+const handleTitleUpdated = forwardIpcEvent('ElectronWebContentsView.handleTitleUpdated');
+const handleWillNavigate = forwardIpcEvent('ElectronWebContentsView.handleWillNavigate');
+const handleContextMenu = forwardIpcEvent('ElectronWebContentsView.handleContextMenu');
+const handleKeyBinding = forwardIpcEvent('ElectronWebContentsView.handleKeyBinding');
+const handleBrowserViewDestroyed = (id, ...args) => {
+  // TODO send to embeds worker?
+};
+
+const applyIncomingIpcResponse = async (target, response, ipcId) => {
+  switch (response.type) {
+    case 'handle':
+      break;
+    default:
+      throw new Error('unexpected response');
+  }
+};
+
+const handleIncomingIpcMessagePort = async (module, handle, message) => {
+  const target = await module.targetMessagePort(handle, message);
+  const response = module.upgradeMessagePort(handle, message);
+  return {
+    target,
+    response
+  };
+};
+
+const commandMapRef = {};
+
+const getIdsToDispose = ipc => {
+  const entries = getAll();
+  const toDispose = [];
+  for (const [id, value] of entries) {
+    if (value === ipc) {
+      toDispose.push(Number.parseInt(id));
+    }
+  }
+  return toDispose;
+};
+const handleIpcClosed = async event => {
+  const idsToDispose = getIdsToDispose(event.target);
+  for (const id of idsToDispose) {
+    remove$1(id);
+    await disposeWebContentsView(id);
+  }
+  // SharedProcessIpc.send('HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed')
 };
 
 const NodeWorker = 1;
@@ -1478,7 +1539,9 @@ const targetMessagePort$2 = async (messagePort, message) => {
     commandMap: commandMapRef
   });
   // @ts-ignore
-  const ipc = rpc.ipc;
+  const {
+    ipc
+  } = rpc;
   ipc.addEventListener('close', handleIpcClosed);
   return rpc;
 };
@@ -1500,7 +1563,7 @@ const targetMessagePort$1 = async (messagePort, message) => {
     method: ElectronMessagePort,
     messagePort
   });
-  set$2(rpc);
+  set$1(rpc);
   return rpc;
 };
 const upgradeMessagePort$1 = () => {
@@ -1517,7 +1580,7 @@ const HandleIpcMainProcess = {
 
 const {
   set
-} = SharedProcess$2;
+} = SharedProcess$1;
 
 const targetMessagePort = async (messagePort, message) => {
   object(messagePort);
@@ -1543,18 +1606,22 @@ const HandleIpcSharedProcess = {
 const EmbedsWorker = 77;
 const MainProcess = -5;
 const SharedProcess = 1;
+const SharedProcessAlt = 1492;
 const EmbedsWorkerAlt = 208;
 
 const getModule = ipcId => {
   number(ipcId);
   switch (ipcId) {
     case SharedProcess:
+    case SharedProcessAlt:
       return HandleIpcSharedProcess;
+    // deprecated
     case EmbedsWorker:
     case EmbedsWorkerAlt:
       return HandleIpcEmbedsWorker;
     case MainProcess:
       return HandleIpcMainProcess;
+    // deprecated
     default:
       throw new Error(`Embeds process encountered unexpected incoming ipc ${ipcId}`);
   }
@@ -1579,6 +1646,23 @@ const handleElectronMessagePort = async (messagePort, ipcId) => {
   return handleIncomingIpc(ipcId, messagePort, {});
 };
 
+const createMainProcessRpc = async port => {
+  try {
+    const rpc = await ElectronMessagePortRpcClient.create({
+      commandMap: {},
+      messagePort: port
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create main process rpc`);
+  }
+};
+
+const initialize = async port => {
+  const rpc = await createMainProcessRpc(port);
+  set$1(rpc);
+};
+
 const commandMap = {
   'ElectronWebContents.handleBrowserViewDestroyed': handleBrowserViewDestroyed,
   'ElectronWebContents.handleContextMenu': handleContextMenu,
@@ -1603,7 +1687,8 @@ const commandMap = {
   'ElectronWebContentsView.setIframeSrc': setIframeSrc,
   'ElectronWebContentsView.setIframeSrcFallback': setIframeSrcFallback,
   'ElectronWebContentsView.show': show,
-  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort
+  'HandleElectronMessagePort.handleElectronMessagePort': handleElectronMessagePort,
+  'Initialize.initialize': initialize
 };
 
 const listen = async argv => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/embeds-process",
-  "version": "4.0.0",
+  "version": "4.3.0",
   "description": "Embeds Process",
   "keywords": [
     "Lvce Editor"