@lvce-editor/static-server 0.115.8 → 0.115.11

package/static/{5e50b2d → bb27a79}/packages/process-explorer-worker/index.js

@@ -2279,1088 +2279,1108 @@ const focusPrevious = state => {
   return focusIndex(state, focusedIndex - 1);
 };
 
-const getComponentState = uid => {
-  return get$2(uid).newState;
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
 };
 
-const getKeyBindings = () => {
-  return [{
-    command: 'ProcessExplorer.handleArrowRight',
-    key: RightArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleArrowLeft',
-    key: LeftArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusFirst',
-    key: Home,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusLast',
-    key: End,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusPrevious',
-    key: UpArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.focusNext',
-    key: DownArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.collapseAll',
-    key: CtrlCmd | LeftArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.expandAll',
-    key: CtrlCmd | RightArrow,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.expandAll',
-    key: CtrlCmd | Star,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleDoubleClick',
-    key: Enter,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleDoubleClick',
-    key: Space,
-    when: FocusExplorer
-  }, {
-    command: 'ProcessExplorer.handleContextMenu',
-    key: ContextMenu,
-    when: FocusExplorer
-  }];
+const text = data => {
+  return {
+    childCount: 0,
+    text: data,
+    type: Text
+  };
 };
 
-const isDebuggable = command => {
-  return command.includes('node ') || command.includes('node.exe') || command.includes('node.mojom.NodeService');
-};
+const SetText = 1;
+const Replace = 2;
+const SetAttribute = 3;
+const RemoveAttribute = 4;
+const Add = 6;
+const NavigateChild = 7;
+const NavigateParent = 8;
+const RemoveChild = 9;
+const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
+const MultiNavigation = 18;
 
-const isRendererProcess = process => {
-  if (process.source === 'remote') {
-    return false;
-  }
-  return process.name === 'renderer' || process.name.startsWith('webcontentsview');
+const isKey = key => {
+  return key !== 'type' && key !== 'childCount';
 };
 
-const KillProcess = 'Kill Process';
-const DebugProcess = 'Debug Process';
-const TakeHeapSnapshot = 'Take Heap Snapshot';
+const getKeys = node => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
+};
 
-const getMenuEntries = state => {
-  const {
-    focusedIndex,
-    visibleProcesses
-  } = state;
-  const process = visibleProcesses[focusedIndex];
-  if (!process || process.synthetic) {
-    return [];
-  }
-  const menuEntries = [{
-    args: [focusedIndex],
-    command: 'ProcessExplorer.killProcess',
-    flags: None$1,
-    id: 'killProcess',
-    label: KillProcess
-  }];
-  const isDebuggable$1 = isDebuggable(process.cmd);
-  if (isDebuggable$1) {
-    menuEntries.push({
-      args: [focusedIndex],
-      command: 'ProcessExplorer.debugProcess',
-      flags: None$1,
-      id: 'debugProcess',
-      label: DebugProcess
-    });
-  }
-  if (isDebuggable$1 || isRendererProcess(process)) {
-    menuEntries.push({
-      args: [focusedIndex],
-      command: 'ProcessExplorer.takeHeapSnapshot',
-      flags: None$1,
-      id: 'takeHeapSnapshot',
-      label: TakeHeapSnapshot
+const arrayToTree = nodes => {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const {
+      children,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+    result.push({
+      node,
+      children
     });
+    i += 1 + nodesConsumed;
   }
-  return menuEntries;
-};
-
-const ProcessExplorer$1 = 29;
-
-const getMenuEntryIds = () => {
-  return [ProcessExplorer$1];
+  return result;
 };
-
-const toggleIndex = (state, index) => {
-  const {
-    collapsedPids: stateCollapsedPids,
-    processes,
-    rootPid,
-    visibleProcesses: stateVisibleProcesses
-  } = state;
-  const process = stateVisibleProcesses[index];
-  if (!process || process.flags === None$2) {
-    return state;
+const getChildrenWithCount = (nodes, startIndex, childCount) => {
+  if (childCount === 0) {
+    return {
+      children: [],
+      nodesConsumed: 0
+    };
+  }
+  const children = [];
+  let i = startIndex;
+  let remaining = childCount;
+  let totalConsumed = 0;
+  while (remaining > 0 && i < nodes.length) {
+    const node = nodes[i];
+    const nodeChildCount = node.childCount || 0;
+    const {
+      children: nodeChildren,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+    children.push({
+      node,
+      children: nodeChildren
+    });
+    const nodeSize = 1 + nodesConsumed;
+    i += nodeSize;
+    totalConsumed += nodeSize;
+    remaining--;
   }
-  const treeId = process.treeId ?? process.pid;
-  const collapsedPids = stateCollapsedPids.includes(treeId) ? stateCollapsedPids.filter(pid => pid !== treeId) : [...stateCollapsedPids, treeId];
-  const visibleProcesses = getVisibleProcesses(processes, collapsedPids, rootPid);
   return {
-    ...state,
-    collapsedPids,
-    focusedIndex: Math.min(index, visibleProcesses.length - 1),
-    visibleProcesses
+    children,
+    nodesConsumed: totalConsumed
   };
 };
 
-const getParentIndex = state => {
-  const {
-    focusedIndex,
-    visibleProcesses
-  } = state;
-  const process = visibleProcesses[focusedIndex];
-  if (!process) {
-    return -1;
+const isNavigationPatch = patch => {
+  switch (patch.type) {
+    case NavigateChild:
+    case NavigateParent:
+    case NavigateSibling:
+      return true;
+    default:
+      return false;
   }
-  for (let i = focusedIndex - 1; i >= 0; i--) {
-    const otherProcess = visibleProcesses[i];
-    if (otherProcess.depth === process.depth - 1) {
-      return i;
-    }
+};
+const getNavigationIndex = patch => {
+  switch (patch.type) {
+    case NavigateChild:
+    case NavigateSibling:
+      return patch.index;
+    default:
+      return 0;
   }
-  return -1;
 };
-const handleArrowLeft = state => {
-  const {
-    focusedIndex,
-    visibleProcesses
-  } = state;
-  const process = visibleProcesses[focusedIndex];
-  if (!process) {
-    return state;
+const appendNavigationPatch = (patches, type, index) => {
+  const previousPatch = patches.at(-1);
+  if (!previousPatch) {
+    patches.push(type === NavigateParent ? {
+      type
+    } : {
+      index,
+      type
+    });
+    return;
   }
-  if (process.flags === Expanded) {
-    return toggleIndex(state, focusedIndex);
+  if (previousPatch.type === MultiNavigation) {
+    previousPatch.navigations.push(type, index);
+    return;
   }
-  const parentIndex = getParentIndex(state);
-  if (parentIndex === -1) {
-    return state;
+  if (isNavigationPatch(previousPatch)) {
+    patches[patches.length - 1] = {
+      navigations: [previousPatch.type, getNavigationIndex(previousPatch), type, index],
+      type: MultiNavigation
+    };
+    return;
   }
-  return focusIndex(state, parentIndex);
+  patches.push(type === NavigateParent ? {
+    type
+  } : {
+    index,
+    type
+  });
 };
 
-const handleArrowRight = state => {
-  const {
-    focusedIndex,
-    visibleProcesses
-  } = state;
-  const process = visibleProcesses[focusedIndex];
-  if (!process) {
-    return state;
+const compareNodes = (oldNode, newNode) => {
+  // Check if node type changed - return null to signal incompatible nodes
+  // (caller should handle this with a Replace operation)
+  if (oldNode.type !== newNode.type) {
+    return null;
   }
-  if (process.flags === Collapsed) {
-    return toggleIndex(state, focusedIndex);
+  const patches = [];
+  // Handle reference nodes - special handling for uid changes
+  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
+    patches.push({
+      type: SetReferenceNodeUid,
+      uid: newNode.uid
+    });
   }
-  const nextProcess = visibleProcesses[focusedIndex + 1];
-  if (process.flags === Expanded && nextProcess && nextProcess.depth > process.depth) {
-    return focusIndex(state, focusedIndex + 1);
+  // Handle text nodes
+  if (oldNode.type === Text && newNode.type === Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
+    }
+    return patches;
   }
-  return state;
-};
-
-const handleBlur = state => {
-  return {
-    ...state,
-    focused: false
-  };
-};
-
-const handleClickAt = (state, index) => {
-  return focusIndex(state, Number(index));
-};
-
-const show2 = async (uid, menuId, x, y, args) => {
-  await showContextMenu2(uid, menuId, x, y, args);
-};
-
-const handleContextMenu = async (state, index = undefined, x = 0, y = 0) => {
-  const {
-    focusedIndex,
-    uid,
-    visibleProcesses
-  } = state;
-  const numericIndex = Number(index === undefined ? focusedIndex : index);
-  const process = visibleProcesses[numericIndex];
-  if (!process) {
-    return state;
+  // Compare attributes
+  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
+  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
+  // Check for attribute changes
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
   }
-  const newState = {
-    ...state,
-    focused: false,
-    focusedIndex: numericIndex
-  };
-  set$a(uid, state, newState);
-  await show2(uid, ProcessExplorer$1, x, y, {
-    index: numericIndex,
-    menuId: ProcessExplorer$1
-  });
-  return newState;
-};
-
-const handleDoubleClick = (state, index = undefined) => {
-  const {
-    focusedIndex
-  } = state;
-  return toggleIndex(state, Number(index === undefined ? focusedIndex : index));
-};
-
-const handleFocus = state => {
-  return {
-    ...state,
-    focused: true
-  };
-};
-
-const state = {
-  connected: false
-};
-const isConnected = () => {
-  const {
-    connected
-  } = state;
-  return connected;
-};
-const invoke = (method, ...params) => invoke$4(method, ...params);
-const set$1 = rpc => {
-  set$5(rpc);
-  state.connected = true;
-};
-
-const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcess = true) => {
-  const executeViewletCommand = async (uid, command, ...args) => {
-    const fn = viewletCommandMap[`ProcessExplorer.${command}`];
-    if (typeof fn !== 'function') {
-      throw new TypeError(`Viewlet command not found: ${command}`);
+  // Check for removed attributes
+  for (const key of oldKeys) {
+    if (!Object.hasOwn(newNode, key)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
     }
-    await fn(uid, ...args);
-    await invoke$3('Viewlet.requestRender', uid);
-  };
-  const rpc = await create$7({
-    commandMap: {
-      'Viewlet.executeViewletCommand': executeViewletCommand
-    },
-    messagePort: port
-  });
-  if (setAsRendererProcess) {
-    set$1(rpc);
   }
+  return patches;
 };
 
-const killProcess = async (state, index = undefined) => {
-  const {
-    focusedIndex,
-    uid,
-    visibleProcesses
-  } = state;
-  const resolvedIndex = index === undefined ? focusedIndex : index;
-  const process = visibleProcesses[resolvedIndex];
-  if (!process || process.synthetic) {
-    return state;
-  }
-  const processExplorer = process.source === 'remote' ? RemoteProcessExplorer : ProcessExplorer$2;
-  const killPromise = processExplorer.invoke('Process.kill', process.pid);
-  if (process.name === 'process-explorer') {
-    dispose$4(uid);
-    void killPromise.catch(() => {});
-    return toProcessExplorerRpcClosedState(state);
+const treeToArray = node => {
+  const result = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    result.push(current.node);
+    for (let i = current.children.length - 1; i >= 0; i--) {
+      stack.push(current.children[i]);
+    }
   }
-  await killPromise;
-  return state;
+  return result;
 };
 
-const getErrorCode = (error, fallback) => {
-  if (!error || typeof error !== 'object') {
-    return fallback;
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    appendNavigationPatch(patches, NavigateChild, index);
+    return index;
   }
-  const code = 'code' in error ? error.code : undefined;
-  if (typeof code !== 'string' || !code) {
-    return fallback;
+  if (currentChildIndex !== index) {
+    appendNavigationPatch(patches, NavigateSibling, index);
   }
-  return code;
+  return index;
 };
-
-const getMeasureMemory = () => {
-  const {
-    measureUserAgentSpecificMemory
-  } = performance;
-  if (typeof measureUserAgentSpecificMemory !== 'function') {
-    return undefined;
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    appendNavigationPatch(patches, NavigateParent, 0);
   }
-  return measureUserAgentSpecificMemory.bind(performance);
+  return -1;
 };
-
-const isValidMemoryValue = value => {
-  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
 };
-
-const QueryOrHashRegex = /[?#]/;
-const getUrlName = url => {
-  if (!url || url === 'cross-origin-url') {
-    return url;
-  }
-  if (URL.canParse(url)) {
-    const parsed = new URL(url);
-    const parts = parsed.pathname.split('/').filter(Boolean);
-    return parts.at(-1) || parsed.hostname || url;
-  }
-  const withoutQuery = url.split(QueryOrHashRegex, 1)[0];
-  const parts = withoutQuery.split('/').filter(Boolean);
-  return parts.at(-1) || url;
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
 };
-
-const getAttributionName = attribution => {
-  const scope = attribution.scope || 'memory';
-  const url = attribution.url ? getUrlName(attribution.url) : '';
-  if (url) {
-    return `${scope}: ${url}`;
+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);
   }
-  return scope;
 };
-
-const getBreakdownName = (entry, index) => {
-  if (entry.attribution && entry.attribution.length > 0) {
-    return entry.attribution.map(getAttributionName).join(', ');
-  }
-  if (entry.types && entry.types.length > 0) {
-    return entry.types.join(', ');
+const appendPatches = (patches, newPatches) => {
+  for (const patch of newPatches) {
+    appendPatch(patches, patch);
   }
-  return `breakdown ${index + 1}`;
 };
-
-const WindowPid = -1;
-
-const toBreakdownProcess = (entry, index) => {
-  const name = getBreakdownName(entry, index);
-  return {
-    cmd: name,
-    memory: entry.bytes,
-    name,
-    pid: -2 - index,
-    ppid: WindowPid,
-    synthetic: true
-  };
-};
-
-const getFrontendMemoryUsage = async rootPid => {
-  const measureMemory = getMeasureMemory();
-  if (!measureMemory) {
-    return [];
+const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex;
   }
-  try {
-    const measurement = await measureMemory();
-    if (!isValidMemoryValue(measurement.bytes)) {
-      return [];
-    }
-    const breakdown = measurement.breakdown || [];
-    const breakdownProcesses = breakdown.filter(entry => isValidMemoryValue(entry.bytes) && entry.bytes > 0).map(toBreakdownProcess);
-    return [{
-      cmd: 'window',
-      memory: measurement.bytes,
-      name: 'window',
-      pid: WindowPid,
-      ppid: rootPid,
-      synthetic: true
-    }, ...breakdownProcesses];
-  } catch {
-    return [];
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  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);
+  patches.push(...nodePatches);
+  appendPatches(patches, childPatches);
+  return nextChildIndex;
 };
-
-const createGroup = (name, source, processes, rootPid) => {
-  const groupId = `${source}:group`;
-  const group = {
-    cmd: name,
-    memory: 0,
-    name,
-    parentTreeId: '',
-    pid: 0,
-    ppid: 0,
-    source,
-    synthetic: true,
-    treeId: groupId
-  };
-  const groupedProcesses = processes.map(process => ({
-    ...process,
-    parentTreeId: process.pid === rootPid ? groupId : `${source}:${process.ppid}`,
-    source,
-    treeId: `${source}:${process.pid}`
-  }));
-  return [group, ...groupedProcesses];
-};
-const groupProcesses = (localProcesses, localRootPid, remoteProcesses, remoteRootPid) => {
-  return [...createGroup('Local', 'local', localProcesses, localRootPid), ...createGroup('Remote', 'remote', remoteProcesses, remoteRootPid)];
+const diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
 };
-
-const getErrorMessage = error => {
-  if (error instanceof Error) {
-    return error.message;
+const diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  let currentChildIndex = -1;
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
+      indicesToRemove.push(i);
+      continue;
+    }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
+  }
+  navigateToParent(patches, currentChildIndex);
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
   }
-  return String(error);
 };
-const prepareError = async error => {
-  try {
-    return await prepare(error);
-  } catch {
-    return {
-      codeFrame: undefined,
-      message: getErrorMessage(error),
-      stack: undefined
-    };
+const diffTrees = (oldTree, newTree, patches, path) => {
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
   }
+  diffChildren(oldTree, newTree, patches);
 };
 
-const conceptualChildNames = ['embeds-process', 'file-system-process', 'file-watcher-process', 'process-explorer', 'search-process', 'terminal-process'];
-const reparentSharedProcessChildren = processes => {
-  const sharedProcess = processes.find(process => process.name === 'shared-process');
-  if (!sharedProcess) {
-    return processes;
-  }
-  return processes.map(process => {
-    if (process.ppid === sharedProcess.pid || !conceptualChildNames.includes(process.name)) {
-      return process;
+const removeTrailingNavigationPatches = patches => {
+  while (patches.length > 0) {
+    const patch = patches.at(-1);
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling && patch.type !== MultiNavigation) {
+      break;
     }
-    return {
-      ...process,
-      ppid: sharedProcess.pid
-    };
-  });
+    patches.pop();
+  }
+  return patches;
 };
 
-const getFocusedIndex = (oldFocusedIndex, visibleProcesses) => {
-  if (visibleProcesses.length === 0) {
-    return -1;
+const diffTree = (oldNodes, newNodes) => {
+  // Step 1: Convert flat arrays to tree structures
+  const oldTree = arrayToTree(oldNodes);
+  const newTree = arrayToTree(newNodes);
+  // Step 3: Compare the trees
+  const patches = [];
+  diffTrees(oldTree, newTree, patches, []);
+  // Remove trailing navigation patches since they serve no purpose
+  return removeTrailingNavigationPatches(patches);
+};
+
+const Grid = 'grid';
+const GridCell = 'gridcell';
+const None = 'none';
+const Row$1 = 'row';
+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';
+const RowFocused = 'ProcessExplorerRowFocused';
+const Table = 'ProcessExplorerTable';
+const TableBody = 'ProcessExplorerTableBody';
+const TableHead = 'ProcessExplorerTableHead';
+const Viewlet = 'Viewlet';
+const ProcessExplorer$1 = 'ProcessExplorer';
+
+const HandleBlur = 1;
+const HandleClick = 2;
+const HandleContextMenu = 3;
+const HandleDoubleClick = 4;
+const HandleFocus = 5;
+const HandlePointerDown = 6;
+
+const formatMemory = memory => {
+  if (memory < 1000) {
+    return `${memory} B`;
   }
-  if (oldFocusedIndex < 0) {
-    return 0;
+  if (memory < 1000 ** 2) {
+    return `${(memory / 1000).toFixed(1)} kB`;
   }
-  return Math.min(oldFocusedIndex, visibleProcesses.length - 1);
+  if (memory < 1000 ** 3) {
+    return `${(memory / 1000 ** 2).toFixed(1)} MB`;
+  }
+  if (memory < 1000 ** 4) {
+    return `${(memory / 1000 ** 3).toFixed(1)} GB`;
+  }
+  return `${(memory / 1000 ** 4).toFixed(1)} TB`;
 };
-const listProcesses = async (processExplorer, rootPid, pidMap) => {
-  if (pidMap) {
-    return processExplorer.invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false, pidMap);
+
+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 processExplorer = {
+  childCount: 1,
+  className: mergeClassNames(Viewlet, ProcessExplorer$1),
+  role: None,
+  type: Div
+};
+const messageNode = {
+  childCount: 1,
+  className: Message,
+  type: Div
+};
+const getRowClassName = focused => {
+  if (focused) {
+    return mergeClassNames(Row, RowFocused);
   }
-  return processExplorer.invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false);
+  return Row;
 };
-const getRootPid = async (processExplorer, rootPid, includeElectronData) => {
-  if (rootPid !== -1) {
-    return rootPid;
+const getAriaExpanded = process => {
+  switch (process.flags) {
+    case Collapsed:
+      return false;
+    case Expanded:
+      return true;
+    default:
+      return undefined;
   }
-  return processExplorer.invoke('ProcessId.getMainProcessId', {
-    includeElectronData
-  });
 };
-const refresh = async state => {
+const getCellDom = (className, value, index) => {
+  return [{
+    childCount: 1,
+    className,
+    'data-index': index,
+    name: String(index),
+    role: GridCell,
+    tabIndex: -1,
+    type: Td
+  }, text(value)];
+};
+const shouldUseWideNameColumn = visibleProcesses => {
+  return visibleProcesses.some(process => process.name.toLowerCase().includes('webcontentsview'));
+};
+const getHeaderDom = visibleProcesses => {
+  const useWideNameColumn = shouldUseWideNameColumn(visibleProcesses);
+  return [tableHeadNode, headerRowNode, ...['Name', 'PID', 'Memory'].flatMap((label, index) => [{
+    ...headerCellNode,
+    ...(index === 0 && useWideNameColumn && {
+      className: mergeClassNames(HeaderCell, NameHeaderCellWide)
+    })
+  }, text(label)])];
+};
+const getRowDom = (process, index, focused) => {
+  return [{
+    ariaExpanded: getAriaExpanded(process),
+    ariaLevel: process.depth,
+    childCount: 3,
+    className: getRowClassName(focused),
+    'data-index': index,
+    name: String(index),
+    role: Row$1,
+    tabIndex: focused ? 0 : -1,
+    title: process.cmd,
+    type: Tr
+  }, ...getCellDom(mergeClassNames(Cell, NameCell, `ProcessExplorerIndent-${process.depth}`), process.name, index), ...getCellDom(Cell, process.synthetic ? '' : String(process.pid), index), ...getCellDom(Cell, process.synthetic ? '' : formatMemory(process.memory), index)];
+};
+const getBodyDom = state => {
   const {
-    collapsedPids,
     focusedIndex,
-    includeFrontendMemoryUsage,
-    platform,
-    rootPid: stateRootPid
+    visibleProcesses
   } = state;
-  if (platform === Web) {
-    return {
-      ...state,
-      initial: false,
-      message: 'Process Explorer is not supported on web.'
-    };
-  }
-  try {
-    await initializeProcessExplorer(platform);
-    const includeElectronData = platform === Electron;
-    const rootPid = await getRootPid(ProcessExplorer$2, stateRootPid, includeElectronData);
-    const pidMap = includeElectronData ? await invoke$5('CreatePidMap.createPidMap') : undefined;
-    const processes = await listProcesses(ProcessExplorer$2, rootPid, pidMap);
-    const frontendMemoryProcesses = includeFrontendMemoryUsage ? await getFrontendMemoryUsage(rootPid) : [];
-    const allProcesses = [...processes, ...frontendMemoryProcesses];
-    const localProcesses = platform === Electron ? reparentSharedProcessChildren(allProcesses) : allProcesses;
-    let displayedProcesses = localProcesses;
-    if (platform === Electron && has()) {
-      const remoteRootPid = await getRootPid(RemoteProcessExplorer, -1, false);
-      const remoteProcesses = await listProcesses(RemoteProcessExplorer, remoteRootPid);
-      displayedProcesses = groupProcesses(localProcesses, rootPid, remoteProcesses, remoteRootPid);
-    }
-    const visibleProcesses = getVisibleProcesses(displayedProcesses, collapsedPids, rootPid);
-    return {
-      ...state,
-      errorCode: '',
-      errorCodeFrame: '',
-      errorMessage: '',
-      errorStack: '',
-      focusedIndex: getFocusedIndex(focusedIndex, visibleProcesses),
-      initial: false,
-      message: '',
-      processes: displayedProcesses,
-      rootPid,
-      visibleProcesses
-    };
-  } catch (error) {
-    const prettyError = await prepareError(error);
-    return {
-      ...state,
-      errorCode: getErrorCode(error, ProcessExplorerRefreshFailed),
-      errorCodeFrame: prettyError.codeFrame || '',
-      errorMessage: prettyError.message || getErrorMessage(error),
-      errorStack: prettyError.stack || '',
-      initial: false,
-      message: ''
-    };
+  return [{
+    childCount: visibleProcesses.length,
+    className: TableBody,
+    role: RowGroup,
+    type: TBody
+  }, ...visibleProcesses.flatMap((process, index) => getRowDom(process, index, index === focusedIndex))];
+};
+const getErrorSectionDom = (value, type) => {
+  if (!value) {
+    return [];
   }
+  return [{
+    childCount: 1,
+    type
+  }, text(value)];
+};
+const hasError$1 = state => {
+  const {
+    errorCode,
+    errorCodeFrame,
+    errorMessage,
+    errorStack
+  } = state;
+  return Boolean(errorCode || errorMessage || errorCodeFrame || errorStack);
+};
+const getMessageDom = message => {
+  return [processExplorer, messageNode, text(message)];
+};
+const getErrorDom = state => {
+  const {
+    errorCode,
+    errorCodeFrame,
+    errorMessage,
+    errorStack
+  } = state;
+  const errorCodeDom = getErrorSectionDom(errorCode, Div);
+  const messageDom = getErrorSectionDom(errorMessage, Div);
+  const codeFrameDom = getErrorSectionDom(errorCodeFrame, Pre);
+  const stackDom = getErrorSectionDom(errorStack, Pre);
+  const childCount = errorCodeDom.length / 2 + messageDom.length / 2 + codeFrameDom.length / 2 + stackDom.length / 2;
+  return [processExplorer, {
+    childCount,
+    className: Error$1,
+    type: Div
+  }, ...errorCodeDom, ...messageDom, ...codeFrameDom, ...stackDom];
+};
+const getTableDom = state => {
+  const {
+    visibleProcesses
+  } = state;
+  return [processExplorer, {
+    ariaLabel: 'Process Explorer',
+    ariaRowCount: visibleProcesses.length + 1,
+    childCount: 2,
+    className: Table,
+    onBlur: HandleBlur,
+    onClick: HandleClick,
+    onContextMenu: HandleContextMenu,
+    onDblClick: HandleDoubleClick,
+    onFocus: HandleFocus,
+    onPointerDown: HandlePointerDown,
+    role: Grid,
+    tabIndex: Focusable,
+    type: Table$1
+  }, ...getHeaderDom(visibleProcesses), ...getBodyDom(state)];
 };
-
-const hasError$1 = state => {
+const getDom = state => {
   const {
-    errorCode,
-    errorCodeFrame,
-    errorMessage,
-    errorStack
+    initial,
+    message
   } = state;
-  return Boolean(errorCode || errorMessage || errorCodeFrame || errorStack);
-};
-const loadContent = async state => {
-  const newState = await refresh(state);
-  if (!hasError$1(newState) && !newState.message) {
-    start(newState.uid, newState.updateInterval);
-  }
-  return {
-    error: undefined,
-    state: newState
-  };
-};
-
-const getIndentRule = depth => {
-  const paddingLeft = Math.max(0, depth - 1) * 1.5;
-  return `.ProcessExplorerNameCell.ProcessExplorerIndent-${depth} {
-  padding-left: ${paddingLeft}ch;
-}`;
-};
-const getCss = depths => {
-  return depths.map(getIndentRule).join('\n');
-};
-
-const getUniqueDepths = visibleProcesses => {
-  return [...new Set(visibleProcesses.map(process => process.depth))];
-};
-
-const renderCss = (oldState, newState) => {
-  const depths = getUniqueDepths(newState.visibleProcesses);
-  const css = getCss(depths);
-  return [SetCss, newState.uid, css];
-};
-
-const renderFocus = (oldState, newState) => {
-  if (!newState.focused || oldState.focusedIndex === newState.focusedIndex) {
+  if (initial) {
     return [];
   }
-  if (newState.focusedIndex < 0) {
-    return [FocusSelector, '.ProcessExplorerTable'];
+  if (message) {
+    return getMessageDom(message);
   }
-  return [FocusSelector, `[data-index="${newState.focusedIndex}"]`];
-};
-
-const renderFocusContext = (oldState, newState) => {
-  if (oldState.focused === newState.focused) {
-    return [];
+  if (hasError$1(state)) {
+    return getErrorDom(state);
   }
-  return [SetFocusContext, newState.uid, newState.focused ? FocusExplorer : Empty];
+  return getTableDom(state);
 };
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
+const renderItems = (oldState, newState) => {
+  return [SetDom2, newState.uid, getDom(newState)];
 };
 
-const text = data => {
-  return {
-    childCount: 0,
-    text: data,
-    type: Text
-  };
+const getComponentDom = uid => {
+  const {
+    newState
+  } = get$2(uid);
+  return getDom(newState);
 };
 
-const SetText = 1;
-const Replace = 2;
-const SetAttribute = 3;
-const RemoveAttribute = 4;
-const Add = 6;
-const NavigateChild = 7;
-const NavigateParent = 8;
-const RemoveChild = 9;
-const NavigateSibling = 10;
-const SetReferenceNodeUid = 11;
-const MultiNavigation = 18;
+const getComponentState = uid => {
+  return get$2(uid).newState;
+};
 
-const isKey = key => {
-  return key !== 'type' && key !== 'childCount';
+const getKeyBindings = () => {
+  return [{
+    command: 'ProcessExplorer.handleArrowRight',
+    key: RightArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleArrowLeft',
+    key: LeftArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusFirst',
+    key: Home,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusLast',
+    key: End,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusPrevious',
+    key: UpArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.focusNext',
+    key: DownArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.collapseAll',
+    key: CtrlCmd | LeftArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.expandAll',
+    key: CtrlCmd | RightArrow,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.expandAll',
+    key: CtrlCmd | Star,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleDoubleClick',
+    key: Enter,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleDoubleClick',
+    key: Space,
+    when: FocusExplorer
+  }, {
+    command: 'ProcessExplorer.handleContextMenu',
+    key: ContextMenu,
+    when: FocusExplorer
+  }];
 };
 
-const getKeys = node => {
-  const keys = Object.keys(node).filter(isKey);
-  return keys;
+const isDebuggable = command => {
+  return command.includes('node ') || command.includes('node.exe') || command.includes('node.mojom.NodeService');
 };
 
-const arrayToTree = nodes => {
-  const result = [];
-  let i = 0;
-  while (i < nodes.length) {
-    const node = nodes[i];
-    const {
-      children,
-      nodesConsumed
-    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
-    result.push({
-      node,
-      children
-    });
-    i += 1 + nodesConsumed;
+const isRendererProcess = process => {
+  if (process.source === 'remote') {
+    return false;
   }
-  return result;
+  return process.name === 'renderer' || process.name.startsWith('webcontentsview');
 };
-const getChildrenWithCount = (nodes, startIndex, childCount) => {
-  if (childCount === 0) {
-    return {
-      children: [],
-      nodesConsumed: 0
-    };
+
+const KillProcess = 'Kill Process';
+const DebugProcess = 'Debug Process';
+const TakeHeapSnapshot = 'Take Heap Snapshot';
+
+const getMenuEntries = state => {
+  const {
+    focusedIndex,
+    visibleProcesses
+  } = state;
+  const process = visibleProcesses[focusedIndex];
+  if (!process || process.synthetic) {
+    return [];
   }
-  const children = [];
-  let i = startIndex;
-  let remaining = childCount;
-  let totalConsumed = 0;
-  while (remaining > 0 && i < nodes.length) {
-    const node = nodes[i];
-    const nodeChildCount = node.childCount || 0;
-    const {
-      children: nodeChildren,
-      nodesConsumed
-    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
-    children.push({
-      node,
-      children: nodeChildren
+  const menuEntries = [{
+    args: [focusedIndex],
+    command: 'ProcessExplorer.killProcess',
+    flags: None$1,
+    id: 'killProcess',
+    label: KillProcess
+  }];
+  const isDebuggable$1 = isDebuggable(process.cmd);
+  if (isDebuggable$1) {
+    menuEntries.push({
+      args: [focusedIndex],
+      command: 'ProcessExplorer.debugProcess',
+      flags: None$1,
+      id: 'debugProcess',
+      label: DebugProcess
     });
-    const nodeSize = 1 + nodesConsumed;
-    i += nodeSize;
-    totalConsumed += nodeSize;
-    remaining--;
   }
-  return {
-    children,
-    nodesConsumed: totalConsumed
-  };
+  if (isDebuggable$1 || isRendererProcess(process)) {
+    menuEntries.push({
+      args: [focusedIndex],
+      command: 'ProcessExplorer.takeHeapSnapshot',
+      flags: None$1,
+      id: 'takeHeapSnapshot',
+      label: TakeHeapSnapshot
+    });
+  }
+  return menuEntries;
 };
 
-const isNavigationPatch = patch => {
-  switch (patch.type) {
-    case NavigateChild:
-    case NavigateParent:
-    case NavigateSibling:
-      return true;
-    default:
-      return false;
+const ProcessExplorer = 29;
+
+const getMenuEntryIds = () => {
+  return [ProcessExplorer];
+};
+
+const toggleIndex = (state, index) => {
+  const {
+    collapsedPids: stateCollapsedPids,
+    processes,
+    rootPid,
+    visibleProcesses: stateVisibleProcesses
+  } = state;
+  const process = stateVisibleProcesses[index];
+  if (!process || process.flags === None$2) {
+    return state;
   }
+  const treeId = process.treeId ?? process.pid;
+  const collapsedPids = stateCollapsedPids.includes(treeId) ? stateCollapsedPids.filter(pid => pid !== treeId) : [...stateCollapsedPids, treeId];
+  const visibleProcesses = getVisibleProcesses(processes, collapsedPids, rootPid);
+  return {
+    ...state,
+    collapsedPids,
+    focusedIndex: Math.min(index, visibleProcesses.length - 1),
+    visibleProcesses
+  };
 };
-const getNavigationIndex = patch => {
-  switch (patch.type) {
-    case NavigateChild:
-    case NavigateSibling:
-      return patch.index;
-    default:
-      return 0;
+
+const getParentIndex = state => {
+  const {
+    focusedIndex,
+    visibleProcesses
+  } = state;
+  const process = visibleProcesses[focusedIndex];
+  if (!process) {
+    return -1;
+  }
+  for (let i = focusedIndex - 1; i >= 0; i--) {
+    const otherProcess = visibleProcesses[i];
+    if (otherProcess.depth === process.depth - 1) {
+      return i;
+    }
   }
+  return -1;
 };
-const appendNavigationPatch = (patches, type, index) => {
-  const previousPatch = patches.at(-1);
-  if (!previousPatch) {
-    patches.push(type === NavigateParent ? {
-      type
-    } : {
-      index,
-      type
-    });
-    return;
+const handleArrowLeft = state => {
+  const {
+    focusedIndex,
+    visibleProcesses
+  } = state;
+  const process = visibleProcesses[focusedIndex];
+  if (!process) {
+    return state;
   }
-  if (previousPatch.type === MultiNavigation) {
-    previousPatch.navigations.push(type, index);
-    return;
+  if (process.flags === Expanded) {
+    return toggleIndex(state, focusedIndex);
   }
-  if (isNavigationPatch(previousPatch)) {
-    patches[patches.length - 1] = {
-      navigations: [previousPatch.type, getNavigationIndex(previousPatch), type, index],
-      type: MultiNavigation
-    };
-    return;
+  const parentIndex = getParentIndex(state);
+  if (parentIndex === -1) {
+    return state;
   }
-  patches.push(type === NavigateParent ? {
-    type
-  } : {
-    index,
-    type
-  });
+  return focusIndex(state, parentIndex);
 };
 
-const compareNodes = (oldNode, newNode) => {
-  // Check if node type changed - return null to signal incompatible nodes
-  // (caller should handle this with a Replace operation)
-  if (oldNode.type !== newNode.type) {
-    return null;
-  }
-  const patches = [];
-  // Handle reference nodes - special handling for uid changes
-  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
-    patches.push({
-      type: SetReferenceNodeUid,
-      uid: newNode.uid
-    });
-  }
-  // Handle text nodes
-  if (oldNode.type === Text && newNode.type === Text) {
-    if (oldNode.text !== newNode.text) {
-      patches.push({
-        type: SetText,
-        value: newNode.text
-      });
-    }
-    return patches;
+const handleArrowRight = state => {
+  const {
+    focusedIndex,
+    visibleProcesses
+  } = state;
+  const process = visibleProcesses[focusedIndex];
+  if (!process) {
+    return state;
   }
-  // Compare attributes
-  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
-  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
-  // Check for attribute changes
-  for (const key of newKeys) {
-    if (oldNode[key] !== newNode[key]) {
-      patches.push({
-        type: SetAttribute,
-        key,
-        value: newNode[key]
-      });
-    }
+  if (process.flags === Collapsed) {
+    return toggleIndex(state, focusedIndex);
   }
-  // Check for removed attributes
-  for (const key of oldKeys) {
-    if (!Object.hasOwn(newNode, key)) {
-      patches.push({
-        type: RemoveAttribute,
-        key
-      });
-    }
+  const nextProcess = visibleProcesses[focusedIndex + 1];
+  if (process.flags === Expanded && nextProcess && nextProcess.depth > process.depth) {
+    return focusIndex(state, focusedIndex + 1);
   }
-  return patches;
+  return state;
 };
 
-const treeToArray = node => {
-  const result = [];
-  const stack = [node];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    result.push(current.node);
-    for (let i = current.children.length - 1; i >= 0; i--) {
-      stack.push(current.children[i]);
-    }
-  }
-  return result;
+const handleBlur = state => {
+  return {
+    ...state,
+    focused: false
+  };
 };
 
-const navigateToChild = (patches, currentChildIndex, index) => {
-  if (currentChildIndex === -1) {
-    appendNavigationPatch(patches, NavigateChild, index);
-    return index;
-  }
-  if (currentChildIndex !== index) {
-    appendNavigationPatch(patches, NavigateSibling, index);
-  }
-  return index;
+const handleClickAt = (state, index) => {
+  return focusIndex(state, Number(index));
 };
-const navigateToParent = (patches, currentChildIndex) => {
-  if (currentChildIndex >= 0) {
-    appendNavigationPatch(patches, NavigateParent, 0);
-  }
-  return -1;
+
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
 };
-const addTree = (newNode, patches) => {
-  patches.push({
-    type: Add,
-    nodes: treeToArray(newNode)
+
+const handleContextMenu = async (state, index = undefined, x = 0, y = 0) => {
+  const {
+    focusedIndex,
+    uid,
+    visibleProcesses
+  } = state;
+  const numericIndex = Number(index === undefined ? focusedIndex : index);
+  const process = visibleProcesses[numericIndex];
+  if (!process) {
+    return state;
+  }
+  const newState = {
+    ...state,
+    focused: false,
+    focusedIndex: numericIndex
+  };
+  set$a(uid, state, newState);
+  await show2(uid, ProcessExplorer, x, y, {
+    index: numericIndex,
+    menuId: ProcessExplorer
   });
+  return newState;
 };
-const replaceTree = (newNode, patches) => {
-  patches.push({
-    type: Replace,
-    nodes: treeToArray(newNode)
-  });
+
+const handleDoubleClick = (state, index = undefined) => {
+  const {
+    focusedIndex
+  } = state;
+  return toggleIndex(state, Number(index === undefined ? focusedIndex : index));
 };
-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 handleFocus = state => {
+  return {
+    ...state,
+    focused: true
+  };
 };
-const appendPatches = (patches, newPatches) => {
-  for (const patch of newPatches) {
-    appendPatch(patches, patch);
-  }
+
+const state = {
+  connected: false
 };
-const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
-  const nodePatches = compareNodes(oldNode.node, newNode.node);
-  if (nodePatches === null) {
-    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
-    replaceTree(newNode, patches);
-    return nextChildIndex;
-  }
-  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-  const childPatches = [];
-  if (hasChildrenToCompare) {
-    diffChildren(oldNode.children, newNode.children, childPatches);
-  }
-  if (nodePatches.length === 0 && childPatches.length === 0) {
-    return currentChildIndex;
+const isConnected = () => {
+  const {
+    connected
+  } = state;
+  return connected;
+};
+const invoke = (method, ...params) => invoke$4(method, ...params);
+const set$1 = rpc => {
+  set$5(rpc);
+  state.connected = true;
+};
+
+const handleMessagePort = async (port, viewletCommandMap, setAsRendererProcess = true) => {
+  const executeViewletCommand = async (uid, command, ...args) => {
+    const fn = viewletCommandMap[`ProcessExplorer.${command}`];
+    if (typeof fn !== 'function') {
+      throw new TypeError(`Viewlet command not found: ${command}`);
+    }
+    await fn(uid, ...args);
+    await invoke$3('Viewlet.requestRender', uid);
+  };
+  const rpc = await create$7({
+    commandMap: {
+      'Viewlet.executeViewletCommand': executeViewletCommand
+    },
+    messagePort: port
+  });
+  if (setAsRendererProcess) {
+    set$1(rpc);
   }
-  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
-  patches.push(...nodePatches);
-  appendPatches(patches, childPatches);
-  return nextChildIndex;
 };
-const diffRootNode = (oldNode, newNode, patches) => {
-  const nodePatches = compareNodes(oldNode.node, newNode.node);
-  if (nodePatches === null) {
-    replaceTree(newNode, patches);
-    return;
-  }
-  if (nodePatches.length > 0) {
-    patches.push(...nodePatches);
+
+const killProcess = async (state, index = undefined) => {
+  const {
+    focusedIndex,
+    uid,
+    visibleProcesses
+  } = state;
+  const resolvedIndex = index === undefined ? focusedIndex : index;
+  const process = visibleProcesses[resolvedIndex];
+  if (!process || process.synthetic) {
+    return state;
   }
-  if (oldNode.children.length > 0 || newNode.children.length > 0) {
-    diffChildren(oldNode.children, newNode.children, patches);
+  const processExplorer = process.source === 'remote' ? RemoteProcessExplorer : ProcessExplorer$2;
+  const killPromise = processExplorer.invoke('Process.kill', process.pid);
+  if (process.name === 'process-explorer') {
+    dispose$4(uid);
+    void killPromise.catch(() => {});
+    return toProcessExplorerRpcClosedState(state);
   }
+  await killPromise;
+  return state;
 };
-const diffChildren = (oldChildren, newChildren, patches) => {
-  const maxLength = Math.max(oldChildren.length, newChildren.length);
-  let currentChildIndex = -1;
-  const indicesToRemove = [];
-  for (let i = 0; i < maxLength; i++) {
-    const oldNode = oldChildren[i];
-    const newNode = newChildren[i];
-    if (!oldNode && !newNode) {
-      continue;
-    }
-    if (!oldNode) {
-      currentChildIndex = navigateToParent(patches, currentChildIndex);
-      addTree(newNode, patches);
-      continue;
-    }
-    if (!newNode) {
-      indicesToRemove.push(i);
-      continue;
-    }
-    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
-  }
-  navigateToParent(patches, currentChildIndex);
-  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
-    patches.push({
-      type: RemoveChild,
-      index: indicesToRemove[j]
-    });
+
+const getErrorCode = (error, fallback) => {
+  if (!error || typeof error !== 'object') {
+    return fallback;
   }
-};
-const diffTrees = (oldTree, newTree, patches, path) => {
-  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
-    diffRootNode(oldTree[0], newTree[0], patches);
-    return;
+  const code = 'code' in error ? error.code : undefined;
+  if (typeof code !== 'string' || !code) {
+    return fallback;
   }
-  diffChildren(oldTree, newTree, patches);
+  return code;
 };
 
-const removeTrailingNavigationPatches = patches => {
-  while (patches.length > 0) {
-    const patch = patches.at(-1);
-    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling && patch.type !== MultiNavigation) {
-      break;
-    }
-    patches.pop();
+const getMeasureMemory = () => {
+  const {
+    measureUserAgentSpecificMemory
+  } = performance;
+  if (typeof measureUserAgentSpecificMemory !== 'function') {
+    return undefined;
   }
-  return patches;
+  return measureUserAgentSpecificMemory.bind(performance);
 };
 
-const diffTree = (oldNodes, newNodes) => {
-  // Step 1: Convert flat arrays to tree structures
-  const oldTree = arrayToTree(oldNodes);
-  const newTree = arrayToTree(newNodes);
-  // Step 3: Compare the trees
-  const patches = [];
-  diffTrees(oldTree, newTree, patches, []);
-  // Remove trailing navigation patches since they serve no purpose
-  return removeTrailingNavigationPatches(patches);
+const isValidMemoryValue = value => {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
 };
 
-const Grid = 'grid';
-const GridCell = 'gridcell';
-const None = 'none';
-const Row$1 = 'row';
-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';
-const RowFocused = 'ProcessExplorerRowFocused';
-const Table = 'ProcessExplorerTable';
-const TableBody = 'ProcessExplorerTableBody';
-const TableHead = 'ProcessExplorerTableHead';
-const Viewlet = 'Viewlet';
-const ProcessExplorer = 'ProcessExplorer';
-
-const HandleBlur = 1;
-const HandleClick = 2;
-const HandleContextMenu = 3;
-const HandleDoubleClick = 4;
-const HandleFocus = 5;
-const HandlePointerDown = 6;
-
-const formatMemory = memory => {
-  if (memory < 1000) {
-    return `${memory} B`;
+const QueryOrHashRegex = /[?#]/;
+const getUrlName = url => {
+  if (!url || url === 'cross-origin-url') {
+    return url;
   }
-  if (memory < 1000 ** 2) {
-    return `${(memory / 1000).toFixed(1)} kB`;
+  if (URL.canParse(url)) {
+    const parsed = new URL(url);
+    const parts = parsed.pathname.split('/').filter(Boolean);
+    return parts.at(-1) || parsed.hostname || url;
   }
-  if (memory < 1000 ** 3) {
-    return `${(memory / 1000 ** 2).toFixed(1)} MB`;
+  const withoutQuery = url.split(QueryOrHashRegex, 1)[0];
+  const parts = withoutQuery.split('/').filter(Boolean);
+  return parts.at(-1) || url;
+};
+
+const getAttributionName = attribution => {
+  const scope = attribution.scope || 'memory';
+  const url = attribution.url ? getUrlName(attribution.url) : '';
+  if (url) {
+    return `${scope}: ${url}`;
   }
-  if (memory < 1000 ** 4) {
-    return `${(memory / 1000 ** 3).toFixed(1)} GB`;
+  return scope;
+};
+
+const getBreakdownName = (entry, index) => {
+  if (entry.attribution && entry.attribution.length > 0) {
+    return entry.attribution.map(getAttributionName).join(', ');
   }
-  return `${(memory / 1000 ** 4).toFixed(1)} TB`;
+  if (entry.types && entry.types.length > 0) {
+    return entry.types.join(', ');
+  }
+  return `breakdown ${index + 1}`;
 };
 
-const Focusable = 0;
+const WindowPid = -1;
 
-const tableHeadNode = {
-  childCount: 1,
-  className: TableHead,
-  role: RowGroup,
-  type: THead
-};
-const headerRowNode = {
-  childCount: 3,
-  className: Row,
-  role: Row$1,
-  type: Tr
+const toBreakdownProcess = (entry, index) => {
+  const name = getBreakdownName(entry, index);
+  return {
+    cmd: name,
+    memory: entry.bytes,
+    name,
+    pid: -2 - index,
+    ppid: WindowPid,
+    synthetic: true
+  };
 };
-const headerCellNode = {
-  childCount: 1,
-  className: HeaderCell,
-  type: Th
+
+const getFrontendMemoryUsage = async rootPid => {
+  const measureMemory = getMeasureMemory();
+  if (!measureMemory) {
+    return [];
+  }
+  try {
+    const measurement = await measureMemory();
+    if (!isValidMemoryValue(measurement.bytes)) {
+      return [];
+    }
+    const breakdown = measurement.breakdown || [];
+    const breakdownProcesses = breakdown.filter(entry => isValidMemoryValue(entry.bytes) && entry.bytes > 0).map(toBreakdownProcess);
+    return [{
+      cmd: 'window',
+      memory: measurement.bytes,
+      name: 'window',
+      pid: WindowPid,
+      ppid: rootPid,
+      synthetic: true
+    }, ...breakdownProcesses];
+  } catch {
+    return [];
+  }
 };
-const processExplorer = {
-  childCount: 1,
-  className: mergeClassNames(Viewlet, ProcessExplorer),
-  role: None,
-  type: Div
+
+const createGroup = (name, source, processes, rootPid) => {
+  const groupId = `${source}:group`;
+  const group = {
+    cmd: name,
+    memory: 0,
+    name,
+    parentTreeId: '',
+    pid: 0,
+    ppid: 0,
+    source,
+    synthetic: true,
+    treeId: groupId
+  };
+  const groupedProcesses = processes.map(process => ({
+    ...process,
+    parentTreeId: process.pid === rootPid ? groupId : `${source}:${process.ppid}`,
+    source,
+    treeId: `${source}:${process.pid}`
+  }));
+  return [group, ...groupedProcesses];
 };
-const messageNode = {
-  childCount: 1,
-  className: Message,
-  type: Div
+const groupProcesses = (localProcesses, localRootPid, remoteProcesses, remoteRootPid) => {
+  return [...createGroup('Local', 'local', localProcesses, localRootPid), ...createGroup('Remote', 'remote', remoteProcesses, remoteRootPid)];
 };
-const getRowClassName = focused => {
-  if (focused) {
-    return mergeClassNames(Row, RowFocused);
+
+const getErrorMessage = error => {
+  if (error instanceof Error) {
+    return error.message;
   }
-  return Row;
+  return String(error);
 };
-const getAriaExpanded = process => {
-  switch (process.flags) {
-    case Collapsed:
-      return false;
-    case Expanded:
-      return true;
-    default:
-      return undefined;
+const prepareError = async error => {
+  try {
+    return await prepare(error);
+  } catch {
+    return {
+      codeFrame: undefined,
+      message: getErrorMessage(error),
+      stack: undefined
+    };
   }
 };
-const getCellDom = (className, value, index) => {
-  return [{
-    childCount: 1,
-    className,
-    'data-index': index,
-    name: String(index),
-    role: GridCell,
-    tabIndex: -1,
-    type: Td
-  }, text(value)];
+
+const conceptualChildNames = ['embeds-process', 'file-system-process', 'file-watcher-process', 'process-explorer', 'search-process', 'terminal-process'];
+const reparentSharedProcessChildren = processes => {
+  const sharedProcess = processes.find(process => process.name === 'shared-process');
+  if (!sharedProcess) {
+    return processes;
+  }
+  return processes.map(process => {
+    if (process.ppid === sharedProcess.pid || !conceptualChildNames.includes(process.name)) {
+      return process;
+    }
+    return {
+      ...process,
+      ppid: sharedProcess.pid
+    };
+  });
 };
-const shouldUseWideNameColumn = visibleProcesses => {
-  return visibleProcesses.some(process => process.name.toLowerCase().includes('webcontentsview'));
+
+const getFocusedIndex = (oldFocusedIndex, visibleProcesses) => {
+  if (visibleProcesses.length === 0) {
+    return -1;
+  }
+  if (oldFocusedIndex < 0) {
+    return 0;
+  }
+  return Math.min(oldFocusedIndex, visibleProcesses.length - 1);
 };
-const getHeaderDom = visibleProcesses => {
-  const useWideNameColumn = shouldUseWideNameColumn(visibleProcesses);
-  return [tableHeadNode, headerRowNode, ...['Name', 'PID', 'Memory'].flatMap((label, index) => [{
-    ...headerCellNode,
-    ...(index === 0 && useWideNameColumn && {
-      className: mergeClassNames(HeaderCell, NameHeaderCellWide)
-    })
-  }, text(label)])];
+const listProcesses = async (processExplorer, rootPid, pidMap) => {
+  if (pidMap) {
+    return processExplorer.invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false, pidMap);
+  }
+  return processExplorer.invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, false);
 };
-const getRowDom = (process, index, focused) => {
-  return [{
-    ariaExpanded: getAriaExpanded(process),
-    ariaLevel: process.depth,
-    childCount: 3,
-    className: getRowClassName(focused),
-    'data-index': index,
-    name: String(index),
-    role: Row$1,
-    tabIndex: focused ? 0 : -1,
-    title: process.cmd,
-    type: Tr
-  }, ...getCellDom(mergeClassNames(Cell, NameCell, `ProcessExplorerIndent-${process.depth}`), process.name, index), ...getCellDom(Cell, process.synthetic ? '' : String(process.pid), index), ...getCellDom(Cell, process.synthetic ? '' : formatMemory(process.memory), index)];
+const getRootPid = async (processExplorer, rootPid, includeElectronData) => {
+  if (rootPid !== -1) {
+    return rootPid;
+  }
+  return processExplorer.invoke('ProcessId.getMainProcessId', {
+    includeElectronData
+  });
 };
-const getBodyDom = state => {
+const refresh = async state => {
   const {
+    collapsedPids,
     focusedIndex,
-    visibleProcesses
+    includeFrontendMemoryUsage,
+    platform,
+    rootPid: stateRootPid
   } = state;
-  return [{
-    childCount: visibleProcesses.length,
-    className: TableBody,
-    role: RowGroup,
-    type: TBody
-  }, ...visibleProcesses.flatMap((process, index) => getRowDom(process, index, index === focusedIndex))];
-};
-const getErrorSectionDom = (value, type) => {
-  if (!value) {
-    return [];
+  if (platform === Web) {
+    return {
+      ...state,
+      initial: false,
+      message: 'Process Explorer is not supported on web.'
+    };
+  }
+  try {
+    await initializeProcessExplorer(platform);
+    const includeElectronData = platform === Electron;
+    const rootPid = await getRootPid(ProcessExplorer$2, stateRootPid, includeElectronData);
+    const pidMap = includeElectronData ? await invoke$5('CreatePidMap.createPidMap') : undefined;
+    const processes = await listProcesses(ProcessExplorer$2, rootPid, pidMap);
+    const frontendMemoryProcesses = includeFrontendMemoryUsage ? await getFrontendMemoryUsage(rootPid) : [];
+    const allProcesses = [...processes, ...frontendMemoryProcesses];
+    const localProcesses = platform === Electron ? reparentSharedProcessChildren(allProcesses) : allProcesses;
+    let displayedProcesses = localProcesses;
+    if (platform === Electron && has()) {
+      const remoteRootPid = await getRootPid(RemoteProcessExplorer, -1, false);
+      const remoteProcesses = await listProcesses(RemoteProcessExplorer, remoteRootPid);
+      displayedProcesses = groupProcesses(localProcesses, rootPid, remoteProcesses, remoteRootPid);
+    }
+    const visibleProcesses = getVisibleProcesses(displayedProcesses, collapsedPids, rootPid);
+    return {
+      ...state,
+      errorCode: '',
+      errorCodeFrame: '',
+      errorMessage: '',
+      errorStack: '',
+      focusedIndex: getFocusedIndex(focusedIndex, visibleProcesses),
+      initial: false,
+      message: '',
+      processes: displayedProcesses,
+      rootPid,
+      visibleProcesses
+    };
+  } catch (error) {
+    const prettyError = await prepareError(error);
+    return {
+      ...state,
+      errorCode: getErrorCode(error, ProcessExplorerRefreshFailed),
+      errorCodeFrame: prettyError.codeFrame || '',
+      errorMessage: prettyError.message || getErrorMessage(error),
+      errorStack: prettyError.stack || '',
+      initial: false,
+      message: ''
+    };
   }
-  return [{
-    childCount: 1,
-    type
-  }, text(value)];
 };
+
 const hasError = state => {
   const {
     errorCode,
@@ -3370,65 +3390,52 @@ const hasError = state => {
   } = state;
   return Boolean(errorCode || errorMessage || errorCodeFrame || errorStack);
 };
-const getMessageDom = message => {
-  return [processExplorer, messageNode, text(message)];
+const loadContent = async state => {
+  const newState = await refresh(state);
+  if (!hasError(newState) && !newState.message) {
+    start(newState.uid, newState.updateInterval);
+  }
+  return {
+    error: undefined,
+    state: newState
+  };
 };
-const getErrorDom = state => {
-  const {
-    errorCode,
-    errorCodeFrame,
-    errorMessage,
-    errorStack
-  } = state;
-  const errorCodeDom = getErrorSectionDom(errorCode, Div);
-  const messageDom = getErrorSectionDom(errorMessage, Div);
-  const codeFrameDom = getErrorSectionDom(errorCodeFrame, Pre);
-  const stackDom = getErrorSectionDom(errorStack, Pre);
-  const childCount = errorCodeDom.length / 2 + messageDom.length / 2 + codeFrameDom.length / 2 + stackDom.length / 2;
-  return [processExplorer, {
-    childCount,
-    className: Error$1,
-    type: Div
-  }, ...errorCodeDom, ...messageDom, ...codeFrameDom, ...stackDom];
+
+const getIndentRule = depth => {
+  const paddingLeft = Math.max(0, depth - 1) * 1.5;
+  return `.ProcessExplorerNameCell.ProcessExplorerIndent-${depth} {
+  padding-left: ${paddingLeft}ch;
+}`;
 };
-const getTableDom = state => {
-  const {
-    visibleProcesses
-  } = state;
-  return [processExplorer, {
-    ariaLabel: 'Process Explorer',
-    ariaRowCount: visibleProcesses.length + 1,
-    childCount: 2,
-    className: Table,
-    onBlur: HandleBlur,
-    onClick: HandleClick,
-    onContextMenu: HandleContextMenu,
-    onDblClick: HandleDoubleClick,
-    onFocus: HandleFocus,
-    onPointerDown: HandlePointerDown,
-    role: Grid,
-    tabIndex: Focusable,
-    type: Table$1
-  }, ...getHeaderDom(visibleProcesses), ...getBodyDom(state)];
+const getCss = depths => {
+  return depths.map(getIndentRule).join('\n');
 };
-const getDom = state => {
-  const {
-    initial,
-    message
-  } = state;
-  if (initial) {
+
+const getUniqueDepths = visibleProcesses => {
+  return [...new Set(visibleProcesses.map(process => process.depth))];
+};
+
+const renderCss = (oldState, newState) => {
+  const depths = getUniqueDepths(newState.visibleProcesses);
+  const css = getCss(depths);
+  return [SetCss, newState.uid, css];
+};
+
+const renderFocus = (oldState, newState) => {
+  if (!newState.focused || oldState.focusedIndex === newState.focusedIndex) {
     return [];
   }
-  if (message) {
-    return getMessageDom(message);
-  }
-  if (hasError(state)) {
-    return getErrorDom(state);
+  if (newState.focusedIndex < 0) {
+    return [FocusSelector, '.ProcessExplorerTable'];
   }
-  return getTableDom(state);
+  return [FocusSelector, `[data-index="${newState.focusedIndex}"]`];
 };
-const renderItems = (oldState, newState) => {
-  return [SetDom2, newState.uid, getDom(newState)];
+
+const renderFocusContext = (oldState, newState) => {
+  if (oldState.focused === newState.focused) {
+    return [];
+  }
+  return [SetFocusContext, newState.uid, newState.focused ? FocusExplorer : Empty];
 };
 
 const renderIncremental = (oldState, newState) => {
@@ -3627,6 +3634,7 @@ const commandMap = {
   'ProcessExplorer.focusNext': wrapCommand(focusNext),
   'ProcessExplorer.focusPrevious': wrapCommand(focusPrevious),
   'ProcessExplorer.getCommandIds': getCommandIds,
+  'ProcessExplorer.getComponentDom': getComponentDom,
   'ProcessExplorer.getComponentState': getComponentState,
   'ProcessExplorer.getKeyBindings': getKeyBindings,
   'ProcessExplorer.getMenuEntries': wrapGetter(getMenuEntries),