@lvce-editor/static-server 0.91.8 → 0.91.10

package/static/{98fc4d9 → fe7bb55}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -72,58 +72,18 @@ const fn = value => {
   }
 };
 
-const state$C = {
-  pending: Object.create(null)
-};
-const get$i = id => {
-  return state$C.pending[id];
-};
-const has$2 = id => {
-  return id in state$C.pending;
-};
-const set$h = (id, value) => {
-  state$C.pending[id] = value;
-};
-
-const Web$1 = 1;
-const Electron$1 = 2;
-const Remote = 3;
-const Test$1 = 4;
-
-/* istanbul ignore file */
-
-// TODO this should always be completely tree shaken out during build, maybe need to be marked as @__Pure for terser to work
-
-// TODO treeshake this function out when targeting electron
-
-/**
- * @returns {number}
- */
-const getPlatform$2 = () => {
-  return platform;
-};
-const platform = Remote;
+const ENOENT = 'ENOENT';
+const ENOTDIR = 'ENOTDIR';
+const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND';
+const E_COMMAND_NOT_FOUND$1 = 'E_COMMAND_NOT_FOUND';
 
-const getAssetDir$2 = () => {
-  // @ts-ignore
-  {
-    // @ts-ignore
-    return '/98fc4d9';
+let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
+  constructor(id) {
+    super(`Command "${id}" not found (renderer worker)`);
+    this.name = 'CommandNotFoundError';
+    this.code = E_COMMAND_NOT_FOUND$1;
   }
 };
-const assetDir = getAssetDir$2();
-
-const NotFound = 404;
-
-const getText$3 = response => {
-  return response.text();
-};
-const getJson$7 = response => {
-  return response.json();
-};
-const create$1c = (value, options) => {
-  return new Response(value, options);
-};
 
 const Dash = '-';
 const Dot = '.';
@@ -131,108 +91,597 @@ const EmptyString = '';
 const NewLine$2 = '\n';
 const Slash$2 = '/';
 
-/**
- *
- * @param {string} string
- * @param {number|undefined} startIndex
- * @returns
- */
-const getNewLineIndex$2 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
-  }
-  return line;
-};
-
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$2(parent);
-  const childNewLineIndex = getNewLineIndex$2(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
+// TODO rename to widgetFind and group together with other widgets (contextMenu, hover, tooltip)
+const Ajax = 1;
+const Audio$2 = 2;
+const Blob$2 = 4;
+const CacheStorage = 5;
+const Callback = 6;
+const ClipBoard = 7;
+const ColorTheme = 9;
+const ContextMenu$1 = 11;
+const Developer = 12;
+const Dialog$1 = 13;
+const Download = 14;
+const EditorDiagnostics = 15;
+const EditorError = 16;
+const ErrorHandling = 18;
+const ExtensionHostCode = 19;
+const ExtensionMeta = 20;
+const Extensions$1 = 21;
+const FileSystem = 22;
+const Format = 23;
+const IconTheme = 24;
+const ImagePreview = 25;
+const KeyBindings$1 = 26;
+const KeyBindingsInitial = 27;
+const Layout$1 = 28;
+const Listener = 29;
+const LocalStorage$1 = 30;
+const Menu = 31;
+const Navigation = 32;
+const Notification = 33;
+const Open$1 = 34;
+const Preferences = 35;
+const QuickPick$1 = 36;
+const RecentlyOpened = 37;
+const SaveState = 38;
+const SessionReplay = 39;
+const SessionStorage$1 = 40;
+const Test$1 = 41;
+const TestFrameworkComponent = 43;
+const Viewlet = 44;
+const Window = 45;
+const Workbench = 46;
+const Workspace = 47;
+const ContentTracing = 48;
+const OpenNativeFolder$1 = 49;
+const ElectronWindow = 50;
+const Url$1 = 51;
+const Mime = 52;
+const FilePicker = 54;
+const PersistentFileHandle = 55;
+const IndexedDb = 56;
+const Chrome = 57;
+const ElectronBrowserView = 58;
+const Exit = 59;
+const ElectronContextMenu = 60;
+const ElectronClipBoard = 61;
+const SaveFileAs = 62;
+const About$1 = 64;
+const ConfirmPrompt = 65;
+const BulkReplacement = 66;
+const AutoUpdater = 67;
+const IpcParent = 68;
+const NativeHost = 69;
+const RebuildNodePty = 70;
+const DebugSharedProcess = 71;
+const Reload = 72;
+const Prompt$1 = 74;
+const WindowTitle = 75;
+const Focus = 76;
+const PointerCapture = 77;
+const ExtensionHostQuickPick = 78;
+const ExtensionHostDialog = 79;
+const TestFrameWork = 80;
+const ExtensionHostWorkerContentSecurityPolicy = 81;
+const SendMessagePortToElectron = 82;
+const OffscreenCanvas$1 = 83;
+const Debug$1 = 84;
+const Languages = 85;
+const FileWatcher = 86;
+const ExtensionHostBraceCompletion = 114;
+const ExtensionHostDefinition = 115;
+const ExtensionHostOrganizeImports = 117;
+const ExtensionHostSelection = 119;
+const ExtensionHostTabCompletion = 120;
+const ExtensionHostTypeDefinition = 121;
+const ExtensionHostClosingTag = 122;
+const SendMessagePortToRendererProcess = 123;
+const ExtensionHostHover = 124;
+const SendMessagePortToExtensionHostWorker = 125;
+const ExtensionHostManagement = 126;
+const SendMessagePortToSyntaxHighlightingWorker = 127;
+const Transferrable = 128;
+const WebView$2 = 129;
+const SearchProcess = 130;
+const GetEditorSourceActions = 131;
+const ExtensionHostTextSearch = 132;
+const ExtensionStateStorage$2 = 133;
+const GetWindowId = 134;
+const ElectronDialog = 135;
+const Process = 136;
+const ExtensionManagement = 137;
+const Markdown = 138;
+const FileSystemHandle = 139;
+const MouseActions = 140;
+const Timeout = 141;
+const GetActiveEditor = 142;
+const PlatformPaths = 143;
+const MeasureTextHeight = 144;
+const Document = 145;
+const Exec = 146;
+const OAuthServer = 147;
+const LaunchIsolatedExtensionHostWorker = 148;
+const ExtensionNodeRpc = 149;
+const License = 150;
 
-const stringifyError = error => {
-  if (error instanceof DOMException && error.message) {
-    return `DOMException: ${error.message}`;
-  }
-  const errorPrefixes = ['Error: ', 'VError: '];
-  const stringifiedError = `${error}`;
-  for (const errorPrefix of errorPrefixes) {
-    if (stringifiedError.startsWith(errorPrefix)) {
-      return stringifiedError.slice(errorPrefix.length);
-    }
+const getPrefix = commandId => {
+  if (!commandId || typeof commandId !== 'string') {
+    return commandId;
   }
-  return stringifiedError;
-};
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = stringifyError(error);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
+  const dotIndex = commandId.indexOf(Dot);
+  if (dotIndex === -1) {
+    return '';
   }
-  return `${stringifiedError}`;
+  return commandId.slice(0, dotIndex);
 };
-class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      this.codeFrame = error.codeFrame;
-    }
+const getModuleId$2 = commandId => {
+  const prefix = getPrefix(commandId);
+  if (!prefix) {
+    throw new CommandNotFoundError$1(commandId);
   }
-}
-
-const getCss$2 = async relativePath => {
-  try {
-    const url = `${assetDir}${relativePath}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      if (response.status === NotFound) {
-        throw new Error(`File not found ${url}`);
-      }
-      throw new Error(response.statusText);
-    }
-    const text = await getText$3(response);
-    return text;
-  } catch (error) {
-    throw new VError(error, `Failed to load css "${relativePath}"`);
+  switch (prefix) {
+    case 'About':
+      return About$1;
+    case 'Exec':
+      return Exec;
+    case 'Ajax':
+      return Ajax;
+    case 'Audio':
+      return Audio$2;
+    case 'Debug':
+      return Debug$1;
+    case 'AutoUpdater':
+      return AutoUpdater;
+    case 'Document':
+      return Document;
+    case 'Blob':
+      return Blob$2;
+    case 'GetActiveEditor':
+      return GetActiveEditor;
+    case 'BulkReplacement':
+      return BulkReplacement;
+    case 'CacheStorage':
+      return CacheStorage;
+    case 'Callback':
+      return Callback;
+    case 'Chrome':
+      return Chrome;
+    case 'ClipBoard':
+      return ClipBoard;
+    case 'ColorTheme':
+      return ColorTheme;
+    case 'ConfirmPrompt':
+      return ConfirmPrompt;
+    case 'ContentTracing':
+      return ContentTracing;
+    case 'ContextMenu':
+      return ContextMenu$1;
+    case 'DebugSharedProcess':
+      return DebugSharedProcess;
+    case 'Developer':
+      return Developer;
+    case 'Dialog':
+      return Dialog$1;
+    case 'Download':
+      return Download;
+    case 'EditorDiagnostics':
+      return EditorDiagnostics;
+    case 3900:
+      return EditorError;
+    case 'ElectronBrowserView':
+      return ElectronBrowserView;
+    case 'ElectronClipBoard':
+      return ElectronClipBoard;
+    case 'ElectronContextMenu':
+      return ElectronContextMenu;
+    case 'ElectronWindow':
+      return ElectronWindow;
+    case 'ErrorHandling':
+      return ErrorHandling;
+    case 'Exit':
+      return Exit;
+    case 'ExtensionHost':
+      return ExtensionHostCode;
+    case 'ExtensionMeta':
+      return ExtensionMeta;
+    case 'ExtensionNodeRpc':
+      return ExtensionNodeRpc;
+    case 'Extensions':
+      return Extensions$1;
+    case 'FilePicker':
+      return FilePicker;
+    case 'FileSystem':
+      return FileSystem;
+    case 'Format':
+      return Format;
+    case 'Focus':
+      return Focus;
+    case 'IconTheme':
+      return IconTheme;
+    case 'ImagePreview':
+      return ImagePreview;
+    case 'IndexedDb':
+      return IndexedDb;
+    case 'IpcParent':
+      return IpcParent;
+    case 'KeyBindings':
+      return KeyBindings$1;
+    case 'KeyBindingsInitial':
+      return KeyBindingsInitial;
+    case 'Layout':
+      return Layout$1;
+    case 'LaunchIsolatedExtensionHostWorker':
+      return LaunchIsolatedExtensionHostWorker;
+    case 3444:
+      return Listener;
+    case 'LocalStorage':
+      return LocalStorage$1;
+    case 'Menu':
+      return Menu;
+    case 'Mime':
+      return Mime;
+    case 'NativeHost':
+      return NativeHost;
+    case 'Navigation':
+      return Navigation;
+    case 'Notification':
+      return Notification;
+    case 'Open':
+      return Open$1;
+    case 'OAuthServer':
+      return OAuthServer;
+    case 'OpenNativeFolder':
+      return OpenNativeFolder$1;
+    case 'PersistentFileHandle':
+      return PersistentFileHandle;
+    case 'Preferences':
+      return Preferences;
+    case 'PlatformPaths':
+      return PlatformPaths;
+    case 'Prompt':
+      return Prompt$1;
+    case 'QuickPick':
+      return QuickPick$1;
+    case 'RebuildNodePty':
+      return RebuildNodePty;
+    case 'RecentlyOpened':
+      return RecentlyOpened;
+    case 'Reload':
+      return Reload;
+    case 'SaveFileAs':
+      return SaveFileAs;
+    case 'SaveState':
+      return SaveState;
+    case 'SessionReplay':
+      return SessionReplay;
+    case 'SessionStorage':
+      return SessionStorage$1;
+    case 'Test':
+      return Test$1;
+    case '002':
+      return TestFrameworkComponent;
+    case 'Url':
+      return Url$1;
+    case 'Viewlet':
+    case 2133:
+      return Viewlet;
+    case 'Window':
+      return Window;
+    case 'Workbench':
+      return Workbench;
+    case 'Workspace':
+      return Workspace;
+    case 'WindowTitle':
+      return WindowTitle;
+    case 'PointerCapture':
+      return PointerCapture;
+    case 'Timeout':
+      return Timeout;
+    case 'MouseActions':
+      return MouseActions;
+    case 'FileSystemHandle':
+      return FileSystemHandle;
+    case 'ExtensionHostQuickPick':
+      return ExtensionHostQuickPick;
+    case 'ExtensionHostDialog':
+      return ExtensionHostDialog;
+    case 'ExtensionHostDefinition':
+      return ExtensionHostDefinition;
+    case 'TestFrameWork':
+      return TestFrameWork;
+    case 'ExtensionHostWorkerContentSecurityPolicy':
+      return ExtensionHostWorkerContentSecurityPolicy;
+    case 'SendMessagePortToElectron':
+      return SendMessagePortToElectron;
+    case 'ExtensionHostBraceCompletion':
+      return ExtensionHostBraceCompletion;
+    case 'OffscreenCanvas':
+      return OffscreenCanvas$1;
+    case 'Languages':
+      return Languages;
+    case 'License':
+      return License;
+    case 'FileWatcher':
+      return FileWatcher;
+    case 'ExtensionHostTypeDefinition':
+      return ExtensionHostTypeDefinition;
+    case 'ExtensionHostSelection':
+      return ExtensionHostSelection;
+    case 'ExtensionHostOrganizeImports':
+      return ExtensionHostOrganizeImports;
+    case 'ExtensionHostTabCompletion':
+      return ExtensionHostTabCompletion;
+    case 'ExtensionHostClosingTagCompletion':
+      return ExtensionHostClosingTag;
+    case 'SendMessagePortToRendererProcess':
+      return SendMessagePortToRendererProcess;
+    case 'ExtensionHostHover':
+      return ExtensionHostHover;
+    case 'SendMessagePortToExtensionHostWorker':
+      return SendMessagePortToExtensionHostWorker;
+    case 'SendMessagePortToSyntaxHighlightingWorker':
+      return SendMessagePortToSyntaxHighlightingWorker;
+    case 'ExtensionHostManagement':
+      return ExtensionHostManagement;
+    case 'Transferrable':
+      return Transferrable;
+    case 'WebView':
+      return WebView$2;
+    case 'SearchProcess':
+      return SearchProcess;
+    case 'GetEditorSourceActions':
+      return GetEditorSourceActions;
+    case 'ExtensionHostTextSearch':
+      return ExtensionHostTextSearch;
+    case 'ExtensionStateStorage':
+      return ExtensionStateStorage$2;
+    case 'GetWindowId':
+      return GetWindowId;
+    case 'ElectronDialog':
+      return ElectronDialog;
+    case 'Process':
+      return Process;
+    case 'ExtensionManagement':
+      return ExtensionManagement;
+    case 'Markdown':
+      return Markdown;
+    case 'MeasureTextHeight':
+      return MeasureTextHeight;
+    default:
+      throw new Error(`module ${prefix} not found`);
   }
 };
 
-const getCssId$1 = path => {
-  return 'Css' + path.replace('/css/parts/', '').replaceAll(Slash$2, Dash).replace('.css', EmptyString);
+/**
+ *
+ * @param {string} string
+ * @param {number|undefined} startIndex
+ * @returns
+ */
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
 };
 
-// @ts-nocheck
-const isMessagePort$1 = value => {
-  return value && value instanceof MessagePort;
-};
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
-};
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$2(parent);
+  const childNewLineIndex = getNewLineIndex$2(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+
+const stringifyError = error => {
+  if (error instanceof DOMException && error.message) {
+    return `DOMException: ${error.message}`;
+  }
+  const errorPrefixes = ['Error: ', 'VError: '];
+  const stringifiedError = `${error}`;
+  for (const errorPrefix of errorPrefixes) {
+    if (stringifiedError.startsWith(errorPrefix)) {
+      return stringifiedError.slice(errorPrefix.length);
+    }
+  }
+  return stringifiedError;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = stringifyError(error);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return `${stringifiedError}`;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      this.codeFrame = error.codeFrame;
+    }
+  }
+}
+
+const state$C = {
+  commands: Object.create(null),
+  pendingModules: Object.create(null),
+  async load(moduleId) {
+    throw new Error('not implemented');
+  }
+};
+const initializeModule = module => {
+  if (module.Commands) {
+    for (const [key, value] of Object.entries(module.Commands)) {
+      if (module.name) {
+        const actualKey = key.includes('.') ? key : `${module.name}.${key}`;
+        register$2(actualKey, value);
+      } else {
+        register$2(key, value);
+      }
+    }
+    return;
+  }
+  throw new Error(`module ${module.name} is missing an initialize function and commands`);
+};
+const loadModule$4 = async moduleId => {
+  try {
+    const module = await state$C.load(moduleId);
+    initializeModule(module);
+  } catch (error) {
+    throw new VError(error, `failed to load module ${moduleId}`);
+  }
+};
+const getOrLoadModule = moduleId => {
+  if (!state$C.pendingModules[moduleId]) {
+    state$C.pendingModules[moduleId] = loadModule$4(moduleId);
+  }
+  return state$C.pendingModules[moduleId];
+};
+const loadCommand = async command => {
+  if (command in state$C.commands) {
+    return;
+  }
+  await getOrLoadModule(getModuleId$2(command));
+};
+const register$2 = (commandId, listener) => {
+  if (commandId.split('.').length >= 3) {
+    debugger;
+  }
+  state$C.commands[commandId] = listener;
+};
+const hasThrown = new Set();
+const execute$4 = (command, ...args) => {
+  if (command in state$C.commands) {
+    const fn = state$C.commands[command];
+    if (typeof fn !== 'function') {
+      throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
+    }
+    return fn(...args);
+  }
+  return loadCommand(command)
+  // TODO can skip then block in prod (only to prevent endless loop in dev)
+  .then(() => {
+    if (!(command in state$C.commands)) {
+      if (hasThrown.has(command)) {
+        return;
+      }
+      hasThrown.add(command);
+      throw new CommandNotFoundError$1(command);
+    }
+    return execute$4(command, ...args);
+  });
+};
+const setLoad = load => {
+  state$C.load = load;
+};
+
+const state$B = {
+  pending: Object.create(null)
+};
+const get$i = id => {
+  return state$B.pending[id];
+};
+const has$2 = id => {
+  return id in state$B.pending;
+};
+const set$h = (id, value) => {
+  state$B.pending[id] = value;
+};
+
+const Web$1 = 1;
+const Electron$1 = 2;
+const Remote = 3;
+const Test = 4;
+
+/* istanbul ignore file */
+
+// TODO this should always be completely tree shaken out during build, maybe need to be marked as @__Pure for terser to work
+
+// TODO treeshake this function out when targeting electron
+
+/**
+ * @returns {number}
+ */
+const getPlatform$2 = () => {
+  return platform;
+};
+const platform = Remote;
+
+const getAssetDir$2 = () => {
+  // @ts-ignore
+  {
+    // @ts-ignore
+    return '/fe7bb55';
+  }
+};
+const assetDir = getAssetDir$2();
+
+const NotFound = 404;
+
+const getText$3 = response => {
+  return response.text();
+};
+const getJson$7 = response => {
+  return response.json();
+};
+const create$1c = (value, options) => {
+  return new Response(value, options);
+};
+
+const getCss$2 = async relativePath => {
+  try {
+    const url = `${assetDir}${relativePath}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      if (response.status === NotFound) {
+        throw new Error(`File not found ${url}`);
+      }
+      throw new Error(response.statusText);
+    }
+    const text = await getText$3(response);
+    return text;
+  } catch (error) {
+    throw new VError(error, `Failed to load css "${relativePath}"`);
+  }
+};
+
+const getCssId$1 = path => {
+  return 'Css' + path.replace('/css/parts/', '').replaceAll(Slash$2, Dash).replace('.css', EmptyString);
+};
+
+// @ts-nocheck
+const isMessagePort$1 = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
 const isInstanceOf = (value, constructorName) => {
   return value?.constructor?.name === constructorName;
@@ -501,7 +950,7 @@ const resolve$1 = (id, response) => {
   fn(response);
   remove$d(id);
 };
-const E_COMMAND_NOT_FOUND$1 = 'E_COMMAND_NOT_FOUND';
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
     return prettyError.type;
@@ -523,7 +972,7 @@ const getStack = prettyError => {
   return stackString;
 };
 const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND$1) {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound$1,
       message: error.message,
@@ -621,701 +1070,252 @@ const normalizeParams = args => {
     resolve: args[3],
     preparePrettyError: args[4],
     logError: args[5],
-    requiresSocket: args[6]
-  };
-};
-const handleJsonRpcMessage$1 = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    message,
-    ipc,
-    execute,
-    resolve,
-    preparePrettyError,
-    logError,
-    requiresSocket
-  } = options;
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse$2(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  if ('method' in message) {
-    await getResponse$2(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
-  }
-  throw new JsonRpcError$1('unexpected message');
-};
-let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-};
-const commands = Object.create(null);
-const register$2 = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute$4 = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError$1(command);
-  }
-  return fn(...args);
-};
-const Two$2 = '2.0';
-const create$o$1 = (method, params) => {
-  return {
-    jsonrpc: Two$2,
-    method,
-    params
-  };
-};
-const create$n$1 = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two$2,
-    method,
-    params
-  };
-  return message;
-};
-let id$6 = 0;
-const create$m$1 = () => {
-  return ++id$6;
-};
-
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
-const registerPromise$1 = map => {
-  const id = create$m$1();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  map[id] = resolve;
-  return {
-    id,
-    promise
-  };
-};
-
-// @ts-ignore
-const invokeHelper$1 = async (callbacks, ipc, method, params, useSendAndTransfer) => {
-  const {
-    id,
-    promise
-  } = registerPromise$1(callbacks);
-  const message = create$n$1(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult$1(responseMessage);
-};
-const createRpc = ipc => {
-  const callbacks = Object.create(null);
-  ipc._resolve = (id, response) => {
-    const fn = callbacks[id];
-    if (!fn) {
-      console.warn(`callback ${id} may already be disposed`);
-      return;
-    }
-    fn(response);
-    delete callbacks[id];
-  };
-  const rpc = {
-    async dispose() {
-      await ipc?.dispose();
-    },
-    invoke(method, ...params) {
-      return invokeHelper$1(callbacks, ipc, method, params, false);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeHelper$1(callbacks, ipc, method, params, true);
-    },
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      const message = create$o$1(method, params);
-      ipc.send(message);
-    }
-  };
-  return rpc;
-};
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError$1 = () => {
-  // handled by renderer worker
-};
-const handleMessage$2 = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$4;
-  return handleJsonRpcMessage$1(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
-};
-const handleIpc$1 = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage$2);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage$2);
-  }
-};
-const listen$2 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-const create$1b = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register$2(commandMap);
-  const ipc = await listen$2(IpcChildWithModuleWorker$1);
-  handleIpc$1(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient2 = {
-  __proto__: null,
-  create: create$1b
-};
-
-const commandMapRef = {};
-
-// @ts-ignore
-const state$B = {
-  pendingMessages: [],
-  /**
-   * @type {any}
-   */
-  rpc: undefined
-};
-const getRpc$1 = async () => {
-  // TODO replace this with a static commandmap
-
-  const rpc = await WebWorkerRpcClient2.create({
-    commandMap: commandMapRef
-  });
-  return rpc;
-};
-const listen$1 = async () => {
-  console.assert(state$B.pendingMessages.length === 0);
-  const rpc = await getRpc$1();
-  state$B.rpc = rpc;
-};
-const invoke$I = (method, ...params) => {
-  return state$B.rpc.invoke(method, ...params);
-};
-const invokeAndTransfer$u = (method, ...params) => {
-  return state$B.rpc.invokeAndTransfer(method, ...params);
-};
-
-const escapeCssComment = value => {
-  return value.replaceAll('*/', '* /');
-};
-const prependCssSourceComment = (cssPath, id, text) => {
-  return `/* ${escapeCssComment(cssPath)} (${escapeCssComment(id)}) */\n${text}`;
-};
-const actuallyLoadCssStyleSheet = async css => {
-  const text = await getCss$2(css);
-  const id = getCssId$1(css);
-  await addCssStyleSheet(id, prependCssSourceComment(css, id, text));
-};
-const loadCssStyleSheet = id => {
-  if (!has$2(id)) {
-    set$h(id, actuallyLoadCssStyleSheet(id));
-  }
-  return get$i(id);
-};
-const loadCssStyleSheets = css => {
-  return Promise.all(css.map(loadCssStyleSheet));
-};
-const addCssStyleSheet = (id, css) => {
-  return invoke$I('Css.addCssStyleSheet', id, css);
-};
-const actuallyAddDynamicCss = async (id, getCss, preferences) => {
-  const css = await getCss(preferences);
-  await addCssStyleSheet(id, css);
-};
-const addDynamicCss = (id, getCss, preferences) => {
-  if (!has$2(id)) {
-    set$h(id, actuallyAddDynamicCss(id, getCss, preferences));
-  }
-  return get$i(id);
-};
-
-const ENOENT = 'ENOENT';
-const ENOTDIR = 'ENOTDIR';
-const E_MANIFEST_NOT_FOUND = 'E_MANIFEST_NOT_FOUND';
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-
-class CommandNotFoundError extends Error {
-  constructor(id) {
-    super(`Command "${id}" not found (renderer worker)`);
-    this.name = 'CommandNotFoundError';
-    this.code = E_COMMAND_NOT_FOUND;
-  }
-}
-
-// TODO rename to widgetFind and group together with other widgets (contextMenu, hover, tooltip)
-const Ajax = 1;
-const Audio$2 = 2;
-const Blob$2 = 4;
-const CacheStorage = 5;
-const Callback = 6;
-const ClipBoard = 7;
-const ColorTheme = 9;
-const ContextMenu$1 = 11;
-const Developer = 12;
-const Dialog$1 = 13;
-const Download = 14;
-const EditorDiagnostics = 15;
-const EditorError = 16;
-const ErrorHandling = 18;
-const ExtensionHostCode = 19;
-const ExtensionMeta = 20;
-const Extensions$1 = 21;
-const FileSystem = 22;
-const Format = 23;
-const IconTheme = 24;
-const ImagePreview = 25;
-const KeyBindings$1 = 26;
-const KeyBindingsInitial = 27;
-const Layout$1 = 28;
-const Listener = 29;
-const LocalStorage$1 = 30;
-const Menu = 31;
-const Navigation = 32;
-const Notification = 33;
-const Open$1 = 34;
-const Preferences = 35;
-const QuickPick$1 = 36;
-const RecentlyOpened = 37;
-const SaveState = 38;
-const SessionReplay = 39;
-const SessionStorage$1 = 40;
-const Test = 41;
-const TestFrameworkComponent = 43;
-const Viewlet = 44;
-const Window = 45;
-const Workbench = 46;
-const Workspace = 47;
-const ContentTracing = 48;
-const OpenNativeFolder$1 = 49;
-const ElectronWindow = 50;
-const Url$1 = 51;
-const Mime = 52;
-const FilePicker = 54;
-const PersistentFileHandle = 55;
-const IndexedDb = 56;
-const Chrome = 57;
-const ElectronBrowserView = 58;
-const Exit = 59;
-const ElectronContextMenu = 60;
-const ElectronClipBoard = 61;
-const SaveFileAs = 62;
-const About$1 = 64;
-const ConfirmPrompt = 65;
-const BulkReplacement = 66;
-const AutoUpdater = 67;
-const IpcParent = 68;
-const NativeHost = 69;
-const RebuildNodePty = 70;
-const DebugSharedProcess = 71;
-const Reload = 72;
-const Prompt$1 = 74;
-const WindowTitle = 75;
-const Focus = 76;
-const PointerCapture = 77;
-const ExtensionHostQuickPick = 78;
-const ExtensionHostDialog = 79;
-const TestFrameWork = 80;
-const ExtensionHostWorkerContentSecurityPolicy = 81;
-const SendMessagePortToElectron = 82;
-const OffscreenCanvas$1 = 83;
-const Debug$1 = 84;
-const Languages = 85;
-const FileWatcher = 86;
-const ExtensionHostBraceCompletion = 114;
-const ExtensionHostDefinition = 115;
-const ExtensionHostOrganizeImports = 117;
-const ExtensionHostSelection = 119;
-const ExtensionHostTabCompletion = 120;
-const ExtensionHostTypeDefinition = 121;
-const ExtensionHostClosingTag = 122;
-const SendMessagePortToRendererProcess = 123;
-const ExtensionHostHover = 124;
-const SendMessagePortToExtensionHostWorker = 125;
-const ExtensionHostManagement = 126;
-const SendMessagePortToSyntaxHighlightingWorker = 127;
-const Transferrable = 128;
-const WebView$2 = 129;
-const SearchProcess = 130;
-const GetEditorSourceActions = 131;
-const ExtensionHostTextSearch = 132;
-const ExtensionStateStorage$2 = 133;
-const GetWindowId = 134;
-const ElectronDialog = 135;
-const Process = 136;
-const ExtensionManagement = 137;
-const Markdown = 138;
-const FileSystemHandle = 139;
-const MouseActions = 140;
-const Timeout = 141;
-const GetActiveEditor = 142;
-const PlatformPaths = 143;
-const MeasureTextHeight = 144;
-const Document = 145;
-const Exec = 146;
-const OAuthServer = 147;
-const LaunchIsolatedExtensionHostWorker = 148;
-const ExtensionNodeRpc = 149;
-const License = 150;
-
-const getPrefix = commandId => {
-  if (!commandId || typeof commandId !== 'string') {
-    return commandId;
-  }
-  const dotIndex = commandId.indexOf(Dot);
-  if (dotIndex === -1) {
-    return '';
-  }
-  return commandId.slice(0, dotIndex);
-};
-const getModuleId$2 = commandId => {
-  const prefix = getPrefix(commandId);
-  if (!prefix) {
-    throw new CommandNotFoundError(commandId);
-  }
-  switch (prefix) {
-    case 'About':
-      return About$1;
-    case 'Exec':
-      return Exec;
-    case 'Ajax':
-      return Ajax;
-    case 'Audio':
-      return Audio$2;
-    case 'Debug':
-      return Debug$1;
-    case 'AutoUpdater':
-      return AutoUpdater;
-    case 'Document':
-      return Document;
-    case 'Blob':
-      return Blob$2;
-    case 'GetActiveEditor':
-      return GetActiveEditor;
-    case 'BulkReplacement':
-      return BulkReplacement;
-    case 'CacheStorage':
-      return CacheStorage;
-    case 'Callback':
-      return Callback;
-    case 'Chrome':
-      return Chrome;
-    case 'ClipBoard':
-      return ClipBoard;
-    case 'ColorTheme':
-      return ColorTheme;
-    case 'ConfirmPrompt':
-      return ConfirmPrompt;
-    case 'ContentTracing':
-      return ContentTracing;
-    case 'ContextMenu':
-      return ContextMenu$1;
-    case 'DebugSharedProcess':
-      return DebugSharedProcess;
-    case 'Developer':
-      return Developer;
-    case 'Dialog':
-      return Dialog$1;
-    case 'Download':
-      return Download;
-    case 'EditorDiagnostics':
-      return EditorDiagnostics;
-    case 3900:
-      return EditorError;
-    case 'ElectronBrowserView':
-      return ElectronBrowserView;
-    case 'ElectronClipBoard':
-      return ElectronClipBoard;
-    case 'ElectronContextMenu':
-      return ElectronContextMenu;
-    case 'ElectronWindow':
-      return ElectronWindow;
-    case 'ErrorHandling':
-      return ErrorHandling;
-    case 'Exit':
-      return Exit;
-    case 'ExtensionHost':
-      return ExtensionHostCode;
-    case 'ExtensionMeta':
-      return ExtensionMeta;
-    case 'ExtensionNodeRpc':
-      return ExtensionNodeRpc;
-    case 'Extensions':
-      return Extensions$1;
-    case 'FilePicker':
-      return FilePicker;
-    case 'FileSystem':
-      return FileSystem;
-    case 'Format':
-      return Format;
-    case 'Focus':
-      return Focus;
-    case 'IconTheme':
-      return IconTheme;
-    case 'ImagePreview':
-      return ImagePreview;
-    case 'IndexedDb':
-      return IndexedDb;
-    case 'IpcParent':
-      return IpcParent;
-    case 'KeyBindings':
-      return KeyBindings$1;
-    case 'KeyBindingsInitial':
-      return KeyBindingsInitial;
-    case 'Layout':
-      return Layout$1;
-    case 'LaunchIsolatedExtensionHostWorker':
-      return LaunchIsolatedExtensionHostWorker;
-    case 3444:
-      return Listener;
-    case 'LocalStorage':
-      return LocalStorage$1;
-    case 'Menu':
-      return Menu;
-    case 'Mime':
-      return Mime;
-    case 'NativeHost':
-      return NativeHost;
-    case 'Navigation':
-      return Navigation;
-    case 'Notification':
-      return Notification;
-    case 'Open':
-      return Open$1;
-    case 'OAuthServer':
-      return OAuthServer;
-    case 'OpenNativeFolder':
-      return OpenNativeFolder$1;
-    case 'PersistentFileHandle':
-      return PersistentFileHandle;
-    case 'Preferences':
-      return Preferences;
-    case 'PlatformPaths':
-      return PlatformPaths;
-    case 'Prompt':
-      return Prompt$1;
-    case 'QuickPick':
-      return QuickPick$1;
-    case 'RebuildNodePty':
-      return RebuildNodePty;
-    case 'RecentlyOpened':
-      return RecentlyOpened;
-    case 'Reload':
-      return Reload;
-    case 'SaveFileAs':
-      return SaveFileAs;
-    case 'SaveState':
-      return SaveState;
-    case 'SessionReplay':
-      return SessionReplay;
-    case 'SessionStorage':
-      return SessionStorage$1;
-    case 'Test':
-      return Test;
-    case '002':
-      return TestFrameworkComponent;
-    case 'Url':
-      return Url$1;
-    case 'Viewlet':
-    case 2133:
-      return Viewlet;
-    case 'Window':
-      return Window;
-    case 'Workbench':
-      return Workbench;
-    case 'Workspace':
-      return Workspace;
-    case 'WindowTitle':
-      return WindowTitle;
-    case 'PointerCapture':
-      return PointerCapture;
-    case 'Timeout':
-      return Timeout;
-    case 'MouseActions':
-      return MouseActions;
-    case 'FileSystemHandle':
-      return FileSystemHandle;
-    case 'ExtensionHostQuickPick':
-      return ExtensionHostQuickPick;
-    case 'ExtensionHostDialog':
-      return ExtensionHostDialog;
-    case 'ExtensionHostDefinition':
-      return ExtensionHostDefinition;
-    case 'TestFrameWork':
-      return TestFrameWork;
-    case 'ExtensionHostWorkerContentSecurityPolicy':
-      return ExtensionHostWorkerContentSecurityPolicy;
-    case 'SendMessagePortToElectron':
-      return SendMessagePortToElectron;
-    case 'ExtensionHostBraceCompletion':
-      return ExtensionHostBraceCompletion;
-    case 'OffscreenCanvas':
-      return OffscreenCanvas$1;
-    case 'Languages':
-      return Languages;
-    case 'License':
-      return License;
-    case 'FileWatcher':
-      return FileWatcher;
-    case 'ExtensionHostTypeDefinition':
-      return ExtensionHostTypeDefinition;
-    case 'ExtensionHostSelection':
-      return ExtensionHostSelection;
-    case 'ExtensionHostOrganizeImports':
-      return ExtensionHostOrganizeImports;
-    case 'ExtensionHostTabCompletion':
-      return ExtensionHostTabCompletion;
-    case 'ExtensionHostClosingTagCompletion':
-      return ExtensionHostClosingTag;
-    case 'SendMessagePortToRendererProcess':
-      return SendMessagePortToRendererProcess;
-    case 'ExtensionHostHover':
-      return ExtensionHostHover;
-    case 'SendMessagePortToExtensionHostWorker':
-      return SendMessagePortToExtensionHostWorker;
-    case 'SendMessagePortToSyntaxHighlightingWorker':
-      return SendMessagePortToSyntaxHighlightingWorker;
-    case 'ExtensionHostManagement':
-      return ExtensionHostManagement;
-    case 'Transferrable':
-      return Transferrable;
-    case 'WebView':
-      return WebView$2;
-    case 'SearchProcess':
-      return SearchProcess;
-    case 'GetEditorSourceActions':
-      return GetEditorSourceActions;
-    case 'ExtensionHostTextSearch':
-      return ExtensionHostTextSearch;
-    case 'ExtensionStateStorage':
-      return ExtensionStateStorage$2;
-    case 'GetWindowId':
-      return GetWindowId;
-    case 'ElectronDialog':
-      return ElectronDialog;
-    case 'Process':
-      return Process;
-    case 'ExtensionManagement':
-      return ExtensionManagement;
-    case 'Markdown':
-      return Markdown;
-    case 'MeasureTextHeight':
-      return MeasureTextHeight;
-    default:
-      throw new Error(`module ${prefix} not found`);
-  }
-};
-
-const state$A = {
-  commands: Object.create(null),
-  pendingModules: Object.create(null),
-  async load(moduleId) {
-    throw new Error('not implemented');
-  }
-};
-const initializeModule = module => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      if (module.name) {
-        const actualKey = key.includes('.') ? key : `${module.name}.${key}`;
-        register$1(actualKey, value);
-      } else {
-        register$1(key, value);
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage$1 = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse$2(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
       }
+      return;
     }
+    resolve(message.id, message);
     return;
   }
-  throw new Error(`module ${module.name} is missing an initialize function and commands`);
-};
-const loadModule$4 = async moduleId => {
-  try {
-    const module = await state$A.load(moduleId);
-    initializeModule(module);
-  } catch (error) {
-    throw new VError(error, `failed to load module ${moduleId}`);
+  if ('method' in message) {
+    await getResponse$2(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
   }
+  throw new JsonRpcError$1('unexpected message');
 };
-const getOrLoadModule = moduleId => {
-  if (!state$A.pendingModules[moduleId]) {
-    state$A.pendingModules[moduleId] = loadModule$4(moduleId);
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
   }
-  return state$A.pendingModules[moduleId];
+}
+const commands = Object.create(null);
+const register$1 = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const loadCommand = async command => {
-  if (command in state$A.commands) {
-    return;
+const getCommand = key => {
+  return commands[key];
+};
+const execute$3 = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
   }
-  await getOrLoadModule(getModuleId$2(command));
+  return fn(...args);
 };
-const register$1 = (commandId, listener) => {
-  if (commandId.split('.').length >= 3) {
-    debugger;
+const Two$2 = '2.0';
+const create$o$1 = (method, params) => {
+  return {
+    jsonrpc: Two$2,
+    method,
+    params
+  };
+};
+const create$n$1 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two$2,
+    method,
+    params
+  };
+  return message;
+};
+let id$6 = 0;
+const create$m$1 = () => {
+  return ++id$6;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise$1 = map => {
+  const id = create$m$1();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper$1 = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise$1(callbacks);
+  const message = create$n$1(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
   }
-  state$A.commands[commandId] = listener;
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult$1(responseMessage);
 };
-const hasThrown = new Set();
-const execute$3 = (command, ...args) => {
-  if (command in state$A.commands) {
-    const fn = state$A.commands[command];
-    if (typeof fn !== 'function') {
-      throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
     }
-    return fn(...args);
-  }
-  return loadCommand(command)
-  // TODO can skip then block in prod (only to prevent endless loop in dev)
-  .then(() => {
-    if (!(command in state$A.commands)) {
-      if (hasThrown.has(command)) {
-        return;
-      }
-      hasThrown.add(command);
-      throw new CommandNotFoundError(command);
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper$1(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper$1(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$o$1(method, params);
+      ipc.send(message);
     }
-    return execute$3(command, ...args);
+  };
+  return rpc;
+};
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError$1 = () => {
+  // handled by renderer worker
+};
+const handleMessage$2 = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute$3;
+  return handleJsonRpcMessage$1(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+};
+const handleIpc$1 = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage$2);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage$2);
+  }
+};
+const listen$2 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$1b = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const ipc = await listen$2(IpcChildWithModuleWorker$1);
+  handleIpc$1(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient2 = {
+  __proto__: null,
+  create: create$1b
+};
+
+const commandMapRef = {};
+
+// @ts-ignore
+const state$A = {
+  pendingMessages: [],
+  /**
+   * @type {any}
+   */
+  rpc: undefined
+};
+const getRpc$1 = async () => {
+  // TODO replace this with a static commandmap
+
+  const rpc = await WebWorkerRpcClient2.create({
+    commandMap: commandMapRef
   });
+  return rpc;
 };
-const setLoad = load => {
-  state$A.load = load;
+const listen$1 = async () => {
+  console.assert(state$A.pendingMessages.length === 0);
+  const rpc = await getRpc$1();
+  state$A.rpc = rpc;
+};
+const invoke$I = (method, ...params) => {
+  return state$A.rpc.invoke(method, ...params);
+};
+const invokeAndTransfer$u = (method, ...params) => {
+  return state$A.rpc.invokeAndTransfer(method, ...params);
+};
+
+const escapeCssComment = value => {
+  return value.replaceAll('*/', '* /');
+};
+const prependCssSourceComment = (cssPath, id, text) => {
+  return `/* ${escapeCssComment(cssPath)} (${escapeCssComment(id)}) */\n${text}`;
+};
+const actuallyLoadCssStyleSheet = async css => {
+  const text = await getCss$2(css);
+  const id = getCssId$1(css);
+  await addCssStyleSheet(id, prependCssSourceComment(css, id, text));
+};
+const loadCssStyleSheet = id => {
+  if (!has$2(id)) {
+    set$h(id, actuallyLoadCssStyleSheet(id));
+  }
+  return get$i(id);
+};
+const loadCssStyleSheets = css => {
+  return Promise.all(css.map(loadCssStyleSheet));
+};
+const addCssStyleSheet = (id, css) => {
+  return invoke$I('Css.addCssStyleSheet', id, css);
+};
+const actuallyAddDynamicCss = async (id, getCss, preferences) => {
+  const css = await getCss(preferences);
+  await addCssStyleSheet(id, css);
+};
+const addDynamicCss = (id, getCss, preferences) => {
+  if (!has$2(id)) {
+    set$h(id, actuallyAddDynamicCss(id, getCss, preferences));
+  }
+  return get$i(id);
 };
 
 // @ts-nocheck
@@ -1603,7 +1603,7 @@ const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
 };
 
 const handleMessage$1 = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute$3, resolve, 'process');
+  return handleJsonRpcMessage(event.target, event.data, execute$4, resolve, 'process');
 };
 
 const handleIpc = ipc => {
@@ -1759,7 +1759,7 @@ const handleError = async (error, notify = true, prefix = '') => {
   try {
     const prettyError = await logError(error, prefix);
     if (notify) {
-      await execute$3(/* Notification.create */'Notification.create', /* type */'error', /* text */getMessage$3(prettyError));
+      await execute$4(/* Notification.create */'Notification.create', /* type */'error', /* text */getMessage$3(prettyError));
     }
   } catch (otherError) {
     console.warn('ErrorHandling error');
@@ -1773,7 +1773,7 @@ const showErrorDialog = async error => {
     if (prettyError && prettyError.type === 'Object') {
       prettyError.type = 'Error';
     }
-    await execute$3(/* Dialog.showMessage */'Dialog.showMessage', /* message */prettyError);
+    await execute$4(/* Dialog.showMessage */'Dialog.showMessage', /* message */prettyError);
   } catch {
     // ignore
   }
@@ -1847,7 +1847,7 @@ const getPath$5 = (protocol, uri) => {
 };
 
 const notifyWorkspaceChanged = async () => {
-  await Promise.allSettled([execute$3('Layout.handleWorkspaceRefresh'), execute$3('Layout.refreshSourceControlBadgeCount')]);
+  await Promise.allSettled([execute$4('Layout.handleWorkspaceRefresh'), execute$4('Layout.refreshSourceControlBadgeCount')]);
 };
 const readFile$f = async (uri, encoding = Utf8) => {
   const protocol = getProtocol(uri);
@@ -2040,7 +2040,7 @@ const parse = content => {
 };
 
 const openUri$1 = async (path, focus = true, props = {}) => {
-  await execute$3(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
+  await execute$4(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
 const state$w = {
@@ -2089,12 +2089,12 @@ const openKeyBindingsJson = async () => {
 
 const getPreferencesJson = async () => {
   if (getPlatform$2() === Web$1) {
-    const cachedPreferences = await execute$3(/* LocalStorage.getJson */'LocalStorage.getJson', /* key */'settings');
+    const cachedPreferences = await execute$4(/* LocalStorage.getJson */'LocalStorage.getJson', /* key */'settings');
     if (cachedPreferences) {
       return cachedPreferences;
     }
     const url = `${assetDir}/config/defaultSettings.json`;
-    return execute$3(/* Ajax.getJson */'Ajax.getJson', /* url */url);
+    return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
   return invoke$F(PreferencesGetAll);
 };
@@ -2132,7 +2132,7 @@ const set$e = async (key, value) => {
       ...getAll$3(),
       [key]: value
     };
-    await execute$3(/* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
+    await execute$4(/* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
     return;
   }
   const content = stringify(getAll$3());
@@ -2279,6 +2279,7 @@ const setColorTheme = async colorThemeId => {
   }
   // TODO should preferences throw errors or should it call handleError directly?
   await set$e('workbench.colorTheme', colorThemeId);
+  await execute$4('Layout.handleColorThemeChanged', colorThemeId);
   return undefined;
 };
 const watch$1 = async id => {
@@ -3434,7 +3435,7 @@ const isValid$1 = resolvedRoot => {
   return resolvedRoot && typeof resolvedRoot.path === 'string' && typeof resolvedRoot.uri === 'string' && typeof resolvedRoot.homeDir === 'string' && typeof resolvedRoot.pathSeparator === 'string';
 };
 const getResolveRootFromSessionStorage = async () => {
-  const resolvedRoot = await execute$3(/* SessionStorage.getJson */'SessionStorage.getJson', /* key */'workspace');
+  const resolvedRoot = await execute$4(/* SessionStorage.getJson */'SessionStorage.getJson', /* key */'workspace');
   if (!isValid$1(resolvedRoot)) {
     return undefined;
   }
@@ -4281,20 +4282,20 @@ const getRenderCommands = (module, oldState, newState, uid = newState.uid || mod
 };
 const registerWrappedCommand = (moduleName, key, wrappedCommand) => {
   if (key.startsWith(moduleName)) {
-    register$1(key, wrappedCommand);
+    register$2(key, wrappedCommand);
   } else {
     // TODO rename editorText to editor
     if (moduleName === 'EditorText') {
       if (key.includes('.')) {
-        register$1(key, wrappedCommand);
+        register$2(key, wrappedCommand);
       } else {
-        register$1(`Editor.${key}`, wrappedCommand);
+        register$2(`Editor.${key}`, wrappedCommand);
       }
     } else {
       if (key.includes('.')) {
-        register$1(key, wrappedCommand);
+        register$2(key, wrappedCommand);
       } else {
-        register$1(`${moduleName}.${key}`, wrappedCommand);
+        register$2(`${moduleName}.${key}`, wrappedCommand);
       }
     }
   }
@@ -4566,7 +4567,7 @@ const load$4 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     setFocusedInstanceByType(viewletUid, moduleId);
     if (newState.badgeCount) {
-      await execute$3('Layout.handleBadgeCountChange');
+      await execute$4('Layout.handleBadgeCountChange');
     }
     if (module.hasFunctionalRootRender) {
       commands.push([kCreateFunctionalRoot, viewlet.id, viewletUid, module.hasFunctionalEvents]);
@@ -4764,7 +4765,7 @@ const run$1 = async (method, overlayId) => {
     return;
   }
   try {
-    await execute$3(`SimpleBrowser.${method}`, overlayId);
+    await execute$4(`SimpleBrowser.${method}`, overlayId);
   } catch (error) {
     console.error(`[renderer-worker] Failed to ${method} for Simple Browser`, error);
   }
@@ -5177,7 +5178,7 @@ const handleKeyBinding$1 = async identifier => {
   if (!keyBinding) {
     throw new Error(`keybinding not found for identifier ${identifier}`);
   }
-  await execute$3(/* command */keyBinding.command,
+  await execute$4(/* command */keyBinding.command,
   // TODO should args always be defined? (probably yes -> monomorphism & simpler code since all objects are the same)
   ...(keyBinding.args || []));
   // TODO
@@ -5858,7 +5859,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   if (!languageConfigurationPath) {
     return undefined;
   }
-  const json = await execute$3('Ajax.getJson', languageConfigurationPath);
+  const json = await execute$4('Ajax.getJson', languageConfigurationPath);
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
@@ -6347,7 +6348,7 @@ const load$1 = moduleId => {
       return Promise.resolve().then(function () { return SessionReplay_ipc; });
     case SessionStorage$1:
       return Promise.resolve().then(function () { return SessionStorage_ipc; });
-    case Test:
+    case Test$1:
       return Promise.resolve().then(function () { return Test_ipc; });
     case TestFrameWork:
       return Promise.resolve().then(function () { return TestFrameWork_ipc; });
@@ -6497,8 +6498,8 @@ const exit$1 = code => {
   return invoke$F('Exit.exit', code);
 };
 
-const version = '0.91.8';
-const commit$1 = '98fc4d9';
+const version = '0.91.10';
+const commit$1 = 'fe7bb55';
 const productNameLong$1 = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$F('Process.getPid');
@@ -6857,7 +6858,7 @@ const run = async (promptOrOptions, authState) => {
     }
     fileSystemAccess = getFileSystemAccess(options);
     const commandArguments = getCommandArguments(prompt, fileSystemAccess, accessToken);
-    result = await execute$3('ExtensionHost.executeCommand', 'chat2.runPrompt', ...commandArguments);
+    result = await execute$4('ExtensionHost.executeCommand', 'chat2.runPrompt', ...commandArguments);
     if (result?.status !== 'completed') {
       throw new Error(result?.error || 'Chat task failed without an error message');
     }
@@ -7086,7 +7087,7 @@ const replayCurrentSession = async () => {
 
   const href = await getHref$1();
   const replayUrl = addSearchParam(href, 'replayId', getSessionId());
-  await execute$3('Open.openUrl', /* url */replayUrl);
+  await execute$4('Open.openUrl', /* url */replayUrl);
 };
 const getSessionContent = async () => {
   const sessionId = getSessionId();
@@ -7096,7 +7097,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$B.rpc.ipc;
+  const originalIpc = state$A.rpc.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -7111,33 +7112,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$B.rpc.ipc.onmessage = originalAddEventListsner;
-          state$B.rpc.ipc.send = originalSend;
-          await execute$3('ElectronWindow.close');
-          state$B.rpc.ipc.onmessage = wrappedOnMessage;
-          state$B.rpc.ipc.send = wrappedSend;
+          state$A.rpc.ipc.onmessage = originalAddEventListsner;
+          state$A.rpc.ipc.send = originalSend;
+          await execute$4('ElectronWindow.close');
+          state$A.rpc.ipc.onmessage = wrappedOnMessage;
+          state$A.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$B.rpc.ipc.onmessage = originalAddEventListsner;
-          state$B.rpc.ipc.send = originalSend;
-          await execute$3('ElectronWindow.minimize');
-          state$B.rpc.ipc.onmessage = wrappedOnMessage;
-          state$B.rpc.ipc.send = wrappedSend;
+          state$A.rpc.ipc.onmessage = originalAddEventListsner;
+          state$A.rpc.ipc.send = originalSend;
+          await execute$4('ElectronWindow.minimize');
+          state$A.rpc.ipc.onmessage = wrappedOnMessage;
+          state$A.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$B.rpc.ipc.onmessage = originalAddEventListsner;
-          state$B.rpc.ipc.send = originalSend;
-          await execute$3('ElectronWindow.maximize');
-          state$B.rpc.ipc.onmessage = wrappedOnMessage;
-          state$B.rpc.ipc.send = wrappedSend;
+          state$A.rpc.ipc.onmessage = originalAddEventListsner;
+          state$A.rpc.ipc.send = originalSend;
+          await execute$4('ElectronWindow.maximize');
+          state$A.rpc.ipc.onmessage = wrappedOnMessage;
+          state$A.rpc.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$B.rpc.send = wrappedSend;
-  state$B.rpc.addEventListener('message', wrappedOnMessage);
+  state$A.rpc.send = wrappedSend;
+  state$A.rpc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -7168,7 +7169,7 @@ const downloadSession = async () => {
     const sessionId = getSessionId();
     const events = await getSessionEvents(sessionId);
     const fileName = `${sessionId}.json`;
-    await execute$3(/* Download.downloadJson */'Download.downloadJson', /* json */events, /* fileName */fileName);
+    await execute$4(/* Download.downloadJson */'Download.downloadJson', /* json */events, /* fileName */fileName);
   } catch (error) {
     throw new VError(error, 'Failed to download session');
   }
@@ -7209,11 +7210,11 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$B.rpc.ipc = wrapIpc(state$B.rpc, 'renderer-process', event => event.data);
+  state$A.rpc.ipc = wrapIpc(state$A.rpc, 'renderer-process', event => event.data);
   state$w.ipc = wrapIpc(state$w.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
-  await execute$3(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
+  await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
 };
 
 const shouldInitializeAuth = (hasAuthCallback, isPromptMode) => {
@@ -7381,31 +7382,31 @@ const watchFilesForHotReload = async platform => {
 
 const actions = [async () => {
   mark(WillLoadMain);
-  await execute$3('Layout.loadMainIfVisible');
+  await execute$4('Layout.loadMainIfVisible');
   mark(DidLoadMain);
 }, async () => {
   mark$1(Six);
   mark$1(Seven);
   mark(WillLoadSideBar);
-  await Promise.all([execute$3('Layout.loadSideBarIfVisible'), execute$3('Layout.loadSecondarySideBarIfVisible')]);
+  await Promise.all([execute$4('Layout.loadSideBarIfVisible'), execute$4('Layout.loadSecondarySideBarIfVisible')]);
   mark(DidLoadSideBar);
 }, async () => {
   mark$1(Eight);
   mark(WillLoadPanel);
-  await execute$3('Layout.loadPanelIfVisible');
+  await execute$4('Layout.loadPanelIfVisible');
   mark(DidLoadPanel);
 }, async () => {
   mark$1(Nine);
   mark(WillLoadActivityBar);
-  await execute$3('Layout.loadActivityBarIfVisible');
+  await execute$4('Layout.loadActivityBarIfVisible');
   mark(DidLoadActivityBar);
 }, async () => {
   mark$1(Ten);
   mark(WillLoadStatusBar);
-  await execute$3('Layout.loadStatusBarIfVisible');
+  await execute$4('Layout.loadStatusBarIfVisible');
   mark(DidLoadStatusBar);
 }, async () => {
-  await execute$3('Layout.loadPreviewIfVisible');
+  await execute$4('Layout.loadPreviewIfVisible');
 }, async (platform, assetDir) => {
   mark$1(Eleven);
   mark(WillLoadIconTheme);
@@ -7417,7 +7418,7 @@ const actions = [async () => {
   mark$1(Thirteen);
   mark$1(Fourteen);
   mark(WillLoadTitleBar);
-  await execute$3('Layout.loadTitleBarIfVisible');
+  await execute$4('Layout.loadTitleBarIfVisible');
   mark(DidLoadTitleBar);
 }];
 
@@ -7470,7 +7471,7 @@ const startup = async (platform, assetDir) => {
   mark(DidOpenWorkspace);
   if (promptOptions !== undefined) {
     await initialize$1(initData);
-    await execute$3('Layout.setAuthState', authState);
+    await execute$4('Layout.setAuthState', authState);
     await run(promptOptions, authState);
     return;
   }
@@ -7509,7 +7510,7 @@ const startup = async (platform, assetDir) => {
   commands.push(['Viewlet.appendToBody', layout.uid]);
   await invoke$I('Viewlet.executeCommands', commands);
   if (authState) {
-    await execute$3('Layout.setAuthState', authState);
+    await execute$4('Layout.setAuthState', authState);
   }
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
@@ -7548,7 +7549,7 @@ const startup = async (platform, assetDir) => {
   const supportsAutoUpdate = platform === Electron$1; // TODO also check if auto update is supported on this platform, e.g. windows
   if (autoUpdate && autoUpdate !== 'none' && supportsAutoUpdate) {
     try {
-      await execute$3('AutoUpdater.checkForUpdates', autoUpdate);
+      await execute$4('AutoUpdater.checkForUpdates', autoUpdate);
     } catch {
       // ignore
     }
@@ -7558,7 +7559,7 @@ const startup = async (platform, assetDir) => {
 
 const lazy = key => async (...args) => {
   await loadCommand(key);
-  return execute$3(key, ...args);
+  return execute$4(key, ...args);
 };
 const commandMap = {
   'About.showAbout': lazy('About.showAbout'),
@@ -8027,6 +8028,7 @@ const commandMap = {
   'Layout.getUserInfo': lazy('Layout.getUserInfo'),
   'Layout.handleBadgeCountChange': lazy('Layout.handleBadgeCountChange'),
   'Layout.handleBlur': lazy('Layout.handleBlur'),
+  'Layout.handleColorThemeChanged': lazy('Layout.handleColorThemeChanged'),
   'Layout.handleContextMenu': lazy('Layout.handleContextMenu'),
   'Layout.handleExtensionsChanged': lazy('Layout.handleExtensionsChanged'),
   'Layout.handleFocus': lazy('Layout.handleFocus'),
@@ -8789,7 +8791,7 @@ const addWebExtension = async path => {
   }
   await invoke$E('Extensions.addExtension', manifest);
   {
-    await execute$3(`Layout.handleExtensionsChanged`);
+    await execute$4(`Layout.handleExtensionsChanged`);
   }
   // TODO avoid side effect here
   if (manifest.languages) {
@@ -9954,7 +9956,7 @@ const addHandle = async (uri, handle) => {
   try {
     // TODO save handle in indexeddb
     handles[uri] = handle;
-    await execute$3('IndexedDb.addHandle', uri, handle);
+    await execute$4('IndexedDb.addHandle', uri, handle);
   } catch (error) {
     throw new VError(error, 'Failed to add handle');
   }
@@ -9987,11 +9989,11 @@ const getHandle = async uri => {
     if (uri in handles) {
       return handles[uri];
     }
-    let handle = await execute$3('IndexedDb.getHandle', uri);
+    let handle = await execute$4('IndexedDb.getHandle', uri);
     if (!handle) {
       const legacyKeys = getLegacyHtmlKeys(uri);
       for (const legacyKey of legacyKeys) {
-        handle = await execute$3('IndexedDb.getHandle', legacyKey);
+        handle = await execute$4('IndexedDb.getHandle', legacyKey);
         if (handle) {
           await addHandle(uri, handle);
           handles[legacyKey] = handle;
@@ -10648,7 +10650,7 @@ const getSrc = uri => {
 };
 const disposeSrc = async src => {
   if (src.startsWith(Blob$1)) {
-    await execute$3('Url.revokeObjectUrl', src);
+    await execute$4('Url.revokeObjectUrl', src);
   }
 };
 
@@ -10864,7 +10866,7 @@ const Callback_ipc = {
 const minimize = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.minimize');
+      return execute$4('ElectronWindow.minimize');
     default:
       throw new Error('not implemented');
   }
@@ -10872,7 +10874,7 @@ const minimize = () => {
 const maximize = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.maximize');
+      return execute$4('ElectronWindow.maximize');
     default:
       throw new Error('not implemented');
   }
@@ -10880,7 +10882,7 @@ const maximize = () => {
 const unmaximize = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.unmaximize');
+      return execute$4('ElectronWindow.unmaximize');
     default:
       throw new Error('not implemented');
   }
@@ -10888,7 +10890,7 @@ const unmaximize = () => {
 const close$2 = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.close');
+      return execute$4('ElectronWindow.close');
     default:
       throw new Error('not implemented');
   }
@@ -10896,7 +10898,7 @@ const close$2 = () => {
 const exit = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('Exit.exit');
+      return execute$4('Exit.exit');
     default:
       throw new Error('not implemented');
   }
@@ -10904,7 +10906,7 @@ const exit = () => {
 const openNew = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.openNew');
+      return execute$4('ElectronWindow.openNew');
     default:
       throw new Error('not implemented');
   }
@@ -10912,7 +10914,7 @@ const openNew = () => {
 const zoomIn = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.zoomIn');
+      return execute$4('ElectronWindow.zoomIn');
     default:
       throw new Error('not implemented');
   }
@@ -10920,7 +10922,7 @@ const zoomIn = () => {
 const zoomOut = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.zoomOut');
+      return execute$4('ElectronWindow.zoomOut');
     default:
       throw new Error('not implemented');
   }
@@ -10928,7 +10930,7 @@ const zoomOut = () => {
 const zoomReset = () => {
   switch (getPlatform$2()) {
     case Electron$1:
-      return execute$3('ElectronWindow.zoomReset');
+      return execute$4('ElectronWindow.zoomReset');
     default:
       throw new Error('not implemented');
   }
@@ -11833,9 +11835,9 @@ const showColorThemeCss = async () => {
   Main.openRawText('css://color-theme.css', colorThemeCss);
 };
 const clearCache = async () => {
-  await execute$3(/* CacheStorage.clearCache */'CacheStorage.clearCache');
-  await execute$3(/* LocalStorage.clear */'LocalStorage.clear');
-  await execute$3(/* SessionStorage.clear */'SessionStorage.clear');
+  await execute$4(/* CacheStorage.clearCache */'CacheStorage.clearCache');
+  await execute$4(/* LocalStorage.clear */'LocalStorage.clear');
+  await execute$4(/* SessionStorage.clear */'SessionStorage.clear');
 };
 const openProcessExplorer = () => {
   return open();
@@ -11844,8 +11846,8 @@ const showGpuInfo = () => {
   return invoke$F('Developer.showGpuInfo');
 };
 const downloadViewletState = async () => {
-  const states = await execute$3('Viewlet.getAllStates');
-  await execute$3('Download.downloadJson', /* json */states, /* fileName */'viewlets.json');
+  const states = await execute$4('Viewlet.getAllStates');
+  await execute$4('Download.downloadJson', /* json */states, /* fileName */'viewlets.json');
 };
 const openStorageOverview = async () => {
   await openUri$1('storage-overview://');
@@ -11928,14 +11930,14 @@ const state$9 = {
 };
 const openFileWeb = async () => {
   try {
-    const [fileHandle] = await execute$3('FilePicker.showFilePicker', {
+    const [fileHandle] = await execute$4('FilePicker.showFilePicker', {
       multiple: false
     });
     if (!fileHandle) {
       return;
     }
     const uri = `html:///${fileHandle.name}`;
-    await execute$3('PersistentFileHandle.addHandle', uri, fileHandle);
+    await execute$4('PersistentFileHandle.addHandle', uri, fileHandle);
     await openUri$1(uri);
   } catch (error) {
     if (isAbortError(error)) {
@@ -12286,7 +12288,7 @@ const state$8 = {
 };
 const getWebExtensionManifest = async path => {
   const manifestPath = `${path}/extension.json`;
-  const manifest = await execute$3(/* Ajax.getJson */'Ajax.getJson', /* url */manifestPath);
+  const manifest = await execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */manifestPath);
   return {
     ...manifest,
     path
@@ -13644,7 +13646,7 @@ const Viewlet_ipc = {
 
 const toggleFullScreen = () => {
   if (getPlatform$2() === Electron$1) {
-    return execute$3('ElectronWindow.toggleFullScreen');
+    return execute$4('ElectronWindow.toggleFullScreen');
   }
   return invoke$I('Window.toggleFullScreen');
 };
@@ -13744,7 +13746,7 @@ const executeCallback2 = (callbackId, ...args) => {
 
 const show$6 = async (...args) => {
   // TODO show custom quickpick
-  await execute$3('Viewlet.openWidget', QuickPick, ...args);
+  await execute$4('Viewlet.openWidget', QuickPick, ...args);
   return undefined;
 };
 const showFile = () => {
@@ -13800,7 +13802,7 @@ const show$5 = async picks => {
     resolve,
     promise
   } = withResolvers();
-  await execute$3('QuickPick.showCustom', picks, resolve);
+  await execute$4('QuickPick.showCustom', picks, resolve);
   return promise;
 };
 const showQuickPick = options => {
@@ -13823,7 +13825,7 @@ const ExtensionHostQuickPick_ipc = {
 
 const showInformationMessage = async message => {
   string(message);
-  const result = await execute$3('ConfirmPrompt.prompt', message);
+  const result = await execute$4('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -14843,14 +14845,14 @@ const getWebViewsWeb = async () => {
   const url = `${assetDir}/config/webViews.json`;
   // TODO move this to shared-process-web / network-process-web
   // TODO handle error ?
-  return execute$3(/* Ajax.getJson */'Ajax.getJson', /* url */url);
+  return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
 };
 
 const getWebViewsDefault = async () => {
   switch (getPlatform$2()) {
     case Web$1:
       return getWebViewsWeb();
-    case Test$1:
+    case Test:
       return [];
     default:
       return getWebViewsNode();
@@ -15085,8 +15087,8 @@ const doInvalidateExtensionsCache = async () => {
 };
 const handleExtensionsCacheInvalidated = async () => {
   try {
-    await execute$3('KeyBindings.hydrate');
-    await execute$3('Layout.handleExtensionsChanged');
+    await execute$4('KeyBindings.hydrate');
+    await execute$4('Layout.handleExtensionsChanged');
   } catch {
     // ignore
   }
@@ -16233,7 +16235,7 @@ const handleClickOk = async state => {
   const {
     okCommand
   } = state;
-  await execute$3(okCommand);
+  await execute$4(okCommand);
   return state;
 };
 const handleClickClose = async state => {
@@ -16766,7 +16768,7 @@ const handleClick$1 = async (state, index) => {
     case 'Show Command Output':
       await dispose$q();
       const uri = 'data://';
-      await execute$3(/* Main.openUri */'Main.openUri', uri);
+      await execute$4(/* Main.openUri */'Main.openUri', uri);
       // TODO show stderr in editor
       // TODO close dialog
       break;
@@ -17166,11 +17168,11 @@ const handleClickAt$1 = async (state, eventX, eventY) => {
   return state;
 };
 const handleSashCornerPointerDown = async (state, eventX, eventY) => {
-  await execute$3('Layout.handleSashPointerDown', Preview$2);
+  await execute$4('Layout.handleSashPointerDown', Preview$2);
   return state;
 };
 const handleSashCornerPointerMove = async (state, eventX, eventY) => {
-  await execute$3('Layout.handleSashPointerMove', eventX, eventY);
+  await execute$4('Layout.handleSashPointerMove', eventX, eventY);
   return state;
 };
 const handleSashCornerPointerUp = state => {
@@ -18535,7 +18537,7 @@ const updateSemanticTokens = async state => {
     console.log({
       newSemanticTokens
     });
-    await execute$3(/* Editor.setDecorations */'Editor.setDecorations', /* decorations */newSemanticTokens);
+    await execute$4(/* Editor.setDecorations */'Editor.setDecorations', /* decorations */newSemanticTokens);
     // TODO apply semantic tokens to editor and rerender
     // TODO possibly overlay semantic tokens as decorations
   } catch (error) {
@@ -19607,7 +19609,7 @@ const rerender = async state => {
   };
 };
 const handleClickAction$1 = async (state, index, command) => {
-  await execute$3('ExtensionHost.executeCommand', command);
+  await execute$4('ExtensionHost.executeCommand', command);
   return state;
 };
 const handleInput$2 = (state, name, value) => {
@@ -20252,7 +20254,7 @@ const getUri = (state, index) => {
 const selectIndexLead = async (state, index) => {
   const uri = getUri(state, index);
   // TODO open file and jump to line
-  await execute$3(/* Main.openUri */'Main.openUri', /* uri */uri);
+  await execute$4(/* Main.openUri */'Main.openUri', /* uri */uri);
   return {
     ...state,
     focusedIndex: index
@@ -20638,7 +20640,7 @@ const ViewletKeyBindings_ipc = {
 
 const Deb = 'Deb';
 
-const commit = '98fc4d9';
+const commit = 'fe7bb55';
 
 const getAutoUpdateType = () => {
   return invoke$F('AutoUpdater.getAutoUpdateType');
@@ -21855,7 +21857,7 @@ const closeChat = state => {
   return hideSecondarySideBar(state);
 };
 const openCommandPalette = async state => {
-  await execute$3('QuickPick.showCommands');
+  await execute$4('QuickPick.showCommands');
   return {
     newState: state,
     commands: []
@@ -22026,7 +22028,7 @@ const showPreview = async (state, uri = state.previewUri) => {
       return replacePreview(state, uri, previewViewletId);
     }
     if (previewViewletId === Preview$3) {
-      await execute$3('Preview.setUri', uri);
+      await execute$4('Preview.setUri', uri);
     }
     return {
       newState: {
@@ -22690,7 +22692,7 @@ const handleFocus = state => {
   return handleFocusChange$1(state, true);
 };
 const showE2eTests = async state => {
-  await execute$3('SideBar.show', 'E2eTests');
+  await execute$4('SideBar.show', 'E2eTests');
   return state;
 };
 const handleBlur$1 = state => {
@@ -22943,7 +22945,7 @@ const refreshSourceControlBadgeCount = async state => {
   }
 };
 const contentLoadedEffects = async () => {
-  await execute$3('Layout.refreshSourceControlBadgeCount');
+  await execute$4('Layout.refreshSourceControlBadgeCount');
 };
 const handleBadgeCountChange = async (state, changes) => {
   return callGlobalEvent(state, 'handleBadgeCountChange', changes);
@@ -22973,6 +22975,9 @@ const setBadgeCount = async (state, moduleId, badgeCount) => {
 const handleExtensionsChanged = async state => {
   return callGlobalEvent(state, 'handleExtensionsChanged');
 };
+const handleColorThemeChanged = async (state, colorThemeId) => {
+  return callGlobalEvent(state, 'handleColorThemeChanged', colorThemeId);
+};
 const getActiveSideBarView = state => {
   return state.sideBarView;
 };
@@ -23033,9 +23038,9 @@ const getHref = state => {
 const defaultColorTheme = 'slime';
 const defaultTitleTemplate = '${folderName}';
 const closeWidgets = async () => {
-  await execute$3('Viewlet.closeWidget', QuickPick);
-  await execute$3('Viewlet.closeWidget', Dialog);
-  await execute$3('Viewlet.closeWidget', Confirm$1);
+  await execute$4('Viewlet.closeWidget', QuickPick);
+  await execute$4('Viewlet.closeWidget', Dialog);
+  await execute$4('Viewlet.closeWidget', Confirm$1);
 };
 const getActivityBarBounds = () => {
   const state = getState$1(Layout);
@@ -23053,35 +23058,39 @@ const resetActivityBar = async () => {
     x,
     y
   } = getActivityBarBounds();
-  await execute$3('ActivityBar.create', '', x, y, width, height, null, null, -1);
-  await execute$3('ActivityBar.loadContent', {});
+  await execute$4('ActivityBar.create', '', x, y, width, height, null, null, -1);
+  await execute$4('ActivityBar.loadContent', {});
 };
 const reset = async state => {
-  await execute$3('Menu.hide', false);
-  await execute$3('TitleBar.closeMenu');
-  await execute$3('TitleBar.setTitleTemplate', defaultTitleTemplate);
-  await execute$3('TitleBar.setWidth', state.titleBarWidth);
+  await execute$4('Menu.hide', false);
+  await execute$4('TitleBar.closeMenu');
+  await execute$4('TitleBar.setTitleTemplate', defaultTitleTemplate);
+  await execute$4('TitleBar.setWidth', state.titleBarWidth);
   await closeWidgets();
-  await execute$3('ColorTheme.setColorTheme', defaultColorTheme);
-  await execute$3('Main.closeAllEditors');
-  const workspacePath = await execute$3('Workspace.getPath');
+  await execute$4('ColorTheme.setColorTheme', defaultColorTheme);
+  await execute$4('Main.closeAllEditors');
+  const workspacePath = await execute$4('Workspace.getPath');
   if (workspacePath) {
-    await execute$3('Workspace.close');
+    await execute$4('Workspace.close');
   }
   if (state.sideBarFocusMode) {
-    await execute$3('Layout.leaveSideBarFocusMode');
+    await execute$4('Layout.leaveSideBarFocusMode');
   }
   if (state.sideBarLocation !== Right) {
-    await execute$3('Layout.moveSideBarRight');
+    await execute$4('Layout.moveSideBarRight');
   }
   if (!state.sideBarVisible || state.sideBarView !== Explorer$1) {
-    await execute$3('Layout.showSideBar', Explorer$1);
+    await execute$4('Layout.showSideBar', Explorer$1);
   }
-  if (state.panelVisible) {
+  const panelViewNeedsReset = state.panelView !== Problems;
+  if (state.panelVisible || panelViewNeedsReset) {
     if (state.panelMaximized) {
-      await execute$3('Layout.unmaximizePanel');
+      await execute$4('Layout.unmaximizePanel');
+    }
+    if (panelViewNeedsReset) {
+      await execute$4('Layout.showPanel', Problems);
     }
-    await execute$3('Layout.hidePanel');
+    await execute$4('Layout.hidePanel');
   }
   await resetActivityBar();
   return {
@@ -23113,6 +23122,7 @@ const Commands$m = {
 const CommandsWithSideEffects = {
   attachViewlet: attachViewlet,
   handleBadgeCountChange: handleBadgeCountChange,
+  handleColorThemeChanged: handleColorThemeChanged,
   handleExtensionsChanged: handleExtensionsChanged,
   handleBlur: handleBlur$1,
   handleContextMenu: handleContextMenu$1,
@@ -24179,6 +24189,7 @@ const ViewletLayout_ipc = {
   getUserInfo,
   handleBadgeCountChange,
   handleBlur: handleBlur$1,
+  handleColorThemeChanged,
   handleContextMenu: handleContextMenu$1,
   handleExtensionsChanged,
   handleFocus,
@@ -26726,11 +26737,11 @@ const handleClickAction = async (state, index, command) => {
   }
   const currentViewletId = getId$1(state);
   if (currentViewletId.includes('.')) {
-    await execute$3('ExtensionHost.executeCommand', command);
+    await execute$4('ExtensionHost.executeCommand', command);
     return state;
   }
   const fullCommand = `${currentViewletId}.${command}`;
-  await execute$3(fullCommand);
+  await execute$4(fullCommand);
   return state;
 };
 
@@ -26773,7 +26784,7 @@ const create$9 = (id, uri, x, y, width, height) => {
 const loadContent$9 = async (state, savedState, targetViewletId) => {
   // TODO get it from layout state
   const restore = savedState?.restore !== false;
-  let savedViewletId = restore ? targetViewletId || (await execute$3('Layout.getActiveSideBarView')) : Explorer$1;
+  let savedViewletId = restore ? targetViewletId || (await execute$4('Layout.getActiveSideBarView')) : Explorer$1;
   if (!savedViewletId) {
     savedViewletId = Explorer$1;
   }
@@ -26941,7 +26952,7 @@ const setTitle = (state, title) => {
 
 // TODO no default parameter -> monomorphism
 const openViewlet$1 = async (state, moduleId, focus = false, args) => {
-  await execute$3('Layout.openSideBarViewlet', moduleId);
+  await execute$4('Layout.openSideBarViewlet', moduleId);
   return state;
 };
 const dispose$6 = state => {
@@ -26988,7 +26999,7 @@ const focus$2 = async state => {
   if (!currentViewlet) {
     return state;
   }
-  await execute$3(`${currentViewletId}.focus`);
+  await execute$4(`${currentViewletId}.focus`);
   // if (!currentViewlet.factory.focus) {
   //   throw new Error(`missing focus function for ${currentViewletId}`)
   // }
@@ -27115,7 +27126,7 @@ const create$8 = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$8 = async (state, savedState) => {
-  let savedViewletId = await execute$3('Layout.getActiveSecondarySideBarView');
+  let savedViewletId = await execute$4('Layout.getActiveSecondarySideBarView');
   if (!savedViewletId) {
     savedViewletId = Chat;
   }
@@ -27173,8 +27184,8 @@ const handleSecondarySideBarViewletChange = async (state, moduleId) => {
   };
 };
 const openViewlet = async (state, moduleId, focus = false, args) => {
-  await execute$3('Layout.showSecondarySideBar');
-  await execute$3('Layout.openSecondarySideBarViewlet', moduleId);
+  await execute$4('Layout.showSecondarySideBar');
+  await execute$4('Layout.openSecondarySideBarViewlet', moduleId);
   return state;
 };
 const dispose$5 = state => {};
@@ -27213,7 +27224,7 @@ const focus$1 = async state => {
   if (!currentViewlet) {
     return state;
   }
-  await execute$3(`${currentViewletId}.focus`);
+  await execute$4(`${currentViewletId}.focus`);
   return state;
 };
 const handleUpdateStateChange = state => {
@@ -28188,7 +28199,7 @@ const loadContent$6 = async (state, savedState) => {
   const commands = await invoke$n('SourceControl.render2', state.uid, diffResult);
   const actionsDom = await invoke$n('SourceControl.renderActions2', state.uid);
   const badgeCount = await invoke$n('SourceControl.getBadgeCount', state.uid);
-  await execute$3('Layout.setBadgeCount', SourceControl, badgeCount);
+  await execute$4('Layout.setBadgeCount', SourceControl, badgeCount);
   return {
     ...state,
     commands,
@@ -28313,7 +28324,7 @@ const wrapSourceControlCommand = key => {
       };
       setState$1(state.uid, newState);
       setRenderedState(state.uid, newState);
-      await execute$3('Layout.setBadgeCount', SourceControl, badgeCount);
+      await execute$4('Layout.setBadgeCount', SourceControl, badgeCount);
     }
     return {
       ...state,
@@ -28948,7 +28959,7 @@ const getTerminalModuleId = () => {
 };
 const createViewlet = async (state, childUid) => {
   const bounds = getChildBounds(state);
-  await execute$3('Layout.createViewlet', getTerminalModuleId(), childUid, 0, bounds, '');
+  await execute$4('Layout.createViewlet', getTerminalModuleId(), childUid, 0, bounds, '');
 };
 const loadContent$2 = async state => {
   const terminalTabsEnabled = get$d('terminal.tabs.enabled');
@@ -29478,7 +29489,7 @@ const ViewletWebView_ipc = {
 };
 
 const readFile$5 = () => {
-  return execute$3(/* Developer.getStartupPerformanceContent */'Developer.getStartupPerformanceContent');
+  return execute$4(/* Developer.getStartupPerformanceContent */'Developer.getStartupPerformanceContent');
 };
 const writeFile$5 = () => {
   throw new Error('not implemented');
@@ -29491,7 +29502,7 @@ const FileSystemAppStartupPerformance = {
 };
 
 const readFile$4 = () => {
-  return execute$3('Developer.getMemoryUsageContent');
+  return execute$4('Developer.getMemoryUsageContent');
 };
 const writeFile$4 = () => {
   throw new Error('not implemened');
@@ -29581,7 +29592,7 @@ const readJsonInternal = async (getPath, defaultContent = '') => {
 };
 const writeFileWeb = async (path, content) => {
   if (getPlatform$2() === Web$1) {
-    await execute$3(/* LocalStorage.setText */'LocalStorage.setText', /* key */path, /* value */content);
+    await execute$4(/* LocalStorage.setText */'LocalStorage.setText', /* key */path, /* value */content);
   }
 };
 const writeFileNode = async (path, content) => {
@@ -29725,7 +29736,7 @@ const openContextMenu = async (x, y, id, ...args) => {
     return;
   }
   const commandArgs = item.args || [];
-  await execute$3(item.command, ...commandArgs);
+  await execute$4(item.command, ...commandArgs);
 };
 const openContextMenu2 = async (x, y, uid, menuId, ...args) => {
   const entries = await getMenuEntries2(uid, menuId, ...args);
@@ -29739,7 +29750,7 @@ const openContextMenu2 = async (x, y, uid, menuId, ...args) => {
     return;
   }
   const commandArgs = item.args || [];
-  await execute$3(item.command, ...commandArgs);
+  await execute$4(item.command, ...commandArgs);
 };
 
 const show$1 = (x, y, id, ...args) => {
@@ -29780,13 +29791,13 @@ const ContextMenuBrowser = {
 
 const openFolder$2 = async () => {
   try {
-    const result = await execute$3('FilePicker.showDirectoryPicker', {
+    const result = await execute$4('FilePicker.showDirectoryPicker', {
       startIn: 'pictures',
       mode: 'readwrite'
     });
     const uri = `html:///${result.name}`;
-    await execute$3('PersistentFileHandle.addHandle', uri, result);
-    await execute$3('Workspace.setPath', uri);
+    await execute$4('PersistentFileHandle.addHandle', uri, result);
+    await execute$4('Workspace.setPath', uri);
   } catch (error) {
     if (isAbortError(error)) {
       return;
@@ -29805,7 +29816,7 @@ const openFolder$1 = async () => {
   if (!path) {
     return;
   }
-  await execute$3(/* Workspace.setPath */'Workspace.setPath', /* path */path);
+  await execute$4(/* Workspace.setPath */'Workspace.setPath', /* path */path);
 };
 
 const OpenFolderRemote = {
@@ -29819,7 +29830,7 @@ const openFolder = async () => {
     return;
   }
   const path = folders[0];
-  await execute$3(/* Workspace.setPath */'Workspace.setPath', /* path */path);
+  await execute$4(/* Workspace.setPath */'Workspace.setPath', /* path */path);
 };
 
 const OpenFolderElectron = {
@@ -29831,7 +29842,7 @@ const openExternal = async state => {
   const {
     iframeSrc
   } = state;
-  await execute$3('Open.openExternal', iframeSrc);
+  await execute$4('Open.openExternal', iframeSrc);
   return state;
 };
 
@@ -29842,7 +29853,7 @@ const ViewletSimpleBrowserOpenExternal = {
 
 const openBackgroundTab = async (state, url) => {
   const simpleBrowserUrl = 'simple-browser://';
-  await execute$3('Main.openBackgroundTab', simpleBrowserUrl, {
+  await execute$4('Main.openBackgroundTab', simpleBrowserUrl, {
     iframeSrc: url
   });
   // TODO