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

package/index.js

@@ -3,8 +3,28 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$e = () => {
+  const generations = Object.create(null);
   const states = Object.create(null);
   const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
   return {
     clear() {
       for (const key of Object.keys(states)) {
@@ -43,14 +63,39 @@ const create$e = () => {
       Object.assign(commandMapRef, commandMap);
     },
     set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
         oldState,
         scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        let latestState = states[uid].newState;
+        const context = {
+          getState: () => {
+            if (isCurrentGeneration(uid, generation)) {
+              latestState = states[uid].newState;
+            }
+            return latestState;
+          },
+          updateState: async updater => {
+            latestState = await updateState(uid, generation, latestState, updater);
+            return latestState;
+          }
+        };
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -59,6 +104,9 @@ const create$e = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -83,6 +131,7 @@ const create$e = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -97,6 +146,11 @@ const create$e = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -181,12 +235,12 @@ const collapseAll = state => {
 };
 
 const {
-  dispose: dispose$4,
+  dispose: dispose$5,
   get: get$2,
   getCommandIds,
   getKeys: getKeys$1,
   registerCommands,
-  set: set$6,
+  set: set$7,
   wrapCommand,
   wrapGetter,
   wrapLoadContent
@@ -235,7 +289,7 @@ const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0,
     x,
     y
   };
-  set$6(state.uid, state, state);
+  set$7(state.uid, state, state);
   return state;
 };
 
@@ -380,7 +434,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -534,7 +587,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -884,7 +944,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -915,31 +978,45 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
 const restoreExistingError = (error, currentStack) => {
   if (typeof error.stack === 'string') {
-    error.stack = error.stack + NewLine + currentStack;
+    setStack(error, `${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;
+  setStack(restoredError, `${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;
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
     return;
   }
   if (error.data.stack) {
-    restoredError.stack = error.data.stack;
+    setStack(restoredError, error.data.stack);
   }
 };
 const applyDataProperties = (restoredError, error) => {
-  if (!error.data) {
-    return;
-  }
   restoreStackFromData(restoredError, error, getCurrentStack());
   if (error.data.codeFrame) {
     // @ts-ignore
@@ -960,7 +1037,7 @@ const applyDirectProperties = (restoredError, error) => {
     const indexNewLine = getNewLineIndex(lowerStack);
     const parentStack = getParentStack(error);
     // @ts-ignore
-    restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
   }
   if (error.codeFrame) {
     // @ts-ignore
@@ -1170,128 +1247,564 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-const Two = '2.0';
-
-const create$a = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
   };
-};
-
-const create$9 = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
   };
-  return message;
+  return mockRpc;
 };
 
-let id = 0;
-const create$8 = () => {
-  return ++id;
+const rpcs = Object.create(null);
+const set$6 = (id, rpc) => {
+  rpcs[id] = rpc;
 };
-
-const registerPromise = map => {
-  const id = create$8();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  map[id] = resolve;
-  return {
-    id,
-    promise
-  };
+const get = id => {
+  return rpcs[id];
 };
-
-const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
-  const {
-    id,
-    promise
-  } = registerPromise(callbacks);
-  const message = create$9(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
+const remove = id => {
+  delete rpcs[id];
 };
-const createRpc = ipc => {
-  const callbacks = Object.create(null);
-  ipc._resolve = (id, response) => {
-    const fn = callbacks[id];
-    if (!fn) {
-      console.warn(`callback ${id} may already be disposed`);
-      return;
-    }
-    fn(response);
-    delete callbacks[id];
-  };
-  const rpc = {
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$a = rpcId => {
+  return {
     async dispose() {
-      await ipc?.dispose();
+      const rpc = get(rpcId);
+      await rpc.dispose();
     },
+    // @ts-ignore
     invoke(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, false);
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
     },
+    // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, true);
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
     },
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      const message = create$a(method, params);
-      ipc.send(message);
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$6(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$6(rpcId, rpc);
     }
   };
-  return rpc;
 };
 
-const requiresSocket = () => {
-  return false;
+const Audio = 0;
+const Button = 1;
+const Col = 2;
+const ColGroup = 3;
+const Div = 4;
+const H1 = 5;
+const Input = 6;
+const Kbd = 7;
+const Span = 8;
+const Table$1 = 9;
+const TBody = 10;
+const Td = 11;
+const Text = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const I = 16;
+const Img = 17;
+const Root = 0;
+const Ins = 20;
+const Del = 21;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Search = 42;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
+const Li = 48;
+const Ol = 49;
+const P = 50;
+const Pre = 51;
+const A = 53;
+const Abbr = 54;
+const Br = 55;
+const Cite = 56;
+const Data = 57;
+const Time = 58;
+const Tfoot = 59;
+const Ul = 60;
+const Video = 61;
+const TextArea = 62;
+const Select = 63;
+const Option = 64;
+const Code = 65;
+const Label = 66;
+const Dt = 67;
+const Iframe = 68;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
+const Style = 72;
+const Html = 73;
+const Head = 74;
+const Title = 75;
+const Meta = 76;
+const Canvas = 77;
+const Form = 78;
+const BlockQuote = 79;
+const Quote = 80;
+const Circle = 81;
+const Defs = 82;
+const Ellipse = 83;
+const G = 84;
+const Line = 85;
+const Path = 86;
+const Polygon = 87;
+const Polyline = 88;
+const Rect = 89;
+const Svg = 90;
+const Use = 91;
+const Reference = 100;
+
+const VirtualDomElements = {
+  __proto__: null,
+  A,
+  Abbr,
+  Article,
+  Aside,
+  Audio,
+  BlockQuote,
+  Br,
+  Button,
+  Canvas,
+  Circle,
+  Cite,
+  Code,
+  Col,
+  ColGroup,
+  Data,
+  Dd,
+  Defs,
+  Del,
+  Div,
+  Dl,
+  Dt,
+  Ellipse,
+  Em,
+  Figcaption,
+  Figure,
+  Footer,
+  Form,
+  G,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Head,
+  Header,
+  Hr,
+  Html,
+  I,
+  Iframe,
+  Img,
+  Input,
+  Ins,
+  Kbd,
+  Label,
+  Li,
+  Line,
+  Main,
+  Meta,
+  Nav,
+  Ol,
+  Option,
+  P,
+  Path,
+  Polygon,
+  Polyline,
+  Pre,
+  Quote,
+  Rect,
+  Reference,
+  Root,
+  Search,
+  Section,
+  Select,
+  Span,
+  Strong,
+  Style,
+  Svg,
+  TBody,
+  THead,
+  Table: Table$1,
+  Td,
+  Text,
+  TextArea,
+  Tfoot,
+  Th,
+  Time,
+  Title,
+  Tr,
+  Ul,
+  Use,
+  Video
 };
-const preparePrettyError = error => {
-  return error;
+
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+
+const Enter = 3;
+const Space = 9;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+const ContextMenu = 56;
+const Star = 131;
+
+const CtrlCmd = 1 << 11 >>> 0;
+
+const None$1 = 0;
+
+const Electron = 2;
+const Remote = 3;
+
+const ErrorWorker = 3308;
+const FileSystemWorker$1 = 209;
+const MainProcess = -5;
+const ProcessExplorerRenderer = 33;
+const RendererWorker = 1;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetPatches = 'Viewlet.setPatches';
+
+const Empty = 0;
+const FocusExplorer = 13;
+
+const {
+  invoke: invoke$3,
+  set: set$5
+} = create$a(ErrorWorker);
+const prepare = async error => {
+  return invoke$3('Errors.prepare', error);
 };
-const logError = () => {
-  // handled by renderer worker
+
+const {
+  set: set$4
+} = create$a(FileSystemWorker$1);
+
+const FileSystemWorker = {
+  __proto__: null,
+  set: set$4
 };
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+
+const {
+  dispose: dispose$4,
+  invoke: invoke$2,
+  set: set$3
+} = create$a(MainProcess);
+
+const {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$2
+} = create$a(RendererWorker);
+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 sendMessagePortToErrorWorker$1 = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const sendMessagePortToProcessExplorer$1 = async port => {
+  const command = 'ProcessExplorer.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToProcessExplorer', port, command, 0);
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
+const debugProcess = async (state, index = state.focusedIndex) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
   }
+  await invoke$1('AttachDebugger.attachDebugger', process.pid);
+  return state;
 };
 
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
 };
 
-const create$7 = async ({
-  commandMap,
-  isMessagePortOpen = true,
+const isEqual = (oldState, newState) => {
+  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.focusedIndex === newState.focusedIndex && oldState.visibleProcesses === newState.visibleProcesses;
+};
+
+const RenderItems = 1;
+const RenderFocus = 2;
+const RenderFocusContext = 3;
+const RenderIncremental = 4;
+
+const modules = [isEqual, isEqual$1, isEqual$1];
+const numbers = [RenderIncremental, RenderFocus, RenderFocusContext];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    oldState,
+    scheduledState
+  } = get$2(uid);
+  return diff(oldState, scheduledState);
+};
+
+const intervals = new Map();
+const pending = new Set();
+const dispose$3 = uid => {
+  const interval = intervals.get(uid);
+  if (interval) {
+    clearInterval(interval);
+    intervals.delete(uid);
+  }
+  pending.delete(uid);
+};
+const update = async uid => {
+  if (!getKeys$1().includes(uid)) {
+    dispose$3(uid);
+    return;
+  }
+  if (pending.has(uid)) {
+    return;
+  }
+  pending.add(uid);
+  try {
+    await invoke$1('ProcessExplorer.update');
+  } catch (error) {
+    console.error(error);
+  } finally {
+    pending.delete(uid);
+  }
+};
+const start = (uid, interval = processExplorerUpdateInterval) => {
+  if (interval <= 0 || intervals.has(uid)) {
+    return;
+  }
+  const intervalId = setInterval(() => {
+    void update(uid);
+  }, interval);
+  intervals.set(uid, intervalId);
+};
+const restart = (uid, interval) => {
+  dispose$3(uid);
+  start(uid, interval);
+};
+
+const processExplorerRpcClosedMessage = 'Process explorer RPC connection was closed';
+const toProcessExplorerRpcClosedState = state => {
+  return {
+    ...state,
+    errorCodeFrame: '',
+    errorMessage: processExplorerRpcClosedMessage,
+    errorStack: '',
+    initial: false
+  };
+};
+const handleProcessExplorerRpcClose = async () => {
+  let didUpdate = false;
+  for (const uid of getKeys$1()) {
+    const viewletState = get$2(uid);
+    if (!viewletState) {
+      continue;
+    }
+    dispose$3(uid);
+    const {
+      oldState,
+      scheduledState
+    } = viewletState;
+    const newState = toProcessExplorerRpcClosedState(scheduledState);
+    set$7(uid, oldState, newState);
+    didUpdate = true;
+  }
+  if (didUpdate) {
+    await invoke$1('ProcessExplorer.rerender');
+  }
+};
+
+const Two = '2.0';
+
+const create$9 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$8 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$7 = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$7();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$8(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc$1 = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$9(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
+};
+
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const create$6 = async ({
+  commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1302,12 +1815,12 @@ const create$7 = async ({
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   messagePort.start();
   return rpc;
 };
 
-const create$6 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1317,7 +1830,7 @@ const create$6 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$7({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
@@ -1352,13 +1865,13 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$5 = async ({
+const create$4 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$6({
+    return create$5({
       commandMap,
       isMessagePortOpen,
       send
@@ -1386,318 +1899,106 @@ const getProtocol = () => {
   return location.protocol;
 };
 
-const create$4 = async ({
+const create$3 = async ({
   commandMap,
   webSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const rawIpc = await IpcParentWithWebSocket$1.create({
-    webSocket
-  });
+  let rawIpc;
+  try {
+    rawIpc = await IpcParentWithWebSocket$1.create({
+      webSocket
+    });
+  } catch (error) {
+    throw new VError(error, 'Failed to create rpc connection');
+  }
   const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   return rpc;
 };
 
-const create$3 = async ({
+const create$2 = async ({
   commandMap,
+  onClose,
   type
 }) => {
   const host = getHost();
   const protocol = getProtocol();
   const wsUrl = getWebSocketUrl(type, host, protocol);
   const webSocket = new WebSocket(wsUrl);
-  const rpc = await create$4({
+  if (onClose) {
+    webSocket.addEventListener('close', onClose, {
+      once: true
+    });
+  }
+  const rpc = await create$3({
     commandMap,
     webSocket
   });
   return rpc;
 };
 
-const create$2 = async ({
+const create$1 = async ({
   commandMap,
+  onClose,
   type
 }) => {
   return createSharedLazyRpc(() => {
-    return create$3({
+    return create$2({
       commandMap,
+      onClose,
       type
     });
   });
 };
 
-const create$1 = async ({
+const create = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   return rpc;
 };
 
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invocations,
-    invoke,
-    invokeAndTransfer: invoke
-  };
-  return mockRpc;
-};
-
-const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get = id => {
-  return rpcs[id];
-};
-const remove = id => {
-  delete rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create = rpcId => {
-  return {
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    },
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    registerMockRpc(commandMap) {
-      const mockRpc = createMockRpc({
-        commandMap
-      });
-      set$5(rpcId, mockRpc);
-      // @ts-ignore
-      mockRpc[Symbol.dispose] = () => {
-        remove(rpcId);
-      };
-      // @ts-ignore
-      return mockRpc;
-    },
-    set(rpc) {
-      set$5(rpcId, rpc);
-    }
-  };
-};
-
-const Div = 4;
-const Table$1 = 9;
-const TBody = 10;
-const Td = 11;
-const Text = 12;
-const Th = 13;
-const THead = 14;
-const Tr = 15;
-const Pre = 51;
-const Reference = 100;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-
-const Enter = 3;
-const Space = 9;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-const ContextMenu = 56;
-const Star = 131;
-
-const CtrlCmd = 1 << 11 >>> 0;
-
-const None$1 = 0;
-
-const Electron = 2;
-const Remote = 3;
-
-const ErrorWorker = 3308;
-const FileSystemWorker$1 = 209;
-const RendererWorker = 1;
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetDom2 = 'Viewlet.setDom2';
-const SetFocusContext = 'Viewlet.setFocusContext';
-const SetPatches = 'Viewlet.setPatches';
-
-const Empty = 0;
-const FocusExplorer = 13;
-
-const {
-  invoke: invoke$2,
-  set: set$4
-} = create(ErrorWorker);
-const prepare = async error => {
-  return invoke$2('Errors.prepare', error);
-};
-
-const {
-  set: set$3
-} = create(FileSystemWorker$1);
-
-const FileSystemWorker = {
-  __proto__: null,
-  set: set$3
-};
-
-const {
-  invoke: invoke$1,
-  invokeAndTransfer,
-  set: set$2
-} = create(RendererWorker);
-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 sendMessagePortToErrorWorker$1 = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const sendMessagePortToProcessExplorer$1 = async port => {
-  const command = 'ProcessExplorer.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToProcessExplorer', port, command, 0);
-};
-
-const debugProcess = async (state, index = state.focusedIndex) => {
-  const process = state.visibleProcesses[index];
-  if (!process) {
-    return state;
-  }
-  await invoke$1('AttachDebugger.attachDebugger', process.pid);
-  return state;
-};
-
-const isEqual$1 = (oldState, newState) => {
-  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
-};
-
-const isEqual = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.focusedIndex === newState.focusedIndex && oldState.visibleProcesses === newState.visibleProcesses;
-};
-
-const RenderItems = 1;
-const RenderFocus = 2;
-const RenderFocusContext = 3;
-const RenderIncremental = 4;
-
-const modules = [isEqual, isEqual$1, isEqual$1];
-const numbers = [RenderIncremental, RenderFocus, RenderFocusContext];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
-  }
-  return diffResult;
-};
-
-const diff2 = uid => {
-  const {
-    oldState,
-    scheduledState
-  } = get$2(uid);
-  return diff(oldState, scheduledState);
-};
-
-const intervals = new Map();
-const pending = new Set();
-const dispose$3 = uid => {
-  const interval = intervals.get(uid);
-  if (interval) {
-    clearInterval(interval);
-    intervals.delete(uid);
-  }
-  pending.delete(uid);
-};
-const update = async uid => {
-  if (!getKeys$1().includes(uid)) {
-    dispose$3(uid);
-    return;
-  }
-  if (pending.has(uid)) {
-    return;
-  }
-  pending.add(uid);
-  try {
-    await invoke$1('ProcessExplorer.update');
-  } catch (error) {
-    console.error(error);
-  } finally {
-    pending.delete(uid);
-  }
-};
-const start = (uid, interval = processExplorerUpdateInterval) => {
-  if (interval <= 0 || intervals.has(uid)) {
-    return;
-  }
-  const intervalId = setInterval(() => {
-    void update(uid);
-  }, interval);
-  intervals.set(uid, intervalId);
-};
-const restart = (uid, interval) => {
-  dispose$3(uid);
-  start(uid, interval);
+const sendMessagePortToMainProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToMainProcess.sendMessagePortToMainProcess', port, 'HandleElectronMessagePort.handleElectronMessagePort', ProcessExplorerRenderer);
 };
 
 const sendMessagePortToProcessExplorer = async port => {
   await sendMessagePortToProcessExplorer$1(port);
 };
 
+const createRpc = async send => {
+  return create$4({
+    commandMap: {},
+    send
+  });
+};
 const launchProcessExplorerElectron = async () => {
+  let processExplorerRpc;
   try {
-    const rpc = await create$5({
-      commandMap: {},
-      send: sendMessagePortToProcessExplorer
-    });
-    return rpc;
+    processExplorerRpc = await createRpc(sendMessagePortToProcessExplorer);
+    const mainProcessRpc = await createRpc(sendMessagePortToMainProcess);
+    return {
+      mainProcessRpc,
+      processExplorerRpc
+    };
   } catch (error) {
-    throw new VError(error, 'Failed to create process explorer electron rpc');
+    await processExplorerRpc?.dispose();
+    throw new VError(error, 'Failed to create process explorer electron rpcs');
   }
 };
 
-const launchProcessExplorerNode = async () => {
+const launchProcessExplorerNode = async onClose => {
   try {
-    const rpc = await create$2({
+    const rpc = await create$1({
       commandMap: {},
+      onClose,
       type: 'process-explorer'
     });
     return rpc;
@@ -1718,6 +2019,9 @@ const invoke = async (method, ...params) => {
 const set$1 = newRpc => {
   state$1.rpc = newRpc;
 };
+const clear = () => {
+  state$1.rpc = undefined;
+};
 const dispose$2 = async () => {
   const {
     rpc
@@ -1729,30 +2033,48 @@ const dispose$2 = async () => {
 const state = {
   initializedPlatform: 0
 };
+const handleClose = async () => {
+  state.initializedPlatform = 0;
+  clear();
+  await handleProcessExplorerRpcClose();
+};
 const initializeProcessExplorer = async platform => {
   if (state.initializedPlatform === platform) {
     return;
   }
   if (platform === Electron) {
-    const rpc = await launchProcessExplorerElectron();
-    set$1(rpc);
+    const {
+      mainProcessRpc,
+      processExplorerRpc
+    } = await launchProcessExplorerElectron();
+    set$3(mainProcessRpc);
+    set$1(processExplorerRpc);
     state.initializedPlatform = platform;
     return;
   }
   if (platform === Remote) {
-    const rpc = await launchProcessExplorerNode();
+    const rpc = await launchProcessExplorerNode(() => {
+      void handleClose();
+    });
     set$1(rpc);
     state.initializedPlatform = platform;
   }
 };
 const dispose$1 = async () => {
+  const {
+    initializedPlatform
+  } = state;
   state.initializedPlatform = 0;
+  if (initializedPlatform === Electron) {
+    await Promise.all([dispose$4(), dispose$2()]);
+    return;
+  }
   await dispose$2();
 };
 
 const dispose = async uid => {
   dispose$3(uid);
-  dispose$4(uid);
+  dispose$5(uid);
   if (getKeys$1().length === 0) {
     await dispose$1();
   }
@@ -1997,7 +2319,7 @@ const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0
     focused: false,
     focusedIndex: numericIndex
   };
-  set$6(state.uid, state, newState);
+  set$7(state.uid, state, newState);
   await show2(state.uid, ProcessExplorer$1, x, y, {
     index: numericIndex,
     menuId: ProcessExplorer$1
@@ -2021,7 +2343,13 @@ const killProcess = async (state, index = state.focusedIndex) => {
   if (!process) {
     return state;
   }
-  await invoke('Process.kill', process.pid);
+  const killPromise = invoke('Process.kill', process.pid);
+  if (process.name === 'process-explorer') {
+    dispose$3(state.uid);
+    void killPromise.catch(() => {});
+    return toProcessExplorerRpcClosedState(state);
+  }
+  await killPromise;
   return state;
 };
 
@@ -2140,6 +2468,13 @@ const getFocusedIndex = (oldFocusedIndex, visibleProcesses) => {
   }
   return Math.min(oldFocusedIndex, visibleProcesses.length - 1);
 };
+const listProcesses = async (rootPid, platform) => {
+  if (platform === Electron) {
+    const pidMap = await invoke$2('CreatePidMap.createPidMap');
+    return invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false, pidMap);
+  }
+  return invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false);
+};
 const refresh = async state => {
   try {
     await initializeProcessExplorer(state.platform);
@@ -2147,7 +2482,7 @@ const refresh = async state => {
     const rootPid = state.rootPid === -1 ? await invoke('ProcessId.getMainProcessId', {
       includeElectronData
     }) : state.rootPid;
-    const processes = await invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, includeElectronData);
+    const processes = await listProcesses(rootPid, state.platform);
     const frontendMemoryProcesses = state.includeFrontendMemoryUsage ? await getFrontendMemoryUsage(rootPid) : [];
     const allProcesses = [...processes, ...frontendMemoryProcesses];
     const visibleProcesses = getVisibleProcesses(allProcesses, state.collapsedPids, rootPid);
@@ -2205,6 +2540,10 @@ const renderFocusContext = (oldState, newState) => {
   return [SetFocusContext, newState.uid, newState.focused ? FocusExplorer : Empty];
 };
 
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
 const text = data => {
   return {
     childCount: 0,
@@ -2213,6 +2552,8 @@ const text = data => {
   };
 };
 
+new Set(Object.values(VirtualDomElements));
+
 const SetText = 1;
 const Replace = 2;
 const SetAttribute = 3;
@@ -2515,9 +2856,28 @@ const formatMemory = memory => {
   return `${(memory / 1000 ** 4).toFixed(1)} TB`;
 };
 
+const Focusable = 0;
+
+const tableHeadNode = {
+  childCount: 1,
+  className: TableHead,
+  role: RowGroup,
+  type: THead
+};
+const headerRowNode = {
+  childCount: 3,
+  className: Row,
+  role: Row$1,
+  type: Tr
+};
+const headerCellNode = {
+  childCount: 1,
+  className: HeaderCell,
+  type: Th
+};
 const getRowClassName = focused => {
   if (focused) {
-    return `${Row} ${RowFocused}`;
+    return mergeClassNames(Row, RowFocused);
   }
   return Row;
 };
@@ -2551,25 +2911,10 @@ const getCellDom = (className, value, index, paddingLeft) => {
   }, text(value)];
 };
 const getHeaderDom = () => {
-  return [{
-    childCount: 1,
-    className: TableHead,
-    role: RowGroup,
-    type: THead
-  }, {
-    childCount: 3,
-    className: Row,
-    role: Row$1,
-    type: Tr
-  }, ...['Name', 'PID', 'Memory'].flatMap(label => [{
-    childCount: 1,
-    className: HeaderCell,
-    type: Th
-  }, text(label)])];
+  return [tableHeadNode, headerRowNode, ...['Name', 'PID', 'Memory'].flatMap(label => [headerCellNode, text(label)])];
 };
 const getRowDom = (process, index, focused) => {
   return [{
-    ariaDescription: '',
     ariaExpanded: getAriaExpanded(process),
     ariaLevel: process.depth,
     childCount: 3,
@@ -2580,7 +2925,7 @@ const getRowDom = (process, index, focused) => {
     tabIndex: focused ? 0 : -1,
     title: process.cmd,
     type: Tr
-  }, ...getCellDom(`${Cell} ${NameCell}`, process.name, index, getPaddingLeft(process)), ...getCellDom(Cell, String(process.pid), index), ...getCellDom(Cell, formatMemory(process.memory), index)];
+  }, ...getCellDom(mergeClassNames(Cell, NameCell), process.name, index, getPaddingLeft(process)), ...getCellDom(Cell, String(process.pid), index), ...getCellDom(Cell, formatMemory(process.memory), index)];
 };
 const getBodyDom = state => {
   const {
@@ -2604,16 +2949,26 @@ const getErrorSectionDom = (value, type) => {
   }, text(value)];
 };
 const hasError = state => {
-  return Boolean(state.errorMessage || state.errorCodeFrame || state.errorStack);
+  const {
+    errorCodeFrame,
+    errorMessage,
+    errorStack
+  } = state;
+  return Boolean(errorMessage || errorCodeFrame || errorStack);
 };
 const getErrorDom = state => {
-  const messageDom = getErrorSectionDom(state.errorMessage, Div);
-  const codeFrameDom = getErrorSectionDom(state.errorCodeFrame, Pre);
-  const stackDom = getErrorSectionDom(state.errorStack, Pre);
+  const {
+    errorCodeFrame,
+    errorMessage,
+    errorStack
+  } = state;
+  const messageDom = getErrorSectionDom(errorMessage, Div);
+  const codeFrameDom = getErrorSectionDom(errorCodeFrame, Pre);
+  const stackDom = getErrorSectionDom(errorStack, Pre);
   const childCount = messageDom.length / 2 + codeFrameDom.length / 2 + stackDom.length / 2;
   return [{
     childCount: 1,
-    className: `${Viewlet} ${ProcessExplorer}`,
+    className: mergeClassNames(Viewlet, ProcessExplorer),
     role: None,
     type: Div
   }, {
@@ -2623,14 +2978,17 @@ const getErrorDom = state => {
   }, ...messageDom, ...codeFrameDom, ...stackDom];
 };
 const getTableDom = state => {
+  const {
+    visibleProcesses
+  } = state;
   return [{
     childCount: 1,
-    className: `${Viewlet} ${ProcessExplorer}`,
+    className: mergeClassNames(Viewlet, ProcessExplorer),
     role: None,
     type: Div
   }, {
     ariaLabel: 'Process Explorer',
-    ariaRowCount: state.visibleProcesses.length + 1,
+    ariaRowCount: visibleProcesses.length + 1,
     childCount: 2,
     className: Table,
     onBlur: HandleBlur,
@@ -2640,12 +2998,15 @@ const getTableDom = state => {
     onFocus: HandleFocus,
     onPointerDown: HandlePointerDown,
     role: Grid,
-    tabIndex: 0,
+    tabIndex: Focusable,
     type: Table$1
   }, ...getHeaderDom(), ...getBodyDom(state)];
 };
 const getDom = state => {
-  if (state.initial) {
+  const {
+    initial
+  } = state;
+  if (initial) {
     return [];
   }
   if (hasError(state)) {
@@ -2696,7 +3057,7 @@ const render2 = (uid, diffResult) => {
     oldState,
     scheduledState
   } = get$2(uid);
-  set$6(uid, scheduledState, scheduledState);
+  set$7(uid, scheduledState, scheduledState);
   return applyRender(oldState, scheduledState, diffResult);
 };
 
@@ -2725,6 +3086,10 @@ const renderEventListeners = () => {
   }];
 };
 
+const rerender = state => {
+  return state;
+};
+
 const isRawError = value => {
   return Boolean(value && typeof value === 'object');
 };
@@ -2812,6 +3177,7 @@ const commandMap = {
   'ProcessExplorer.refresh': wrapCommand(refresh),
   'ProcessExplorer.render2': render2,
   'ProcessExplorer.renderEventListeners': renderEventListeners,
+  'ProcessExplorer.rerender': wrapCommand(rerender),
   'ProcessExplorer.setError': wrapCommand(setError),
   'ProcessExplorer.setRootProcessId': wrapCommand(setRootProcessId),
   'ProcessExplorer.setUpdateInterval': wrapCommand(setUpdateInterval),
@@ -2825,7 +3191,7 @@ const sendMessagePortToErrorWorker = async port => {
 
 const createErrorWorkerRpc = async () => {
   try {
-    const rpc = await create$5({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToErrorWorker
     });
@@ -2837,7 +3203,7 @@ const createErrorWorkerRpc = async () => {
 
 const initializeErrorWorker = async () => {
   const rpc = await createErrorWorkerRpc();
-  set$4(rpc);
+  set$5(rpc);
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
@@ -2846,7 +3212,7 @@ const sendMessagePortToFileSystemWorker = async port => {
 
 const createFileSystemWorkerRpc = async () => {
   try {
-    const rpc = await create$5({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToFileSystemWorker
     });
@@ -2866,7 +3232,7 @@ const initializeFileSystemWorker = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await create$1({
+  const rpc = await create({
     commandMap: commandMap
   });
   set$2(rpc);