@lvce-editor/process-explorer-worker 3.3.0 → 3.5.0

package/index.js

@@ -119,7 +119,7 @@ const terminate = () => {
   globalThis.close();
 };
 
-const None$1 = 0;
+const None$2 = 0;
 const Collapsed = 1;
 const Expanded = 2;
 
@@ -144,7 +144,7 @@ const getChildren = (processes, collapsedPids, process, depth) => {
 };
 const withChildren = (processes, collapsedPids, process, depth) => {
   const processHasChildren = hasChildren(processes, process.pid);
-  let flags = None$1;
+  let flags = None$2;
   if (processHasChildren && collapsedPids.includes(process.pid)) {
     flags = Collapsed;
   } else if (processHasChildren) {
@@ -181,15 +181,25 @@ const collapseAll = state => {
 };
 
 const {
+  dispose: dispose$3,
   get: get$2,
   getCommandIds,
+  getKeys: getKeys$1,
   registerCommands,
   set: set$9,
   wrapCommand,
+  wrapGetter,
   wrapLoadContent
 } = create$e();
 
-const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0, assetDir = '') => {
+const getIncludeFrontendMemoryUsage = args => {
+  if (!args || typeof args !== 'object') {
+    return false;
+  }
+  const createArgs = args;
+  return createArgs.includeFrontendMemoryUsage === true;
+};
+const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0, assetDir = '') => {
   const state = {
     assetDir,
     collapsedPids: [],
@@ -200,6 +210,7 @@ const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0,
     focused: false,
     focusedIndex: -1,
     height,
+    includeFrontendMemoryUsage: getIncludeFrontendMemoryUsage(args),
     initial: true,
     parentUid,
     platform,
@@ -215,264 +226,6 @@ const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0,
   return state;
 };
 
-const isEqual$1 = (oldState, newState) => {
-  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
-};
-
-const isEqual = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.visibleProcesses === newState.visibleProcesses;
-};
-
-const RenderItems = 1;
-const RenderFocus = 2;
-const RenderFocusContext = 3;
-
-const modules = [isEqual, isEqual$1, isEqual$1];
-const numbers = [RenderItems, RenderFocus, RenderFocusContext];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
-  }
-  return diffResult;
-};
-
-const diff2 = uid => {
-  const {
-    oldState,
-    scheduledState
-  } = get$2(uid);
-  return diff(oldState, scheduledState);
-};
-
-const expandAll = state => {
-  const collapsedPids = [];
-  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
-  return {
-    ...state,
-    collapsedPids,
-    visibleProcesses
-  };
-};
-
-const focusIndex = (state, index) => {
-  if (index < -1 || index >= state.visibleProcesses.length) {
-    return state;
-  }
-  return {
-    ...state,
-    focusedIndex: index
-  };
-};
-
-const focusFirst = state => {
-  if (state.visibleProcesses.length === 0) {
-    return state;
-  }
-  return focusIndex(state, 0);
-};
-
-const focusLast = state => {
-  if (state.visibleProcesses.length === 0) {
-    return state;
-  }
-  return focusIndex(state, state.visibleProcesses.length - 1);
-};
-
-const focusNext = state => {
-  if (state.focusedIndex >= state.visibleProcesses.length - 1) {
-    return state;
-  }
-  return focusIndex(state, state.focusedIndex + 1);
-};
-
-const focusPrevious = state => {
-  if (state.focusedIndex === -1 && state.visibleProcesses.length > 0) {
-    return focusIndex(state, state.visibleProcesses.length - 1);
-  }
-  if (state.focusedIndex <= 0) {
-    return state;
-  }
-  return focusIndex(state, state.focusedIndex - 1);
-};
-
-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 ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const TargetName = 'event.target.name';
-
-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 Script = 2;
-
-const CtrlCmd = 1 << 11 >>> 0;
-
-const Electron = 2;
-const Remote = 3;
-
-const DebugWorker = 55;
-const EditorWorker = 99;
-const ErrorWorker = 3308;
-const FileSystemWorker$1 = 209;
-const IconThemeWorker = 7009;
-const OpenerWorker = 4561;
-const RendererWorker$1 = 1;
-const TestWorker = 9001;
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetDom2 = 'Viewlet.setDom2';
-const SetFocusContext = 'Viewlet.setFocusContext';
-
-const Empty = 0;
-const FocusExplorer = 13;
-
-const getKeyBindings$1 = () => {
-  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 toggleIndex = (state, index) => {
-  const process = state.visibleProcesses[index];
-  if (!process || process.flags === None$1) {
-    return state;
-  }
-  const collapsedPids = state.collapsedPids.includes(process.pid) ? state.collapsedPids.filter(pid => pid !== process.pid) : [...state.collapsedPids, process.pid];
-  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
-  return {
-    ...state,
-    collapsedPids,
-    focusedIndex: Math.min(index, visibleProcesses.length - 1),
-    visibleProcesses
-  };
-};
-
-const getParentIndex = state => {
-  const process = state.visibleProcesses[state.focusedIndex];
-  if (!process) {
-    return -1;
-  }
-  for (let i = state.focusedIndex - 1; i >= 0; i--) {
-    const otherProcess = state.visibleProcesses[i];
-    if (otherProcess.depth === process.depth - 1) {
-      return i;
-    }
-  }
-  return -1;
-};
-const handleArrowLeft = state => {
-  const process = state.visibleProcesses[state.focusedIndex];
-  if (!process) {
-    return state;
-  }
-  if (process.flags === Expanded) {
-    return toggleIndex(state, state.focusedIndex);
-  }
-  const parentIndex = getParentIndex(state);
-  if (parentIndex === -1) {
-    return state;
-  }
-  return focusIndex(state, parentIndex);
-};
-
-const handleArrowRight = state => {
-  const {
-    focusedIndex,
-    visibleProcesses
-  } = state;
-  const process = visibleProcesses[focusedIndex];
-  if (!process) {
-    return state;
-  }
-  if (process.flags === Collapsed) {
-    return toggleIndex(state, focusedIndex);
-  }
-  const nextProcess = visibleProcesses[focusedIndex + 1];
-  if (process.flags === Expanded && nextProcess && nextProcess.depth > process.depth) {
-    return focusIndex(state, focusedIndex + 1);
-  }
-  return state;
-};
-
-const handleBlur = state => {
-  return {
-    ...state,
-    focused: false
-  };
-};
-
-const handleClickAt = (state, index) => {
-  return focusIndex(state, index);
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -1717,6 +1470,58 @@ const create = rpcId => {
   };
 };
 
+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 TargetName = 'event.target.name';
+
+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 Script = 2;
+
+const CtrlCmd = 1 << 11 >>> 0;
+
+const None$1 = 0;
+
+const Electron = 2;
+const Remote = 3;
+
+const DebugWorker = 55;
+const EditorWorker = 99;
+const ErrorWorker = 3308;
+const FileSystemWorker$1 = 209;
+const IconThemeWorker = 7009;
+const OpenerWorker = 4561;
+const RendererWorker$1 = 1;
+const TestWorker = 9001;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetPatches = 'Viewlet.setPatches';
+
+const Empty = 0;
+const FocusExplorer = 13;
+
 const {
   set: set$7
 } = create(EditorWorker);
@@ -1747,7 +1552,7 @@ const {
 } = create(IconThemeWorker);
 
 const {
-  dispose,
+  dispose: dispose$2,
   invoke: invoke$1,
   invokeAndTransfer,
   registerMockRpc,
@@ -1974,7 +1779,7 @@ const confirm = async (message, options) => {
 const getRecentlyOpened = async () => {
   return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
-const getKeyBindings = async () => {
+const getKeyBindings$1 = async () => {
   return invoke$1('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
@@ -2195,7 +2000,7 @@ const RendererWorker = {
   confirm,
   createViewlet,
   disableExtension,
-  dispose,
+  dispose: dispose$2,
   disposeEditor,
   enableExtension,
   getActiveEditorId,
@@ -2214,7 +2019,7 @@ const RendererWorker = {
   getFolderIcon,
   getFolderSize,
   getIcons,
-  getKeyBindings,
+  getKeyBindings: getKeyBindings$1,
   getLogsDir,
   getMarkdownDom,
   getNodeVersion,
@@ -2319,52 +2124,329 @@ const RendererWorker = {
   writeFile
 };
 
+const debugProcess = async (state, index = state.focusedIndex) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  await invoke$1('AttachDebugger.attachDebugger', process.pid);
+  return state;
+};
+
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focused === newState.focused && oldState.focusedIndex === newState.focusedIndex;
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.focusedIndex === newState.focusedIndex && oldState.visibleProcesses === newState.visibleProcesses;
+};
+
+const RenderItems = 1;
+const RenderFocus = 2;
+const RenderFocusContext = 3;
+const RenderIncremental = 4;
+
+const modules = [isEqual, isEqual$1, isEqual$1];
+const numbers = [RenderIncremental, RenderFocus, RenderFocusContext];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    oldState,
+    scheduledState
+  } = get$2(uid);
+  return diff(oldState, scheduledState);
+};
+
+const processExplorerUpdateInterval = 1000;
+
+const intervals = new Map();
+const pending = new Set();
+const dispose$1 = 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$1(uid);
+    return;
+  }
+  if (pending.has(uid)) {
+    return;
+  }
+  pending.add(uid);
+  try {
+    await invoke$1('ProcessExplorer.update');
+  } catch (error) {
+    console.error(error);
+  } finally {
+    pending.delete(uid);
+  }
+};
+const start = (uid, interval = processExplorerUpdateInterval) => {
+  if (interval === 0 || intervals.has(uid)) {
+    return;
+  }
+  const intervalId = setInterval(() => {
+    void update(uid);
+  }, interval);
+  intervals.set(uid, intervalId);
+};
+
+const dispose = uid => {
+  dispose$1(uid);
+  dispose$3(uid);
+};
+
+const expandAll = state => {
+  const collapsedPids = [];
+  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
+  return {
+    ...state,
+    collapsedPids,
+    visibleProcesses
+  };
+};
+
+const focusIndex = (state, index) => {
+  if (index < -1 || index >= state.visibleProcesses.length) {
+    return state;
+  }
+  return {
+    ...state,
+    focusedIndex: index
+  };
+};
+
+const focusFirst = state => {
+  if (state.visibleProcesses.length === 0) {
+    return state;
+  }
+  return focusIndex(state, 0);
+};
+
+const focusLast = state => {
+  if (state.visibleProcesses.length === 0) {
+    return state;
+  }
+  return focusIndex(state, state.visibleProcesses.length - 1);
+};
+
+const focusNext = state => {
+  if (state.focusedIndex >= state.visibleProcesses.length - 1) {
+    return state;
+  }
+  return focusIndex(state, state.focusedIndex + 1);
+};
+
+const focusPrevious = state => {
+  if (state.focusedIndex === -1 && state.visibleProcesses.length > 0) {
+    return focusIndex(state, state.visibleProcesses.length - 1);
+  }
+  if (state.focusedIndex <= 0) {
+    return state;
+  }
+  return focusIndex(state, state.focusedIndex - 1);
+};
+
+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 isDebuggable = command => {
   return command.includes('node ') || command.includes('node.exe') || command.includes('node.mojom.NodeService');
 };
 
 const KillProcess = 'Kill Process';
 const DebugProcess = 'Debug Process';
-const getMenuItems = process => {
-  const menuItems = [{
+
+const getMenuEntries = state => {
+  const process = state.visibleProcesses[state.focusedIndex];
+  if (!process) {
+    return [];
+  }
+  const menuEntries = [{
+    args: [state.focusedIndex],
+    command: 'ProcessExplorer.killProcess',
+    flags: None$1,
+    id: 'killProcess',
     label: KillProcess
   }];
   if (isDebuggable(process.cmd)) {
-    menuItems.push({
+    menuEntries.push({
+      args: [state.focusedIndex],
+      command: 'ProcessExplorer.debugProcess',
+      flags: None$1,
+      id: 'debugProcess',
       label: DebugProcess
     });
   }
-  return menuItems;
+  return menuEntries;
 };
 
-const SigTerm = 'SIGTERM';
+const ProcessExplorer$1 = 29;
 
-const handleContextMenuSelect = async (label, process) => {
-  switch (label) {
-    case DebugProcess:
-      await invoke$1('AttachDebugger.attachDebugger', process.pid);
-      return;
-    case KillProcess:
-      await invoke$1('Process.kill', process.pid, SigTerm);
-      return;
-    default:
-      return;
-  }
+const getMenuEntryIds = () => {
+  return [ProcessExplorer$1];
 };
-const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0) => {
+
+const toggleIndex = (state, index) => {
   const process = state.visibleProcesses[index];
+  if (!process || process.flags === None$2) {
+    return state;
+  }
+  const collapsedPids = state.collapsedPids.includes(process.pid) ? state.collapsedPids.filter(pid => pid !== process.pid) : [...state.collapsedPids, process.pid];
+  const visibleProcesses = getVisibleProcesses(state.processes, collapsedPids, state.rootPid);
+  return {
+    ...state,
+    collapsedPids,
+    focusedIndex: Math.min(index, visibleProcesses.length - 1),
+    visibleProcesses
+  };
+};
+
+const getParentIndex = state => {
+  const process = state.visibleProcesses[state.focusedIndex];
+  if (!process) {
+    return -1;
+  }
+  for (let i = state.focusedIndex - 1; i >= 0; i--) {
+    const otherProcess = state.visibleProcesses[i];
+    if (otherProcess.depth === process.depth - 1) {
+      return i;
+    }
+  }
+  return -1;
+};
+const handleArrowLeft = state => {
+  const process = state.visibleProcesses[state.focusedIndex];
   if (!process) {
     return state;
   }
-  const menuItems = getMenuItems(process);
-  const event = await invoke$1('ElectronContextMenu.openContextMenu', menuItems, x, y, process);
-  if (event.type === 'close' || !event.data) {
+  if (process.flags === Expanded) {
+    return toggleIndex(state, state.focusedIndex);
+  }
+  const parentIndex = getParentIndex(state);
+  if (parentIndex === -1) {
+    return state;
+  }
+  return focusIndex(state, parentIndex);
+};
+
+const handleArrowRight = state => {
+  const {
+    focusedIndex,
+    visibleProcesses
+  } = state;
+  const process = visibleProcesses[focusedIndex];
+  if (!process) {
     return state;
   }
-  await handleContextMenuSelect(event.data, process);
+  if (process.flags === Collapsed) {
+    return toggleIndex(state, focusedIndex);
+  }
+  const nextProcess = visibleProcesses[focusedIndex + 1];
+  if (process.flags === Expanded && nextProcess && nextProcess.depth > process.depth) {
+    return focusIndex(state, focusedIndex + 1);
+  }
   return state;
 };
 
+const handleBlur = state => {
+  return {
+    ...state,
+    focused: false
+  };
+};
+
+const handleClickAt = (state, index) => {
+  return focusIndex(state, index);
+};
+
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
+};
+
+const handleContextMenu = async (state, index = state.focusedIndex, x = 0, y = 0) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  const newState = {
+    ...state,
+    focused: false,
+    focusedIndex: index
+  };
+  set$9(state.uid, state, newState);
+  await show2(state.uid, ProcessExplorer$1, x, y, {
+    index,
+    menuId: ProcessExplorer$1
+  });
+  return newState;
+};
+
 const handleDoubleClick = (state, index = state.focusedIndex) => {
   return toggleIndex(state, index);
 };
@@ -2376,6 +2458,97 @@ const handleFocus = state => {
   };
 };
 
+const SigTerm = 'SIGTERM';
+
+const killProcess = async (state, index = state.focusedIndex) => {
+  const process = state.visibleProcesses[index];
+  if (!process) {
+    return state;
+  }
+  await invoke$1('Process.kill', process.pid, SigTerm);
+  return state;
+};
+
+const WindowPid = -1;
+const isValidMemoryValue = value => {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+};
+const getMeasureMemory = () => {
+  const {
+    measureUserAgentSpecificMemory
+  } = performance;
+  if (typeof measureUserAgentSpecificMemory !== 'function') {
+    return undefined;
+  }
+  return measureUserAgentSpecificMemory.bind(performance);
+};
+const getUrlName = url => {
+  if (!url || url === 'cross-origin-url') {
+    return url;
+  }
+  try {
+    const parsed = new URL(url);
+    const parts = parsed.pathname.split('/').filter(Boolean);
+    return parts.at(-1) || parsed.hostname || url;
+  } catch {
+    const withoutQuery = url.split(/[?#]/, 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}`;
+  }
+  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(', ');
+  }
+  return `breakdown ${index + 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 [];
+  }
+  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 sendMessagePortToProcessExplorer = async port => {
   const rendererWorker = RendererWorker;
   await rendererWorker.sendMessagePortToProcessExplorer(port);
@@ -2468,9 +2641,13 @@ const refresh = async state => {
   try {
     await initializeProcessExplorer(state.platform);
     const includeElectronData = state.platform === Electron;
-    const rootPid = state.rootPid || (await invoke('ProcessId.getMainProcessId', includeElectronData));
+    const rootPid = state.rootPid || (await invoke('ProcessId.getMainProcessId', {
+      includeElectronData
+    }));
     const processes = await invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, includeElectronData);
-    const visibleProcesses = getVisibleProcesses(processes, state.collapsedPids, rootPid);
+    const frontendMemoryProcesses = state.includeFrontendMemoryUsage ? await getFrontendMemoryUsage(rootPid) : [];
+    const allProcesses = [...processes, ...frontendMemoryProcesses];
+    const visibleProcesses = getVisibleProcesses(allProcesses, state.collapsedPids, rootPid);
     return {
       ...state,
       errorCodeFrame: '',
@@ -2478,7 +2655,7 @@ const refresh = async state => {
       errorStack: '',
       focusedIndex: getFocusedIndex(state.focusedIndex, visibleProcesses),
       initial: false,
-      processes,
+      processes: allProcesses,
       rootPid,
       visibleProcesses
     };
@@ -2496,6 +2673,7 @@ const refresh = async state => {
 
 const loadContent = async state => {
   const newState = await refresh(state);
+  start(state.uid);
   return {
     error: undefined,
     state: newState
@@ -2527,6 +2705,267 @@ const text = data => {
   };
 };
 
+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 isKey = key => {
+  return key !== 'type' && key !== 'childCount';
+};
+
+const getKeys = node => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
+};
+
+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 result;
+};
+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--;
+  }
+  return {
+    children,
+    nodesConsumed: totalConsumed
+  };
+};
+
+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) {
+    if (oldNode.uid !== newNode.uid) {
+      patches.push({
+        type: SetReferenceNodeUid,
+        uid: newNode.uid
+      });
+    }
+    return patches;
+  }
+  // Handle text nodes
+  if (oldNode.type === Text && newNode.type === Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
+    }
+    return patches;
+  }
+  // Compare attributes
+  const oldKeys = getKeys(oldNode);
+  const newKeys = getKeys(newNode);
+  // Check for attribute changes
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
+  }
+  // Check for removed attributes
+  for (const key of oldKeys) {
+    if (!Object.hasOwn(newNode, key)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
+    }
+  }
+  return patches;
+};
+
+const treeToArray = node => {
+  const result = [node.node];
+  for (const child of node.children) {
+    result.push(...treeToArray(child));
+  }
+  return result;
+};
+
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+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;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  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);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
+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 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 removeTrailingNavigationPatches = patches => {
+  // Find the last non-navigation patch
+  let lastNonNavigationIndex = -1;
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
+      lastNonNavigationIndex = i;
+      break;
+    }
+  }
+  // Return patches up to and including the last non-navigation patch
+  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 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';
@@ -2579,7 +3018,7 @@ const getPaddingLeft = process => {
     return '0';
   }
   const depthCh = (process.depth - 1) * 1.5;
-  if (process.flags === None$1) {
+  if (process.flags === None$2) {
     return `calc(${depthCh}ch + 17px)`;
   }
   return `${depthCh}ch`;
@@ -2712,12 +3151,21 @@ const renderItems = (oldState, newState) => {
   return [SetDom2, newState.uid, getDom(newState)];
 };
 
+const renderIncremental = (oldState, newState) => {
+  const oldDom = renderItems(oldState, oldState)[2];
+  const newDom = renderItems(newState, newState)[2];
+  const patches = diffTree(oldDom, newDom);
+  return [SetPatches, newState.uid, patches];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderFocus:
       return renderFocus;
     case RenderFocusContext:
       return renderFocusContext;
+    case RenderIncremental:
+      return renderIncremental;
     case RenderItems:
       return renderItems;
     default:
@@ -2774,14 +3222,18 @@ const renderEventListeners = () => {
 const commandMap = {
   'ProcessExplorer.collapseAll': wrapCommand(collapseAll),
   'ProcessExplorer.create': create$d,
+  'ProcessExplorer.debugProcess': wrapCommand(debugProcess),
   'ProcessExplorer.diff2': diff2,
+  'ProcessExplorer.dispose': dispose,
   'ProcessExplorer.expandAll': wrapCommand(expandAll),
   'ProcessExplorer.focusFirst': wrapCommand(focusFirst),
   'ProcessExplorer.focusLast': wrapCommand(focusLast),
   'ProcessExplorer.focusNext': wrapCommand(focusNext),
   'ProcessExplorer.focusPrevious': wrapCommand(focusPrevious),
   'ProcessExplorer.getCommandIds': getCommandIds,
-  'ProcessExplorer.getKeyBindings': getKeyBindings$1,
+  'ProcessExplorer.getKeyBindings': getKeyBindings,
+  'ProcessExplorer.getMenuEntries': wrapGetter(getMenuEntries),
+  'ProcessExplorer.getMenuEntryIds': getMenuEntryIds,
   'ProcessExplorer.handleArrowLeft': wrapCommand(handleArrowLeft),
   'ProcessExplorer.handleArrowRight': wrapCommand(handleArrowRight),
   'ProcessExplorer.handleBlur': wrapCommand(handleBlur),
@@ -2789,11 +3241,13 @@ const commandMap = {
   'ProcessExplorer.handleContextMenu': wrapCommand(handleContextMenu),
   'ProcessExplorer.handleDoubleClick': wrapCommand(handleDoubleClick),
   'ProcessExplorer.handleFocus': wrapCommand(handleFocus),
+  'ProcessExplorer.killProcess': wrapCommand(killProcess),
   'ProcessExplorer.loadContent': wrapLoadContent(loadContent),
   'ProcessExplorer.refresh': wrapCommand(refresh),
   'ProcessExplorer.render2': render2,
   'ProcessExplorer.renderEventListeners': renderEventListeners,
-  'ProcessExplorer.terminate': terminate
+  'ProcessExplorer.terminate': terminate,
+  'ProcessExplorer.update': wrapCommand(refresh)
 };
 
 const sendMessagePortToErrorWorker = async port => {

package/package.json

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