@lvce-editor/process-explorer-worker 3.12.0 → 3.13.0

package/index.js

@@ -235,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
@@ -289,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;
 };
 
@@ -944,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;
   }
@@ -975,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
@@ -1020,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
@@ -1230,280 +1247,6 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-const Two = '2.0';
-
-const create$a = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-
-const create$9 = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
-  };
-  return message;
-};
-
-let id = 0;
-const create$8 = () => {
-  return ++id;
-};
-
-const registerPromise = map => {
-  const id = create$8();
-  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$9(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-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 = {
-    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$a(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$7 = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
-};
-
-const create$6 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$7({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
-};
-
-const createSharedLazyRpc = factory => {
-  let rpcPromise;
-  const getOrCreate = () => {
-    if (!rpcPromise) {
-      rpcPromise = factory();
-    }
-    return rpcPromise;
-  };
-  return {
-    async dispose() {
-      const rpc = await getOrCreate();
-      await rpc.dispose();
-    },
-    async invoke(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invoke(method, ...params);
-    },
-    async invokeAndTransfer(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    async send(method, ...params) {
-      const rpc = await getOrCreate();
-      rpc.send(method, ...params);
-    }
-  };
-};
-
-const create$5 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  return createSharedLazyRpc(() => {
-    return create$6({
-      commandMap,
-      isMessagePortOpen,
-      send
-    });
-  });
-};
-
-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);
-  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);
-  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
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1525,7 +1268,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -1536,7 +1279,7 @@ const remove = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create = rpcId => {
+const create$a = rpcId => {
   return {
     async dispose() {
       const rpc = get(rpcId);
@@ -1558,7 +1301,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$5(rpcId, mockRpc);
+      set$6(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1567,7 +1310,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$5(rpcId, rpc);
+      set$6(rpcId, rpc);
     }
   };
 };
@@ -1764,6 +1507,7 @@ const Remote = 3;
 
 const ErrorWorker = 3308;
 const FileSystemWorker$1 = 209;
+const MainProcess = -5;
 const ProcessExplorerRenderer = 33;
 const RendererWorker = 1;
 
@@ -1776,27 +1520,33 @@ const Empty = 0;
 const FocusExplorer = 13;
 
 const {
-  invoke: invoke$2,
-  set: set$4
-} = create(ErrorWorker);
+  invoke: invoke$3,
+  set: set$5
+} = create$a(ErrorWorker);
 const prepare = async error => {
-  return invoke$2('Errors.prepare', error);
+  return invoke$3('Errors.prepare', error);
 };
 
 const {
-  set: set$3
-} = create(FileSystemWorker$1);
+  set: set$4
+} = create$a(FileSystemWorker$1);
 
 const FileSystemWorker = {
   __proto__: null,
-  set: set$3
+  set: set$4
 };
 
+const {
+  dispose: dispose$4,
+  invoke: invoke$2,
+  set: set$3
+} = create$a(MainProcess);
+
 const {
   invoke: invoke$1,
   invokeAndTransfer,
   set: set$2
-} = create(RendererWorker);
+} = create$a(RendererWorker);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
@@ -1808,116 +1558,464 @@ 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 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 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 debugProcess = async (state, index = state.focusedIndex) => {
-  const process = state.visibleProcesses[index];
-  if (!process) {
-    return state;
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
   }
-  await invoke$1('AttachDebugger.attachDebugger', process.pid);
-  return state;
 };
 
-const isEqual$1 = (oldState, newState) => {
-  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
+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 = (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 create$6 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  messagePort.start();
+  return rpc;
 };
 
-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 create$5 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$6({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
 
-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]);
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
     }
-  }
-  return diffResult;
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
 };
 
-const diff2 = uid => {
-  const {
-    oldState,
-    scheduledState
-  } = get$2(uid);
-  return diff(oldState, scheduledState);
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$5({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
 };
 
-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 Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
 };
-const update = async uid => {
-  if (!getKeys$1().includes(uid)) {
-    dispose$3(uid);
-    return;
-  }
-  if (pending.has(uid)) {
-    return;
-  }
-  pending.add(uid);
+
+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$3 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  let rawIpc;
   try {
-    await invoke$1('ProcessExplorer.update');
+    rawIpc = await IpcParentWithWebSocket$1.create({
+      webSocket
+    });
   } catch (error) {
-    console.error(error);
-  } finally {
-    pending.delete(uid);
+    throw new VError(error, 'Failed to create rpc connection');
   }
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
 };
-const start = (uid, interval = processExplorerUpdateInterval) => {
-  if (interval <= 0 || intervals.has(uid)) {
-    return;
+
+const create$2 = async ({
+  commandMap,
+  onClose,
+  type
+}) => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl(type, host, protocol);
+  const webSocket = new WebSocket(wsUrl);
+  if (onClose) {
+    webSocket.addEventListener('close', onClose, {
+      once: true
+    });
   }
-  const intervalId = setInterval(() => {
-    void update(uid);
-  }, interval);
-  intervals.set(uid, intervalId);
+  const rpc = await create$3({
+    commandMap,
+    webSocket
+  });
+  return rpc;
 };
-const restart = (uid, interval) => {
-  dispose$3(uid);
-  start(uid, interval);
+
+const create$1 = async ({
+  commandMap,
+  onClose,
+  type
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$2({
+      commandMap,
+      onClose,
+      type
+    });
+  });
+};
+
+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$1(ipc);
+  return rpc;
 };
 
 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: sendMessagePortToMainProcess
-    });
-    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 commandNotFoundRegex = /command not found|not found/i;
+const launchProcessExplorerNode = async onClose => {
   try {
-    const rpc = await create$2({
+    try {
+      const {
+        protocols,
+        url
+      } = await invoke$1('WebSocketCapability.create', 'process-explorer');
+      const webSocket = new WebSocket(url, protocols);
+      webSocket.addEventListener('close', onClose);
+      return await create$3({
+        commandMap: {},
+        webSocket
+      });
+    } catch (error) {
+      if (!(error instanceof Error && (error.message.includes('WebSocketCapability.create') || error.message.includes('module WebSocketCapability not found')) && commandNotFoundRegex.test(error.message))) {
+        throw error;
+      }
+    }
+    const rpc = await create$1({
       commandMap: {},
+      onClose,
       type: 'process-explorer'
     });
     return rpc;
@@ -1938,6 +2036,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
@@ -1949,30 +2050,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();
   }
@@ -2217,7 +2336,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
@@ -2241,7 +2360,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;
 };
 
@@ -2360,6 +2485,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);
@@ -2367,7 +2499,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);
@@ -2760,6 +2892,12 @@ const headerCellNode = {
   className: HeaderCell,
   type: Th
 };
+const processExplorer = {
+  childCount: 1,
+  className: mergeClassNames(Viewlet, ProcessExplorer),
+  role: None,
+  type: Div
+};
 const getRowClassName = focused => {
   if (focused) {
     return mergeClassNames(Row, RowFocused);
@@ -2851,12 +2989,7 @@ const getErrorDom = state => {
   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: mergeClassNames(Viewlet, ProcessExplorer),
-    role: None,
-    type: Div
-  }, {
+  return [processExplorer, {
     childCount,
     className: Error$1,
     type: Div
@@ -2866,12 +2999,7 @@ const getTableDom = state => {
   const {
     visibleProcesses
   } = state;
-  return [{
-    childCount: 1,
-    className: mergeClassNames(Viewlet, ProcessExplorer),
-    role: None,
-    type: Div
-  }, {
+  return [processExplorer, {
     ariaLabel: 'Process Explorer',
     ariaRowCount: visibleProcesses.length + 1,
     childCount: 2,
@@ -2942,7 +3070,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);
 };
 
@@ -2971,6 +3099,10 @@ const renderEventListeners = () => {
   }];
 };
 
+const rerender = state => {
+  return state;
+};
+
 const isRawError = value => {
   return Boolean(value && typeof value === 'object');
 };
@@ -3058,6 +3190,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),
@@ -3071,7 +3204,7 @@ const sendMessagePortToErrorWorker = async port => {
 
 const createErrorWorkerRpc = async () => {
   try {
-    const rpc = await create$5({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToErrorWorker
     });
@@ -3083,7 +3216,7 @@ const createErrorWorkerRpc = async () => {
 
 const initializeErrorWorker = async () => {
   const rpc = await createErrorWorkerRpc();
-  set$4(rpc);
+  set$5(rpc);
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
@@ -3092,7 +3225,7 @@ const sendMessagePortToFileSystemWorker = async port => {
 
 const createFileSystemWorkerRpc = async () => {
   try {
-    const rpc = await create$5({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToFileSystemWorker
     });
@@ -3112,7 +3245,7 @@ const initializeFileSystemWorker = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await create$1({
+  const rpc = await create({
     commandMap: commandMap
   });
   set$2(rpc);

package/package.json

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