@lvce-editor/process-explorer-worker 3.7.0 → 3.10.0

package/index.js

@@ -181,17 +181,19 @@ const collapseAll = state => {
 };
 
 const {
-  dispose: dispose$3,
+  dispose: dispose$4,
   get: get$2,
   getCommandIds,
   getKeys: getKeys$1,
   registerCommands,
-  set: set$a,
+  set: set$6,
   wrapCommand,
   wrapGetter,
   wrapLoadContent
 } = create$e();
 
+const processExplorerUpdateInterval = 1000;
+
 const getIncludeFrontendMemoryUsage = args => {
   if (!args || typeof args !== 'object') {
     return false;
@@ -199,6 +201,16 @@ const getIncludeFrontendMemoryUsage = args => {
   const createArgs = args;
   return createArgs.includeFrontendMemoryUsage === true;
 };
+const getUpdateInterval = args => {
+  if (!args || typeof args !== 'object') {
+    return processExplorerUpdateInterval;
+  }
+  const createArgs = args;
+  if (typeof createArgs.updateInterval !== 'number') {
+    return processExplorerUpdateInterval;
+  }
+  return createArgs.updateInterval;
+};
 const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0, assetDir = '') => {
   const state = {
     assetDir,
@@ -215,14 +227,15 @@ const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0,
     parentUid,
     platform,
     processes: [],
-    rootPid: 0,
+    rootPid: -1,
     uid: id,
+    updateInterval: getUpdateInterval(args),
     visibleProcesses: [],
     width,
     x,
     y
   };
-  set$a(state.uid, state, state);
+  set$6(state.uid, state, state);
   return state;
 };
 
@@ -888,8 +901,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -900,55 +915,77 @@ const getParentStack = error => {
 };
 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 + 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 + 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 + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -1423,7 +1460,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$9 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1456,7 +1493,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$9(rpcId, mockRpc);
+      set$5(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1465,7 +1502,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$9(rpcId, rpc);
+      set$5(rpcId, rpc);
     }
   };
 };
@@ -1483,7 +1520,6 @@ const Reference = 100;
 
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
-const TargetName = 'event.target.name';
 
 const Enter = 3;
 const Space = 9;
@@ -1496,8 +1532,6 @@ const DownArrow = 16;
 const ContextMenu = 56;
 const Star = 131;
 
-const Script = 2;
-
 const CtrlCmd = 1 << 11 >>> 0;
 
 const None$1 = 0;
@@ -1505,14 +1539,9 @@ const None$1 = 0;
 const Electron = 2;
 const Remote = 3;
 
-const DebugWorker = 55;
-const EditorWorker = 99;
 const ErrorWorker = 3308;
 const FileSystemWorker$1 = 209;
-const IconThemeWorker = 7009;
-const OpenerWorker = 4561;
-const RendererWorker$1 = 1;
-const TestWorker = 9001;
+const RendererWorker = 1;
 
 const FocusSelector = 'Viewlet.focusSelector';
 const SetDom2 = 'Viewlet.setDom2';
@@ -1522,61 +1551,28 @@ const SetPatches = 'Viewlet.setPatches';
 const Empty = 0;
 const FocusExplorer = 13;
 
-const {
-  set: set$8
-} = create(EditorWorker);
-
 const {
   invoke: invoke$2,
-  set: set$7
+  set: set$4
 } = create(ErrorWorker);
 const prepare = async error => {
   return invoke$2('Errors.prepare', error);
 };
 
 const {
-  set: set$6
+  set: set$3
 } = create(FileSystemWorker$1);
 
 const FileSystemWorker = {
   __proto__: null,
-  set: set$6
-};
-
-const {
-  set: set$5
-} = create(OpenerWorker);
-
-const {
-  set: set$4
-} = create(10_001);
-
-const {
   set: set$3
-} = create(IconThemeWorker);
+};
 
 const {
-  dispose: dispose$2,
   invoke: invoke$1,
   invokeAndTransfer,
-  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);
-};
+} = create(RendererWorker);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
@@ -1584,565 +1580,18 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   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$1 = 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 sendMessagePortToProcessExplorer$1 = async port => {
   const command = 'ProcessExplorer.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToProcessExplorer', 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$5(rpc);
-};
-const send2 = async port => {
-  await sendMessagePortToEditorWorker(port, TestWorker);
-};
-const initializeEditorWorker = async () => {
-  const rpc = await create$5({
-    commandMap: {},
-    send: send2
-  });
-  set$8(rpc);
-};
-const send3 = port => {
-  return sendMessagePortToTextMeasurementWorker(port);
-};
-const initializeTextMeasurementWorker = async () => {
-  const rpc = await create$5({
-    commandMap: {},
-    send: send3
-  });
-  set$3(rpc);
-};
-const send4 = port => {
-  return sendMessagePortToTextMeasurementWorker(port);
-};
-const initializeProcessExplorer$1 = async () => {
-  const rpc = await create$5({
-    commandMap: {},
-    send: send4
-  });
-  set$4(rpc);
-};
-
-const RendererWorker = {
-  __proto__: null,
-  activateByEvent,
-  applyBulkReplacement,
-  closeWidget,
-  closeWindow,
-  confirm,
-  createViewlet,
-  disableExtension,
-  dispose: dispose$2,
-  disposeEditor,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBadgeCounts,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon,
-  getFilePathElectron,
-  getFolderIcon,
-  getFolderSize,
-  getIcons,
-  getKeyBindings: getKeyBindings$1,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened,
-  getV8Version,
-  getViewletModuleId,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  handleModifiedStatusChange,
-  handleUriChange,
-  handleWorkspaceRefresh,
-  initializeEditorWorker,
-  initializeOpenerWorker,
-  initializeProcessExplorer: initializeProcessExplorer$1,
-  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,
-  sendMessagePortToProcessExplorer: sendMessagePortToProcessExplorer$1,
-  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 debugProcess = async (state, index = state.focusedIndex) => {
   const process = state.visibleProcesses[index];
@@ -2188,11 +1637,9 @@ const diff2 = uid => {
   return diff(oldState, scheduledState);
 };
 
-const processExplorerUpdateInterval = 1000;
-
 const intervals = new Map();
 const pending = new Set();
-const dispose$1 = uid => {
+const dispose$3 = uid => {
   const interval = intervals.get(uid);
   if (interval) {
     clearInterval(interval);
@@ -2202,7 +1649,7 @@ const dispose$1 = uid => {
 };
 const update = async uid => {
   if (!getKeys$1().includes(uid)) {
-    dispose$1(uid);
+    dispose$3(uid);
     return;
   }
   if (pending.has(uid)) {
@@ -2218,7 +1665,7 @@ const update = async uid => {
   }
 };
 const start = (uid, interval = processExplorerUpdateInterval) => {
-  if (interval === 0 || intervals.has(uid)) {
+  if (interval <= 0 || intervals.has(uid)) {
     return;
   }
   const intervalId = setInterval(() => {
@@ -2226,10 +1673,100 @@ const start = (uid, interval = processExplorerUpdateInterval) => {
   }, interval);
   intervals.set(uid, intervalId);
 };
+const restart = (uid, interval) => {
+  dispose$3(uid);
+  start(uid, interval);
+};
+
+const sendMessagePortToProcessExplorer = async port => {
+  await sendMessagePortToProcessExplorer$1(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 dispose = uid => {
-  dispose$1(uid);
+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) => {
+  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 dispose$2 = async () => {
+  const {
+    rpc
+  } = state$1;
+  state$1.rpc = undefined;
+  await rpc?.dispose();
+};
+
+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 dispose$1 = async () => {
+  state.initializedPlatform = 0;
+  await dispose$2();
+};
+
+const dispose = async uid => {
   dispose$3(uid);
+  dispose$4(uid);
+  if (getKeys$1().length === 0) {
+    await dispose$1();
+  }
+};
+
+const createE2eFixtureProcess = async (state, marker) => {
+  const pid = await invoke('Process.createE2eFixtureProcess', marker);
+  return {
+    ...state,
+    rootPid: pid
+  };
+};
+const disposeE2eFixtureProcess = async (_uid, pidOrMarker) => {
+  await invoke('Process.disposeE2eFixtureProcess', pidOrMarker);
 };
 
 const expandAll = state => {
@@ -2442,7 +1979,7 @@ const handleBlur = state => {
 };
 
 const handleClickAt = (state, index) => {
-  return focusIndex(state, index);
+  return focusIndex(state, Number(index));
 };
 
 const show2 = async (uid, menuId, x, y, args) => {
@@ -2450,25 +1987,26 @@ const show2 = async (uid, menuId, x, y, args) => {
 };
 
 const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0) => {
-  const process = state.visibleProcesses[index];
+  const numericIndex = Number(index);
+  const process = state.visibleProcesses[numericIndex];
   if (!process) {
     return state;
   }
   const newState = {
     ...state,
     focused: false,
-    focusedIndex: index
+    focusedIndex: numericIndex
   };
-  set$a(state.uid, state, newState);
+  set$6(state.uid, state, newState);
   await show2(state.uid, ProcessExplorer$1, x, y, {
-    index,
+    index: numericIndex,
     menuId: ProcessExplorer$1
   });
   return newState;
 };
 
 const handleDoubleClick = (state, index = state.focusedIndex) => {
-  return toggleIndex(state, index);
+  return toggleIndex(state, Number(index));
 };
 
 const handleFocus = state => {
@@ -2478,22 +2016,15 @@ const handleFocus = state => {
   };
 };
 
-const SigTerm = 'SIGTERM';
-
 const killProcess = async (state, index = state.focusedIndex) => {
   const process = state.visibleProcesses[index];
   if (!process) {
     return state;
   }
-  await invoke$1('Process.kill', process.pid, SigTerm);
+  await invoke('Process.kill', process.pid);
   return state;
 };
 
-const WindowPid = -1;
-const QueryOrHashRegex = /[?#]/;
-const isValidMemoryValue = value => {
-  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
-};
 const getMeasureMemory = () => {
   const {
     measureUserAgentSpecificMemory
@@ -2503,6 +2034,12 @@ const getMeasureMemory = () => {
   }
   return measureUserAgentSpecificMemory.bind(performance);
 };
+
+const isValidMemoryValue = value => {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+};
+
+const QueryOrHashRegex = /[?#]/;
 const getUrlName = url => {
   if (!url || url === 'cross-origin-url') {
     return url;
@@ -2517,6 +2054,7 @@ const getUrlName = url => {
     return parts.at(-1) || url;
   }
 };
+
 const getAttributionName = attribution => {
   const scope = attribution.scope || 'memory';
   const url = attribution.url ? getUrlName(attribution.url) : '';
@@ -2525,6 +2063,7 @@ const getAttributionName = attribution => {
   }
   return scope;
 };
+
 const getBreakdownName = (entry, index) => {
   if (entry.attribution && entry.attribution.length > 0) {
     return entry.attribution.map(getAttributionName).join(', ');
@@ -2534,6 +2073,9 @@ const getBreakdownName = (entry, index) => {
   }
   return `breakdown ${index + 1}`;
 };
+
+const WindowPid = -1;
+
 const toBreakdownProcess = (entry, index) => {
   const name = getBreakdownName(entry, index);
   return {
@@ -2545,6 +2087,7 @@ const toBreakdownProcess = (entry, index) => {
     synthetic: true
   };
 };
+
 const getFrontendMemoryUsage = async rootPid => {
   const measureMemory = getMeasureMemory();
   if (!measureMemory) {
@@ -2570,68 +2113,6 @@ const getFrontendMemoryUsage = async rootPid => {
   }
 };
 
-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) => {
-  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 getErrorMessage = error => {
   if (error instanceof Error) {
     return error.message;
@@ -2663,9 +2144,9 @@ const refresh = async state => {
   try {
     await initializeProcessExplorer(state.platform);
     const includeElectronData = state.platform === Electron;
-    const rootPid = state.rootPid || (await invoke('ProcessId.getMainProcessId', {
+    const rootPid = state.rootPid === -1 ? await invoke('ProcessId.getMainProcessId', {
       includeElectronData
-    }));
+    }) : state.rootPid;
     const processes = await invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, includeElectronData);
     const frontendMemoryProcesses = state.includeFrontendMemoryUsage ? await getFrontendMemoryUsage(rootPid) : [];
     const allProcesses = [...processes, ...frontendMemoryProcesses];
@@ -2699,7 +2180,7 @@ const hasError$1 = state => {
 const loadContent = async state => {
   const newState = await refresh(state);
   if (!hasError$1(newState)) {
-    start(newState.uid);
+    start(newState.uid, newState.updateInterval);
   }
   return {
     error: undefined,
@@ -3045,9 +2526,6 @@ const getPaddingLeft = process => {
     return '0';
   }
   const depthCh = (process.depth - 1) * 1.5;
-  if (process.flags === None$2) {
-    return `calc(${depthCh}ch + 17px)`;
-  }
   return `${depthCh}ch`;
 };
 const getAriaExpanded = process => {
@@ -3064,6 +2542,7 @@ const getCellDom = (className, value, index, paddingLeft) => {
   return [{
     childCount: 1,
     className,
+    'data-index': index,
     name: String(index),
     paddingLeft,
     role: GridCell,
@@ -3217,7 +2696,7 @@ const render2 = (uid, diffResult) => {
     oldState,
     scheduledState
   } = get$2(uid);
-  set$a(uid, scheduledState, scheduledState);
+  set$6(uid, scheduledState, scheduledState);
   return applyRender(oldState, scheduledState, diffResult);
 };
 
@@ -3230,19 +2709,19 @@ const renderEventListeners = () => {
     params: ['handleBlur']
   }, {
     name: HandleClick,
-    params: ['handleClickAt', TargetName],
+    params: ['handleClickAt', 'event.target.dataset.index'],
     preventDefault: true
   }, {
     name: HandleDoubleClick,
-    params: ['handleDoubleClick', TargetName],
+    params: ['handleDoubleClick', 'event.target.dataset.index'],
     preventDefault: true
   }, {
     name: HandleContextMenu,
-    params: ['handleContextMenu', TargetName, ClientX, ClientY],
+    params: ['handleContextMenu', 'event.target.dataset.index', ClientX, ClientY],
     preventDefault: true
   }, {
     name: HandlePointerDown,
-    params: ['handleClickAt', TargetName]
+    params: ['handleClickAt', 'event.target.dataset.index']
   }];
 };
 
@@ -3289,12 +2768,29 @@ const setError = async (state, rawError) => {
   };
 };
 
+const setRootProcessId = (state, rootPid) => {
+  return {
+    ...state,
+    rootPid
+  };
+};
+
+const setUpdateInterval = (state, updateInterval) => {
+  restart(state.uid, updateInterval);
+  return {
+    ...state,
+    updateInterval
+  };
+};
+
 const commandMap = {
   'ProcessExplorer.collapseAll': wrapCommand(collapseAll),
   'ProcessExplorer.create': create$d,
+  'ProcessExplorer.createE2eFixtureProcess': wrapCommand(createE2eFixtureProcess),
   'ProcessExplorer.debugProcess': wrapCommand(debugProcess),
   'ProcessExplorer.diff2': diff2,
   'ProcessExplorer.dispose': dispose,
+  'ProcessExplorer.disposeE2eFixtureProcess': disposeE2eFixtureProcess,
   'ProcessExplorer.expandAll': wrapCommand(expandAll),
   'ProcessExplorer.focusFirst': wrapCommand(focusFirst),
   'ProcessExplorer.focusLast': wrapCommand(focusLast),
@@ -3317,6 +2813,8 @@ const commandMap = {
   'ProcessExplorer.render2': render2,
   'ProcessExplorer.renderEventListeners': renderEventListeners,
   'ProcessExplorer.setError': wrapCommand(setError),
+  'ProcessExplorer.setRootProcessId': wrapCommand(setRootProcessId),
+  'ProcessExplorer.setUpdateInterval': wrapCommand(setUpdateInterval),
   'ProcessExplorer.terminate': terminate,
   'ProcessExplorer.update': wrapCommand(refresh)
 };
@@ -3339,7 +2837,7 @@ const createErrorWorkerRpc = async () => {
 
 const initializeErrorWorker = async () => {
   const rpc = await createErrorWorkerRpc();
-  set$7(rpc);
+  set$4(rpc);
 };
 
 const sendMessagePortToFileSystemWorker = async port => {

package/package.json

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