@lvce-editor/process-explorer-worker 3.0.0 → 3.2.0

package/index.js

@@ -2,7 +2,7 @@ const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
 };
-const create$a = () => {
+const create$e = () => {
   const states = Object.create(null);
   const commandMapRef = {};
   return {
@@ -184,22 +184,25 @@ const {
   get: get$2,
   getCommandIds,
   registerCommands,
-  set: set$4,
+  set: set$9,
   wrapCommand,
   wrapLoadContent
-} = create$a();
+} = create$e();
 
-const create$9 = (id, _uri, x, y, width, height, _args, parentUid, _platform = 0, assetDir = '') => {
+const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0, assetDir = '') => {
   const state = {
     assetDir,
     collapsedPids: [],
+    errorCodeFrame: '',
     errorMessage: '',
+    errorStack: '',
     focus: 0,
     focused: false,
     focusedIndex: -1,
     height,
     initial: true,
     parentUid,
+    platform,
     processes: [],
     rootPid: 0,
     uid: id,
@@ -208,7 +211,7 @@ const create$9 = (id, _uri, x, y, width, height, _args, parentUid, _platform = 0
     x,
     y
   };
-  set$4(state.uid, state, state);
+  set$9(state.uid, state, state);
   return state;
 };
 
@@ -217,7 +220,7 @@ const isEqual$1 = (oldState, newState) => {
 };
 
 const isEqual = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.errorMessage === newState.errorMessage && oldState.visibleProcesses === newState.visibleProcesses;
+  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.visibleProcesses === newState.visibleProcesses;
 };
 
 const RenderItems = 1;
@@ -305,6 +308,7 @@ const Text = 12;
 const Th = 13;
 const THead = 14;
 const Tr = 15;
+const Pre = 51;
 
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
@@ -321,10 +325,21 @@ const DownArrow = 16;
 const ContextMenu = 56;
 const Star = 131;
 
+const Script = 2;
+
 const CtrlCmd = 1 << 11 >>> 0;
 
+const Electron = 2;
+const Remote = 3;
+
+const DebugWorker = 55;
+const EditorWorker = 99;
+const ErrorWorker = 3308;
 const FileSystemWorker$1 = 209;
-const RendererWorker = 1;
+const IconThemeWorker = 7009;
+const OpenerWorker = 4561;
+const RendererWorker$1 = 1;
+const TestWorker = 9001;
 
 const FocusSelector = 'Viewlet.focusSelector';
 const SetDom2 = 'Viewlet.setDom2';
@@ -333,7 +348,7 @@ const SetFocusContext = 'Viewlet.setFocusContext';
 const Empty = 0;
 const FocusExplorer = 13;
 
-const getKeyBindings = () => {
+const getKeyBindings$1 = () => {
   return [{
     command: 'ProcessExplorer.handleArrowRight',
     key: RightArrow,
@@ -514,6 +529,49 @@ class VError extends Error {
   }
 }
 
+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$1 = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -828,6 +886,9 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const Error$3 = 1;
+const Open = 2;
+const Close = 3;
 const addListener = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
     emitter.addEventListener(type, callback);
@@ -922,6 +983,66 @@ const IpcParentWithMessagePort$1 = {
   signal: signal$1,
   wrap: wrap$5
 };
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    close: Close,
+    error: Error$3,
+    open: Open
+  });
+};
+const create$c = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  if (firstWebSocketEvent.type === Error$3) {
+    throw new IpcError(`WebSocket connection error`);
+  }
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+const IpcParentWithWebSocket$1 = {
+  __proto__: null,
+  create: create$c,
+  wrap
+};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -1158,7 +1279,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$8 = (message, result) => {
+const create$b = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -1167,7 +1288,7 @@ const create$8 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$8(message, resultProperty);
+  return create$b(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -1261,7 +1382,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$7 = (method, params) => {
+const create$a = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -1269,7 +1390,7 @@ const create$7 = (method, params) => {
   };
 };
 
-const create$6 = (id, method, params) => {
+const create$9 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -1280,12 +1401,12 @@ const create$6 = (id, method, params) => {
 };
 
 let id = 0;
-const create$5 = () => {
+const create$8 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$5();
+  const id = create$8();
   const {
     promise,
     resolve
@@ -1302,7 +1423,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$6(id, method, params);
+  const message = create$9(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1338,7 +1459,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$7(method, params);
+      const message = create$a(method, params);
       ipc.send(message);
     }
   };
@@ -1378,7 +1499,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$4 = async ({
+const create$7 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1396,7 +1517,7 @@ const create$4 = async ({
   return rpc;
 };
 
-const create$3 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1406,7 +1527,7 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$4({
+  return create$7({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
@@ -1441,13 +1562,13 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$2 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$3({
+    return create$6({
       commandMap,
       isMessagePortOpen,
       send
@@ -1455,6 +1576,68 @@ const create$2 = async ({
   });
 };
 
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
+};
+
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
+};
+
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
+
+const create$4 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+const create$3 = async ({
+  commandMap,
+  type
+}) => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl(type, host, protocol);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await create$4({
+    commandMap,
+    webSocket
+  });
+  return rpc;
+};
+
+const create$2 = async ({
+  commandMap,
+  type
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$3({
+      commandMap,
+      type
+    });
+  });
+};
+
 const create$1 = async ({
   commandMap
 }) => {
@@ -1487,7 +1670,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$8 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1520,7 +1703,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$3(rpcId, mockRpc);
+      set$8(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1529,29 +1712,612 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$3(rpcId, rpc);
+      set$8(rpcId, rpc);
     }
   };
 };
 
 const {
-  set: set$2
+  set: set$7
+} = create(EditorWorker);
+
+const {
+  invoke: invoke$2,
+  set: set$6
+} = create(ErrorWorker);
+const prepare = async error => {
+  return invoke$2('Errors.prepare', error);
+};
+
+const {
+  set: set$5
 } = create(FileSystemWorker$1);
 
 const FileSystemWorker = {
   __proto__: null,
-  set: set$2
+  set: set$5
 };
 
 const {
+  set: set$4
+} = create(OpenerWorker);
+
+const {
+  set: set$3
+} = create(IconThemeWorker);
+
+const {
+  dispose,
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$1
-} = create(RendererWorker);
+  registerMockRpc,
+  set: set$2
+} = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$1('FileSystemHandle.getFilePathElectron', file);
+};
+const handleModifiedStatusChange = async (uri, modified) => {
+  return invoke$1('Main.handleModifiedStatusChange', uri, modified);
+};
+/**
+ * @deprecated
+ */
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$1('ContextMenu.show', x, y, id, ...args);
+};
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
+};
+const getElectronVersion = async () => {
+  return invoke$1('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$1('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  return invoke$1(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$1('Process.getNodeVersion');
+};
+const getBadgeCounts = async () => {
+  return invoke$1('Layout.getBadgeCounts');
+};
+const getChromeVersion = async () => {
+  return invoke$1('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$1('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$1('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$1('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$1('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToSettingsWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSettingsWorker', port, command, rpcId);
+};
+const sendMessagePortToClipBoardWorker = async (port, rpcId) => {
+  const command = 'ClipBoard.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
+};
+const sendMessagePortToOpenerWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
+};
+const sendMessagePortToChatMathWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatMathWorker', port, command, rpcId);
+};
+const sendMessagePortToChatCoordinatorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatCoordinatorWorker', port, command, rpcId);
+};
+const sendMessagePortToChatMessageParsingWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatMessageParsingWorker', port, command, rpcId);
+};
+const sendMessagePortToMainAreaWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMainAreaWorker', port, command, rpcId);
+};
+const sendMessagePortToTerminalProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTerminalProcess', port, command, rpcId);
+};
+const sendMessagePortToTextSearchWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextSearchWorker', port, command, rpcId);
+};
+const sendMessagePortToAuthWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToAuthWorker', port, command, rpcId);
+};
+const sendMessagePortToAuthProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker$1 = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
 const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
+const readFile = async uri => {
+  return invoke$1('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  return invoke$1('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$1('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$1('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$1('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  return invoke$1('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  return invoke$1('ExtensionManagement.enable', id);
+};
+const disposeEditor = async uid => {
+  return invoke$1('Viewlet.dispose', uid);
+};
+const handleDebugChange = async params => {
+  return invoke$1('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$1('IconTheme.getFolderIcon', options);
+};
+const handleWorkspaceRefresh = async () => {
+  return invoke$1('Layout.handleWorkspaceRefresh');
+};
+const closeWidget = async widgetId => {
+  return invoke$1('Viewlet.closeWidget', widgetId);
+};
+const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
+  return invoke$1('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const getViewletModuleId = async uri => {
+  return invoke$1('Layout.getModuleId', uri);
+};
+const showPanel = async () => {
+  return invoke$1('Layout.showPanel');
+};
+const showPreview = async () => {
+  return invoke$1('Layout.showPreview');
+};
+const saveEditor = async () => {
+  return invoke$1('Editor.save');
+};
+const sendMessagePortToFileSearchWorker2 = async (port, rpcId = 0) => {
+  const command = 'FileSearch.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSearchWorker', port, command, rpcId);
+};
+const togglePanelView = async id => {
+  return invoke$1('Panel.toggleView', id);
+};
+const resizeViewlet = async (uid, dimensions) => {
+  return invoke$1('Viewlet.resize', uid, dimensions);
+};
+const sendMessagePortToFileSearchWorker = async (port, rpcId = 0) => {
+  const command = 'QuickPick.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSearchWorker', port, command, rpcId);
+};
+const sendMessagePortToQuickPickWorker = async (port, rpcId = 0) => {
+  const command = 'QuickPick.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToQuickPickWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const sendMessagePortToChatViewModel = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToChatViewModel', port, 'ViewModel.handleMessagePort');
+};
+const sendMessagePortToChatNetworkWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatNetworkWorker', port, 'HandleMessagePort.handleMessagePort');
+};
+const sendMessagePortToChatToolWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatToolWorker', port, 'HandleMessagePort.handleMessagePort');
+};
+const sendMessagePortToChatStorageWorker = async (port, rpcId) => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker', port, 'HandleMessagePort.handleMessagePort', rpcId);
+};
+const sendMessagePortToChatDebugViewWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatDebugViewWorker', port, 'HandleMessagePort.handleMessagePort');
+};
+const confirm = async (message, options) => {
+  const result = await invoke$1('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$1('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$1('ClipBoard.writeText', /* text */text);
+};
+const writeFile = async (uri, text) => {
+  await invoke$1('FileSystem.writeFile', uri, text);
+};
+const handleUriChange = async (uri, newUri) => {
+  await invoke$1('Main.handleUriChange', uri, newUri);
+};
+const readClipBoardText = async () => {
+  return invoke$1('ClipBoard.readText');
+};
+const writeClipBoardImage = async blob => {
+  await invoke$1('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$1('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$1('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$1('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$1('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = (event, assetDir, platform) => {
+  return invoke$1('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
+};
+const setAdditionalFocus = focusKey => {
+  return invoke$1('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  return invoke$1('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$1('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
+const sendMessagePortToSharedProcess = async port => {
+  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+};
+const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+};
+const sendMessagePortToIframeWorker = async (port, rpcId) => {
+  const command = 'Iframes.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
+};
+const getPreference = async key => {
+  return await invoke$1('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$1('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  return invoke$1('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$1('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$1('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const sendMessagePortToBlobWorker = async (port, rpcId = 0) => {
+  const command = 'Blob.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToBlobWorker', port, command, rpcId);
+};
+const sendMessagePortToDiffWorker = async (port, rpcId = 0) => {
+  const command = 'Diff.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToDiffWorker', port, command, rpcId);
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$1('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$1('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  return invoke$1('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$1('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  await invoke$1('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  return await invoke$1('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  return invoke$1('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  return invoke$1('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  return invoke$1('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  await invoke$1('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$1('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  return invoke$1('ExtensionManagement.install', id);
+};
+const minimizeWindow = async () => {
+  return invoke$1('ElectronWindow.minimize');
+};
+const unmaximizeWindow = async () => {
+  return invoke$1('ElectronWindow.unmaximize');
+};
+const maximizeWindow = async () => {
+  return invoke$1('ElectronWindow.maximize');
+};
+const showSideBar = async (id, focus) => {
+  return invoke$1('SideBar.show', id, focus);
+};
+const closeWindow = async () => {
+  return invoke$1('ElectronWindow.close');
+};
+const openExtensionSearch = async () => {
+  return invoke$1('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  return invoke$1('Extensions.handleInput', searchValue, Script);
+};
+const openExternal = async uri => {
+  await invoke$1('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  await invoke$1('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  return invoke$1('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  return invoke$1('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  return invoke$1('PlatformPaths.getLogsDir');
+};
+const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
+  return invoke$1(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+};
+const refreshOutput = async () => {
+  await invoke$1('Output.refresh');
+};
+const send = async (port, sourceId = 0) => {
+  await sendMessagePortToOpenerWorker(port, sourceId);
+};
+const initializeOpenerWorker = async () => {
+  const rpc = await create$5({
+    commandMap: {},
+    send
+  });
+  set$4(rpc);
+};
+const send2 = async port => {
+  await sendMessagePortToEditorWorker(port, TestWorker);
+};
+const initializeEditorWorker = async () => {
+  const rpc = await create$5({
+    commandMap: {},
+    send: send2
+  });
+  set$7(rpc);
+};
+const send3 = port => {
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+const initializeTextMeasurementWorker = async () => {
+  const rpc = await create$5({
+    commandMap: {},
+    send: send3
+  });
+  set$3(rpc);
+};
+
+const RendererWorker = {
+  __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  closeWindow,
+  confirm,
+  createViewlet,
+  disableExtension,
+  dispose,
+  disposeEditor,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBadgeCounts,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getViewletModuleId,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  handleModifiedStatusChange,
+  handleUriChange,
+  handleWorkspaceRefresh,
+  initializeEditorWorker,
+  initializeOpenerWorker,
+  initializeTextMeasurementWorker,
+  installExtension,
+  invoke: invoke$1,
+  invokeAndTransfer,
+  maximizeWindow,
+  measureTextBlockHeight,
+  minimizeWindow,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readClipBoardText,
+  readFile,
+  refreshOutput,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  resizeViewlet,
+  saveEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToAuthProcess,
+  sendMessagePortToAuthWorker,
+  sendMessagePortToBlobWorker,
+  sendMessagePortToChatCoordinatorWorker,
+  sendMessagePortToChatDebugViewWorker,
+  sendMessagePortToChatMathWorker,
+  sendMessagePortToChatMessageParsingWorker,
+  sendMessagePortToChatNetworkWorker,
+  sendMessagePortToChatStorageWorker,
+  sendMessagePortToChatToolWorker,
+  sendMessagePortToChatViewModel,
+  sendMessagePortToClipBoardWorker,
+  sendMessagePortToDiffWorker,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker: sendMessagePortToErrorWorker$1,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToFileSearchWorker,
+  sendMessagePortToFileSearchWorker2,
+  sendMessagePortToFileSystemProcess,
+  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$1,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToIframeWorker,
+  sendMessagePortToMainAreaWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToOpenerWorker,
+  sendMessagePortToQuickPickWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSettingsWorker,
+  sendMessagePortToSharedProcess,
+  sendMessagePortToSourceControlWorker,
+  sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTerminalProcess,
+  sendMessagePortToTextMeasurementWorker,
+  sendMessagePortToTextSearchWorker,
+  set: set$2,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showContextMenu2,
+  showErrorDialog,
+  showMessageBox,
+  showPanel,
+  showPreview,
+  showSaveFilePicker,
+  showSideBar,
+  togglePanelView,
+  uninstallExtension,
+  unmaximizeWindow,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText,
+  writeFile
+};
 
 const isDebuggable = command => {
   return command.includes('node ') || command.includes('node.exe') || command.includes('node.mojom.NodeService');
@@ -1610,12 +2376,67 @@ const handleFocus = state => {
   };
 };
 
+const sendMessagePortToProcessExplorer = async port => {
+  const rendererWorker = RendererWorker;
+  await rendererWorker.sendMessagePortToProcessExplorer(port);
+};
+
+const launchProcessExplorerElectron = async () => {
+  try {
+    const rpc = await create$5({
+      commandMap: {},
+      send: sendMessagePortToProcessExplorer
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, 'Failed to create process explorer electron rpc');
+  }
+};
+
+const launchProcessExplorerNode = async () => {
+  try {
+    const rpc = await create$2({
+      commandMap: {},
+      type: 'process-explorer'
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, 'Failed to create process explorer websocket rpc');
+  }
+};
+
+const state$1 = {
+  rpc: undefined
+};
 const invoke = async (method, ...params) => {
-  return invoke$1(method, ...params);
+  if (!state$1.rpc) {
+    throw new Error('ProcessExplorerModule is not initialized');
+  }
+  return state$1.rpc.invoke(method, ...params);
+};
+const set$1 = newRpc => {
+  state$1.rpc = newRpc;
+};
+
+const state = {
+  initializedPlatform: 0
+};
+const initializeProcessExplorer = async platform => {
+  if (state.initializedPlatform === platform) {
+    return;
+  }
+  if (platform === Electron) {
+    const rpc = await launchProcessExplorerElectron();
+    set$1(rpc);
+    state.initializedPlatform = platform;
+    return;
+  }
+  if (platform === Remote) {
+    const rpc = await launchProcessExplorerNode();
+    set$1(rpc);
+    state.initializedPlatform = platform;
+  }
 };
-const {
-  set
-} = FileSystemWorker;
 
 const getErrorMessage = error => {
   if (error instanceof Error) {
@@ -1623,6 +2444,17 @@ const getErrorMessage = error => {
   }
   return String(error);
 };
+const prepareError = async error => {
+  try {
+    return await prepare(error);
+  } catch {
+    return {
+      codeFrame: undefined,
+      message: getErrorMessage(error),
+      stack: undefined
+    };
+  }
+};
 const getFocusedIndex = (oldFocusedIndex, visibleProcesses) => {
   if (visibleProcesses.length === 0) {
     return -1;
@@ -1634,12 +2466,15 @@ const getFocusedIndex = (oldFocusedIndex, visibleProcesses) => {
 };
 const refresh = async state => {
   try {
+    await initializeProcessExplorer(state.platform);
     const rootPid = state.rootPid || (await invoke('ProcessId.getMainProcessId'));
     const processes = await invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid);
     const visibleProcesses = getVisibleProcesses(processes, state.collapsedPids, rootPid);
     return {
       ...state,
+      errorCodeFrame: '',
       errorMessage: '',
+      errorStack: '',
       focusedIndex: getFocusedIndex(state.focusedIndex, visibleProcesses),
       initial: false,
       processes,
@@ -1647,9 +2482,12 @@ const refresh = async state => {
       visibleProcesses
     };
   } catch (error) {
+    const prettyError = await prepareError(error);
     return {
       ...state,
-      errorMessage: getErrorMessage(error),
+      errorCodeFrame: prettyError.codeFrame || '',
+      errorMessage: prettyError.message || getErrorMessage(error),
+      errorStack: prettyError.stack || '',
       initial: false
     };
   }
@@ -1810,23 +2648,37 @@ const getBodyDom = state => {
     type: TBody
   }, ...visibleProcesses.flatMap((process, index) => getRowDom(process, index, index === focusedIndex))];
 };
-const getErrorDom = errorMessage => {
-  if (!errorMessage) {
+const getErrorSectionDom = (value, type) => {
+  if (!value) {
     return [];
   }
   return [{
     childCount: 1,
+    type
+  }, text(value)];
+};
+const hasError = state => {
+  return Boolean(state.errorMessage || state.errorCodeFrame || state.errorStack);
+};
+const getErrorDom = state => {
+  const messageDom = getErrorSectionDom(state.errorMessage, Div);
+  const codeFrameDom = getErrorSectionDom(state.errorCodeFrame, Pre);
+  const stackDom = getErrorSectionDom(state.errorStack, Pre);
+  const childCount = messageDom.length / 2 + codeFrameDom.length / 2 + stackDom.length / 2;
+  return [{
+    childCount: 1,
+    className: `${Viewlet} ${ProcessExplorer}`,
+    role: None,
+    type: Div
+  }, {
+    childCount,
     className: Error$1,
     type: Div
-  }, text(errorMessage)];
+  }, ...messageDom, ...codeFrameDom, ...stackDom];
 };
-const getDom = state => {
-  if (state.initial) {
-    return [];
-  }
-  const errorDom = getErrorDom(state.errorMessage);
+const getTableDom = state => {
   return [{
-    childCount: 1 + (errorDom.length > 0 ? 1 : 0),
+    childCount: 1,
     className: `${Viewlet} ${ProcessExplorer}`,
     role: None,
     type: Div
@@ -1844,7 +2696,16 @@ const getDom = state => {
     role: Grid,
     tabIndex: 0,
     type: Table$1
-  }, ...getHeaderDom(), ...getBodyDom(state), ...errorDom];
+  }, ...getHeaderDom(), ...getBodyDom(state)];
+};
+const getDom = state => {
+  if (state.initial) {
+    return [];
+  }
+  if (hasError(state)) {
+    return getErrorDom(state);
+  }
+  return getTableDom(state);
 };
 const renderItems = (oldState, newState) => {
   return [SetDom2, newState.uid, getDom(newState)];
@@ -1880,7 +2741,7 @@ const render2 = (uid, diffResult) => {
     oldState,
     scheduledState
   } = get$2(uid);
-  set$4(uid, scheduledState, scheduledState);
+  set$9(uid, scheduledState, scheduledState);
   return applyRender(oldState, scheduledState, diffResult);
 };
 
@@ -1911,7 +2772,7 @@ const renderEventListeners = () => {
 
 const commandMap = {
   'ProcessExplorer.collapseAll': wrapCommand(collapseAll),
-  'ProcessExplorer.create': create$9,
+  'ProcessExplorer.create': create$d,
   'ProcessExplorer.diff2': diff2,
   'ProcessExplorer.expandAll': wrapCommand(expandAll),
   'ProcessExplorer.focusFirst': wrapCommand(focusFirst),
@@ -1919,7 +2780,7 @@ const commandMap = {
   'ProcessExplorer.focusNext': wrapCommand(focusNext),
   'ProcessExplorer.focusPrevious': wrapCommand(focusPrevious),
   'ProcessExplorer.getCommandIds': getCommandIds,
-  'ProcessExplorer.getKeyBindings': getKeyBindings,
+  'ProcessExplorer.getKeyBindings': getKeyBindings$1,
   'ProcessExplorer.handleArrowLeft': wrapCommand(handleArrowLeft),
   'ProcessExplorer.handleArrowRight': wrapCommand(handleArrowRight),
   'ProcessExplorer.handleBlur': wrapCommand(handleBlur),
@@ -1934,13 +2795,34 @@ const commandMap = {
   'ProcessExplorer.terminate': terminate
 };
 
+const sendMessagePortToErrorWorker = async port => {
+  await sendMessagePortToErrorWorker$1(port, 0);
+};
+
+const createErrorWorkerRpc = async () => {
+  try {
+    const rpc = await create$5({
+      commandMap: {},
+      send: sendMessagePortToErrorWorker
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create error worker rpc`);
+  }
+};
+
+const initializeErrorWorker = async () => {
+  const rpc = await createErrorWorkerRpc();
+  set$6(rpc);
+};
+
 const sendMessagePortToFileSystemWorker = async port => {
   await sendMessagePortToFileSystemWorker$1(port, 0);
 };
 
 const createFileSystemWorkerRpc = async () => {
   try {
-    const rpc = await create$2({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToFileSystemWorker
     });
@@ -1950,6 +2832,10 @@ const createFileSystemWorkerRpc = async () => {
   }
 };
 
+const {
+  set
+} = FileSystemWorker;
+
 const initializeFileSystemWorker = async () => {
   const rpc = await createFileSystemWorkerRpc();
   set(rpc);
@@ -1959,12 +2845,12 @@ const initializeRendererWorker = async () => {
   const rpc = await create$1({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const listen = async () => {
   registerCommands(commandMap);
-  await Promise.all([initializeRendererWorker(), initializeFileSystemWorker()]);
+  await Promise.all([initializeRendererWorker(), initializeFileSystemWorker(), initializeErrorWorker()]);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer-worker",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",