@lvce-editor/static-server 0.113.11 → 0.113.13

package/static/{55af9e7 → edd8259}/packages/process-explorer-worker/index.js

@@ -3,9 +3,11 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$e = () => {
+  const commandQueues = new Map();
   const generations = Object.create(null);
   const states = Object.create(null);
-  const commandMapRef = {};
+  const commandMapRef = Object.create(null);
+  const commandsById = Object.create(null);
   const getGeneration = uid => generations[uid] || 0;
   const isCurrentGeneration = (uid, generation) => {
     return states[uid] !== undefined && getGeneration(uid) === generation;
@@ -25,12 +27,60 @@ const create$e = () => {
     }
     return Promise.resolve(updatedState);
   };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
     },
+    createDirectEventCommandMap(requestRender) {
+      return {
+        async 'Viewlet.executeViewletCommand'(uid, command, ...args) {
+          const fn = commandsById[command];
+          if (!fn) {
+            throw new Error(`Viewlet command not found: ${command}`);
+          }
+          await fn(uid, ...args);
+          await requestRender(uid);
+        }
+      };
+    },
     diff(uid, modules, numbers) {
       const {
         oldState,
@@ -46,6 +96,7 @@ const create$e = () => {
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -61,6 +112,9 @@ const create$e = () => {
     },
     registerCommands(commandMap) {
       Object.assign(commandMapRef, commandMap);
+      for (const [key, fn] of Object.entries(commandMap)) {
+        commandsById[toCommandId(key)] = fn;
+      }
     },
     set(uid, oldState, newState, scheduledState) {
       const current = states[uid];
@@ -76,19 +130,7 @@ const create$e = () => {
     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;
-          }
-        };
+        const context = createAsyncCommandContext(uid, generation);
         await fn(context, ...args);
       };
       return wrapped;
@@ -166,6 +208,51 @@ const create$e = () => {
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -288,6 +375,7 @@ const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0,
     height,
     includeFrontendMemoryUsage: getIncludeFrontendMemoryUsage(args),
     initial: true,
+    message: '',
     parentUid,
     platform,
     processes: [],
@@ -1257,581 +1345,615 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-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
+const Two = '2.0';
+
+const create$a = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
   };
-  return mockRpc;
 };
 
-const rpcs = Object.create(null);
-const set$9 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get = id => {
-  return rpcs[id];
+const create$9 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
 };
-const remove = id => {
-  delete rpcs[id];
+
+let id = 0;
+const create$8 = () => {
+  return ++id;
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$a = rpcId => {
+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$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() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
+      await ipc?.dispose();
     },
-    // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
+      return invokeHelper(callbacks, ipc, method, params, false);
     },
-    // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    registerMockRpc(commandMap) {
-      const mockRpc = createMockRpc({
-        commandMap
-      });
-      set$9(rpcId, mockRpc);
-      // @ts-ignore
-      mockRpc[Symbol.dispose] = () => {
-        remove(rpcId);
-      };
-      // @ts-ignore
-      return mockRpc;
+      return invokeHelper(callbacks, ipc, method, params, true);
     },
-    set(rpc) {
-      set$9(rpcId, rpc);
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$a(method, params);
+      ipc.send(message);
     }
   };
+  return 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 MainProcess = -5;
-const ProcessExplorerRenderer = 33;
-const RendererProcess = 1670;
-const RendererWorker = 1;
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetCss = 'Viewlet.setCss';
-const SetDom2 = 'Viewlet.setDom2';
-const SetFocusContext = 'Viewlet.setFocusContext';
-const SetPatches = 'Viewlet.setPatches';
-
-const Empty = 0;
-const FocusExplorer = 13;
-
-const {
-  invoke: invoke$6,
-  set: set$8
-} = create$a(ErrorWorker);
-const prepare = async error => {
-  return invoke$6('Errors.prepare', error);
-};
-
-const {
-  set: set$7
-} = create$a(FileSystemWorker$1);
-
-const FileSystemWorker = {
-  __proto__: null,
-  set: set$7
+const requiresSocket = () => {
+  return false;
 };
-
-const {
-  dispose: dispose$5,
-  invoke: invoke$5,
-  set: set$6
-} = create$a(MainProcess);
-
-const {
-  invoke: invoke$4,
-  set: set$5
-} = create$a(RendererProcess);
-
-const {
-  invoke: invoke$3,
-  invokeAndTransfer,
-  set: set$4
-} = create$a(RendererWorker);
-const showContextMenu2 = async (uid, menuId, x, y, args) => {
-  number(uid);
-  number(menuId);
-  number(x);
-  number(y);
-  await invoke$3('ContextMenu.show2', uid, menuId, x, y, args);
+const preparePrettyError = error => {
+  return error;
 };
-const sendMessagePortToErrorWorker$1 = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+const logError = () => {
+  // handled by renderer worker
 };
-const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+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 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;
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
   }
-  await invoke$3('AttachDebugger.attachDebugger', process.pid);
-  return state;
+  const ipc = module.wrap(rawIpc);
+  return ipc;
 };
 
-const isEqual$2 = (oldState, newState) => {
-  return oldState.visibleProcesses === newState.visibleProcesses;
+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 isEqual$1 = (oldState, newState) => {
-  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
+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$1(ipc);
+  messagePort.start();
+  return rpc;
 };
 
-const isEqual = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.errorCode === newState.errorCode && 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,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$7({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
 };
 
-const RenderItems = 1;
-const RenderFocus = 2;
-const RenderFocusContext = 3;
-const RenderIncremental = 4;
-const RenderCss = 5;
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$6({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
 
-const modules = [isEqual, isEqual$1, isEqual$1, isEqual$2];
-const numbers = [RenderIncremental, RenderFocus, RenderFocusContext, RenderCss];
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
 
-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 getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
 };
 
-const diff2 = uid => {
-  const {
-    oldState,
-    scheduledState
-  } = get$2(uid);
-  return diff(oldState, scheduledState);
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
 };
 
-const intervals = new Map();
-const pending = new Set();
-const dispose$4 = uid => {
-  const interval = intervals.get(uid);
-  if (interval) {
-    clearInterval(interval);
-    intervals.delete(uid);
-  }
-  pending.delete(uid);
+const getHost = () => {
+  return location.host;
 };
-const update = async uid => {
-  if (!getKeys$1().includes(uid)) {
-    dispose$4(uid);
-    return;
-  }
-  if (pending.has(uid)) {
-    return;
-  }
-  pending.add(uid);
+const getProtocol = () => {
+  return location.protocol;
+};
+
+const create$4 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  let rawIpc;
   try {
-    await invoke$3('ProcessExplorer.update');
+    rawIpc = await IpcParentWithWebSocket$1.create({
+      webSocket
+    });
   } catch (error) {
-    console.error(error);
-  } finally {
-    pending.delete(uid);
-  }
-};
-const start = (uid, interval = processExplorerUpdateInterval) => {
-  if (interval <= 0 || intervals.has(uid)) {
-    return;
+    throw new VError(error, 'Failed to create rpc connection');
   }
-  const intervalId = setInterval(() => {
-    void update(uid);
-  }, interval);
-  intervals.set(uid, intervalId);
-};
-const restart = (uid, interval) => {
-  dispose$4(uid);
-  start(uid, interval);
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
 };
 
-const ProcessExplorerError = 'E_PROCESS_EXPLORER_ERROR';
-const ProcessExplorerRefreshFailed = 'E_PROCESS_EXPLORER_REFRESH_FAILED';
-const ProcessExplorerRpcConnectionClosed = 'E_PROCESS_EXPLORER_RPC_CONNECTION_CLOSED';
-
-const processExplorerRpcClosedMessage = 'Process explorer RPC connection was closed';
-const toProcessExplorerRpcClosedState = state => {
-  return {
-    ...state,
-    errorCode: ProcessExplorerRpcConnectionClosed,
-    errorCodeFrame: '',
-    errorMessage: processExplorerRpcClosedMessage,
-    errorStack: '',
-    initial: false
-  };
+const reconnectDelay = 2000;
+const waitForReconnect = async () => {
+  await new Promise(resolve => {
+    setTimeout(resolve, reconnectDelay);
+  });
 };
-const handleProcessExplorerRpcClose = async () => {
-  let didUpdate = false;
-  for (const uid of getKeys$1()) {
-    const viewletState = get$2(uid);
-    if (!viewletState) {
-      continue;
-    }
-    dispose$4(uid);
-    const {
-      oldState,
-      scheduledState
-    } = viewletState;
-    const newState = toProcessExplorerRpcClosedState(scheduledState);
-    set$a(uid, oldState, newState);
-    didUpdate = true;
+const connect = async ({
+  commandMap,
+  wsUrl
+}) => {
+  const webSocket = new WebSocket(wsUrl);
+  try {
+    const rpc = await create$4({
+      commandMap,
+      webSocket
+    });
+    return {
+      rpc,
+      webSocket
+    };
+  } catch (error) {
+    webSocket.close();
+    throw error;
   }
-  if (didUpdate) {
-    await invoke$3('ProcessExplorer.rerender');
+};
+const create$3 = async ({
+  commandMap,
+  onClose,
+  type
+}) => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl(type, host, protocol);
+  let connection;
+  try {
+    connection = await connect({
+      commandMap,
+      wsUrl
+    });
+  } catch {
+    await waitForReconnect();
+    connection = await connect({
+      commandMap,
+      wsUrl
+    });
+  }
+  if (onClose) {
+    connection.webSocket.addEventListener('close', onClose, {
+      once: true
+    });
   }
+  return connection.rpc;
 };
 
-const Two = '2.0';
+const create$2 = async ({
+  commandMap,
+  onClose,
+  type
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$3({
+      commandMap,
+      onClose,
+      type
+    });
+  });
+};
 
-const create$9 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
+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$1(ipc);
+  return rpc;
 };
 
-const create$8 = (id, method, params) => {
-  const message = {
-    id,
-    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);
   };
-  return message;
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
 };
 
-let id = 0;
-const create$7 = () => {
-  return ++id;
+const rpcs = Object.create(null);
+const set$9 = (id, rpc) => {
+  rpcs[id] = rpc;
 };
-
-const registerPromise = map => {
-  const id = create$7();
-  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$8(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$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 = {
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create = 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$9(method, params);
-      ipc.send(message);
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$9(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$9(rpcId, rpc);
     }
   };
-  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 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 handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
-};
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
 
-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 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 Web = 1;
+const Electron = 2;
+const Remote = 3;
+
+const ErrorWorker = 3308;
+const FileSystemWorker$1 = 209;
+const MainProcess = -5;
+const ProcessExplorerRenderer = 33;
+const RendererProcess = 1670;
+const RendererWorker = 1;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetPatches = 'Viewlet.setPatches';
+
+const Empty = 0;
+const FocusExplorer = 13;
+
+const {
+  invoke: invoke$6,
+  set: set$8
+} = create(ErrorWorker);
+const prepare = async error => {
+  return invoke$6('Errors.prepare', error);
 };
 
-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 {
+  set: set$7
+} = create(FileSystemWorker$1);
+
+const FileSystemWorker = {
+  __proto__: null,
+  set: set$7
 };
 
-const create$5 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$6({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
+const {
+  dispose: dispose$5,
+  invoke: invoke$5,
+  set: set$6
+} = create(MainProcess);
+
+const {
+  invoke: invoke$4,
+  set: set$5
+} = create(RendererProcess);
+
+const {
+  invoke: invoke$3,
+  invokeAndTransfer,
+  set: set$4
+} = create(RendererWorker);
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  await invoke$3('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 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 debugProcess = async (state, index = state.focusedIndex) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  await invoke$3('AttachDebugger.attachDebugger', process.pid);
+  return state;
 };
 
-const create$4 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  return createSharedLazyRpc(() => {
-    return create$5({
-      commandMap,
-      isMessagePortOpen,
-      send
-    });
-  });
+const isEqual$2 = (oldState, newState) => {
+  return oldState.visibleProcesses === newState.visibleProcesses;
 };
 
-const Https = 'https:';
-const Ws = 'ws:';
-const Wss = 'wss:';
-
-const getWebSocketProtocol = locationProtocol => {
-  return locationProtocol === Https ? Wss : Ws;
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
 };
 
-const getWebSocketUrl = (type, host, locationProtocol) => {
-  const wsProtocol = getWebSocketProtocol(locationProtocol);
-  return `${wsProtocol}//${host}/websocket/${type}`;
+const isEqual = (oldState, newState) => {
+  return oldState.initial === newState.initial && oldState.errorCode === newState.errorCode && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.focusedIndex === newState.focusedIndex && oldState.message === newState.message && oldState.visibleProcesses === newState.visibleProcesses;
 };
 
-const getHost = () => {
-  return location.host;
+const RenderItems = 1;
+const RenderFocus = 2;
+const RenderFocusContext = 3;
+const RenderIncremental = 4;
+const RenderCss = 5;
+
+const modules = [isEqual, isEqual$1, isEqual$1, isEqual$2];
+const numbers = [RenderIncremental, RenderFocus, RenderFocusContext, RenderCss];
+
+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 getProtocol = () => {
-  return location.protocol;
+
+const diff2 = uid => {
+  const {
+    oldState,
+    scheduledState
+  } = get$2(uid);
+  return diff(oldState, scheduledState);
 };
 
-const create$3 = async ({
-  commandMap,
-  webSocket
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  let rawIpc;
+const intervals = new Map();
+const pending = new Set();
+const dispose$4 = 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$4(uid);
+    return;
+  }
+  if (pending.has(uid)) {
+    return;
+  }
+  pending.add(uid);
   try {
-    rawIpc = await IpcParentWithWebSocket$1.create({
-      webSocket
-    });
+    await invoke$3('ProcessExplorer.update');
   } catch (error) {
-    throw new VError(error, 'Failed to create rpc connection');
+    console.error(error);
+  } finally {
+    pending.delete(uid);
   }
-  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc$1(ipc);
-  return rpc;
 };
-
-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 start = (uid, interval = processExplorerUpdateInterval) => {
+  if (interval <= 0 || intervals.has(uid)) {
+    return;
   }
-  const rpc = await create$3({
-    commandMap,
-    webSocket
-  });
-  return rpc;
+  const intervalId = setInterval(() => {
+    void update(uid);
+  }, interval);
+  intervals.set(uid, intervalId);
 };
-
-const create$1 = async ({
-  commandMap,
-  onClose,
-  type
-}) => {
-  return createSharedLazyRpc(() => {
-    return create$2({
-      commandMap,
-      onClose,
-      type
-    });
-  });
+const restart = (uid, interval) => {
+  dispose$4(uid);
+  start(uid, interval);
 };
 
-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 ProcessExplorerError = 'E_PROCESS_EXPLORER_ERROR';
+const ProcessExplorerRefreshFailed = 'E_PROCESS_EXPLORER_REFRESH_FAILED';
+const ProcessExplorerRpcConnectionClosed = 'E_PROCESS_EXPLORER_RPC_CONNECTION_CLOSED';
+
+const processExplorerRpcClosedMessage = 'Process explorer RPC connection was closed';
+const toProcessExplorerRpcClosedState = state => {
+  return {
+    ...state,
+    errorCode: ProcessExplorerRpcConnectionClosed,
+    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$4(uid);
+    const {
+      oldState,
+      scheduledState
+    } = viewletState;
+    const newState = toProcessExplorerRpcClosedState(scheduledState);
+    set$a(uid, oldState, newState);
+    didUpdate = true;
+  }
+  if (didUpdate) {
+    await invoke$3('ProcessExplorer.rerender');
+  }
 };
 
 const sendMessagePortToMainProcess = async port => {
@@ -1843,7 +1965,7 @@ const sendMessagePortToProcessExplorer = async port => {
 };
 
 const createRpc = async send => {
-  return create$4({
+  return create$5({
     commandMap: {},
     send
   });
@@ -1873,7 +1995,7 @@ const launchProcessExplorerNode = async onClose => {
       } = await invoke$3('WebSocketCapability.create', 'process-explorer');
       const webSocket = new WebSocket(url, protocols);
       webSocket.addEventListener('close', onClose);
-      return await create$3({
+      return await create$4({
         commandMap: {},
         webSocket
       });
@@ -1882,7 +2004,7 @@ const launchProcessExplorerNode = async onClose => {
         throw error;
       }
     }
-    const rpc = await create$1({
+    const rpc = await create$2({
       commandMap: {},
       onClose,
       type: 'process-explorer'
@@ -2115,6 +2237,10 @@ const focusPrevious = state => {
   return focusIndex(state, state.focusedIndex - 1);
 };
 
+const getComponentState = uid => {
+  return get$2(uid).newState;
+};
+
 const getKeyBindings = () => {
   return [{
     command: 'ProcessExplorer.handleArrowRight',
@@ -2344,7 +2470,7 @@ const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcess =
     await fn(uid, ...args);
     await invoke$3('Viewlet.requestRender', uid);
   };
-  const rpc = await create$6({
+  const rpc = await create$7({
     commandMap: {
       'Viewlet.executeViewletCommand': executeViewletCommand
     },
@@ -2401,15 +2527,14 @@ const getUrlName = url => {
   if (!url || url === 'cross-origin-url') {
     return url;
   }
-  try {
+  if (URL.canParse(url)) {
     const parsed = new URL(url);
     const parts = parsed.pathname.split('/').filter(Boolean);
     return parts.at(-1) || parsed.hostname || url;
-  } catch {
-    const withoutQuery = url.split(QueryOrHashRegex, 1)[0];
-    const parts = withoutQuery.split('/').filter(Boolean);
-    return parts.at(-1) || url;
   }
+  const withoutQuery = url.split(QueryOrHashRegex, 1)[0];
+  const parts = withoutQuery.split('/').filter(Boolean);
+  return parts.at(-1) || url;
 };
 
 const getAttributionName = attribution => {
@@ -2554,6 +2679,13 @@ const getRootPid = async (processExplorer, rootPid, includeElectronData) => {
   });
 };
 const refresh = async state => {
+  if (state.platform === Web) {
+    return {
+      ...state,
+      initial: false,
+      message: 'Process Explorer is not supported on web.'
+    };
+  }
   try {
     await initializeProcessExplorer(state.platform);
     const includeElectronData = state.platform === Electron;
@@ -2578,6 +2710,7 @@ const refresh = async state => {
       errorStack: '',
       focusedIndex: getFocusedIndex(state.focusedIndex, visibleProcesses),
       initial: false,
+      message: '',
       processes: displayedProcesses,
       rootPid,
       visibleProcesses
@@ -2590,7 +2723,8 @@ const refresh = async state => {
       errorCodeFrame: prettyError.codeFrame || '',
       errorMessage: prettyError.message || getErrorMessage(error),
       errorStack: prettyError.stack || '',
-      initial: false
+      initial: false,
+      message: ''
     };
   }
 };
@@ -2600,7 +2734,7 @@ const hasError$1 = state => {
 };
 const loadContent = async state => {
   const newState = await refresh(state);
-  if (!hasError$1(newState)) {
+  if (!hasError$1(newState) && !newState.message) {
     start(newState.uid, newState.updateInterval);
   }
   return {
@@ -2868,6 +3002,29 @@ const replaceTree = (newNode, patches) => {
     nodes: treeToArray(newNode)
   });
 };
+const appendPatch = (patches, patch) => {
+  switch (patch.type) {
+    case MultiNavigation:
+      for (let i = 0; i < patch.navigations.length; i += 2) {
+        appendNavigationPatch(patches, patch.navigations[i], patch.navigations[i + 1]);
+      }
+      return;
+    case NavigateChild:
+    case NavigateSibling:
+      appendNavigationPatch(patches, patch.type, patch.index);
+      return;
+    case NavigateParent:
+      appendNavigationPatch(patches, patch.type, 0);
+      return;
+    default:
+      patches.push(patch);
+  }
+};
+const appendPatches = (patches, newPatches) => {
+  for (const patch of newPatches) {
+    appendPatch(patches, patch);
+  }
+};
 const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
   const nodePatches = compareNodes(oldNode.node, newNode.node);
   if (nodePatches === null) {
@@ -2876,16 +3033,16 @@ const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index)
     return nextChildIndex;
   }
   const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+  const childPatches = [];
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, childPatches);
+  }
+  if (nodePatches.length === 0 && childPatches.length === 0) {
     return currentChildIndex;
   }
   const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
-  if (nodePatches.length > 0) {
-    patches.push(...nodePatches);
-  }
-  if (hasChildrenToCompare) {
-    diffChildren(oldNode.children, newNode.children, patches);
-  }
+  patches.push(...nodePatches);
+  appendPatches(patches, childPatches);
   return nextChildIndex;
 };
 const diffRootNode = (oldNode, newNode, patches) => {
@@ -2969,6 +3126,7 @@ const RowGroup = 'rowgroup';
 const Cell = 'ProcessExplorerCell';
 const Error$1 = 'ProcessExplorerError';
 const HeaderCell = 'ProcessExplorerHeaderCell';
+const Message = 'ProcessExplorerMessage';
 const NameHeaderCellWide = 'ProcessExplorerNameHeaderCellWide';
 const NameCell = 'ProcessExplorerNameCell';
 const Row = 'ProcessExplorerRow';
@@ -3027,6 +3185,11 @@ const processExplorer = {
   role: None,
   type: Div
 };
+const messageNode = {
+  childCount: 1,
+  className: Message,
+  type: Div
+};
 const getRowClassName = focused => {
   if (focused) {
     return mergeClassNames(Row, RowFocused);
@@ -3110,6 +3273,9 @@ const hasError = state => {
   } = state;
   return Boolean(errorCode || errorMessage || errorCodeFrame || errorStack);
 };
+const getMessageDom = message => {
+  return [processExplorer, messageNode, text(message)];
+};
 const getErrorDom = state => {
   const {
     errorCode,
@@ -3150,11 +3316,15 @@ const getTableDom = state => {
 };
 const getDom = state => {
   const {
-    initial
+    initial,
+    message
   } = state;
   if (initial) {
     return [];
   }
+  if (message) {
+    return getMessageDom(message);
+  }
   if (hasError(state)) {
     return getErrorDom(state);
   }
@@ -3246,6 +3416,23 @@ const rerender = state => {
   return state;
 };
 
+const applyComponentState = (currentState, state) => {
+  if (!state || typeof state !== 'object' || Array.isArray(state)) {
+    throw new TypeError('Process Explorer state must be an object');
+  }
+  const {
+    uid
+  } = state;
+  const {
+    uid: currentUid
+  } = currentState;
+  if (uid !== currentUid) {
+    throw new Error(`Process Explorer state uid must remain ${currentUid}`);
+  }
+  return state;
+};
+const setComponentState = wrapCommand(applyComponentState);
+
 const isRawError = value => {
   return Boolean(value && typeof value === 'object');
 };
@@ -3335,6 +3522,7 @@ const commandMap = {
   'ProcessExplorer.focusNext': wrapCommand(focusNext),
   'ProcessExplorer.focusPrevious': wrapCommand(focusPrevious),
   'ProcessExplorer.getCommandIds': getCommandIds,
+  'ProcessExplorer.getComponentState': getComponentState,
   'ProcessExplorer.getKeyBindings': getKeyBindings,
   'ProcessExplorer.getMenuEntries': wrapGetter(getMenuEntries),
   'ProcessExplorer.getMenuEntryIds': getMenuEntryIds,
@@ -3352,6 +3540,7 @@ const commandMap = {
   'ProcessExplorer.render2': render2,
   'ProcessExplorer.renderEventListeners': renderEventListeners,
   'ProcessExplorer.rerender': wrapCommand(rerender),
+  'ProcessExplorer.setComponentState': setComponentState,
   'ProcessExplorer.setError': wrapCommand(setError),
   'ProcessExplorer.setRootProcessId': wrapCommand(setRootProcessId),
   'ProcessExplorer.setUpdateInterval': wrapCommand(setUpdateInterval),
@@ -3366,7 +3555,7 @@ const sendMessagePortToErrorWorker = async port => {
 
 const createErrorWorkerRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToErrorWorker
     });
@@ -3387,7 +3576,7 @@ const sendMessagePortToFileSystemWorker = async port => {
 
 const createFileSystemWorkerRpc = async () => {
   try {
-    const rpc = await create$4({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToFileSystemWorker
     });
@@ -3407,7 +3596,7 @@ const initializeFileSystemWorker = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await create({
+  const rpc = await create$1({
     commandMap: commandMap
   });
   set$4(rpc);