@lvce-editor/static-server 0.64.5 → 0.66.6

package/static/{488a9bc → 26ac40c}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -96,7 +96,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/488a9bc';
+    return '/26ac40c';
   }
 };
 const assetDir = getAssetDir();
@@ -225,9 +225,9 @@ const get$h = id => {
 const remove$b = id => {
   delete callbacks[id];
 };
-let id$n = 0;
+let id$m = 0;
 const create$3$1 = () => {
-  return ++id$n;
+  return ++id$m;
 };
 const registerPromise = () => {
   const id = create$3$1();
@@ -420,7 +420,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const invoke$t = (ipc, method, ...params) => {
+const invoke$v = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$a = (ipc, method, ...params) => {
@@ -1037,7 +1037,7 @@ const IpcChildWithModuleWorker$1 = {
   wrap: wrap$6$1
 };
 
-const getModule$8 = method => {
+const getModule$7 = method => {
   switch (method) {
     case ModuleWorker$1:
       return IpcChildWithModuleWorker$1;
@@ -1049,7 +1049,7 @@ const getModule$8 = method => {
 const listen$2 = async ({
   method
 }) => {
-  const module = await getModule$8(method);
+  const module = await getModule$7(method);
   const rawIpc = await module.listen();
   // @ts-ignore
   if (module.signal) {
@@ -1079,8 +1079,8 @@ const listen$1 = async () => {
   handleIpc(ipc);
   state$G.ipc = ipc;
 };
-const invoke$s = (method, ...params) => {
-  return invoke$t(state$G.ipc, method, ...params);
+const invoke$u = (method, ...params) => {
+  return invoke$v(state$G.ipc, method, ...params);
 };
 const invokeAndTransfer$9 = (method, ...params) => {
   return invokeAndTransfer$a(state$G.ipc, method, ...params);
@@ -1101,7 +1101,7 @@ const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
 };
 const addCssStyleSheet = (id, css) => {
-  return invoke$s('Css.addCssStyleSheet', id, css);
+  return invoke$u('Css.addCssStyleSheet', id, css);
 };
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
   const css = await getCss(preferences);
@@ -1125,7 +1125,7 @@ const getOrCreateWorker = fn => {
   return {
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invoke$t(ipc, method, ...params);
+      return invoke$v(ipc, method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
@@ -1163,7 +1163,7 @@ const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 const Node = 7;
 const NodeAlternate = 8;
 
-const getModule$7 = method => {
+const getModule$6 = method => {
   switch (method) {
     case ElectronMessagePort:
       return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; });
@@ -1190,7 +1190,7 @@ const create$10 = async ({
   method,
   ...options
 }) => {
-  const module = await getModule$7(method);
+  const module = await getModule$6(method);
   // @ts-ignore
   const rawIpc = await module.create(options);
   if (options.noReturn) {
@@ -1217,7 +1217,7 @@ const set$h = async (key, value) => {
   state$F[key] = value;
 };
 
-const getConfiguredWorkerUrl$m = () => {
+const getConfiguredWorkerUrl$o = () => {
   let configuredWorkerUrl = get$g('develop.errorWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -1233,14 +1233,14 @@ const launchErrorWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$m()
+    url: getConfiguredWorkerUrl$o()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$r,
+  invoke: invoke$t,
   invokeAndTransfer: invokeAndTransfer$8
 } = getOrCreateWorker(launchErrorWorker);
 
@@ -1262,14 +1262,14 @@ const serializeError = error => {
 const prepare = async error => {
   try {
     const serialized = serializeError(error);
-    const prepared = await invoke$r('Errors.prepare', serialized);
+    const prepared = await invoke$t('Errors.prepare', serialized);
     return prepared;
   } catch {
     return error;
   }
 };
 const print = async (error, prefix = '') => {
-  await invoke$r('Errors.print', error, prefix);
+  await invoke$t('Errors.print', error, prefix);
 };
 const getMessage$3 = error => {
   if (error && error.type && error.message) {
@@ -1635,6 +1635,12 @@ const writeFile$f = async (uri, content, encoding = Utf8) => {
   const fileSystem = await getFileSystem(protocol);
   await fileSystem.writeFile(path, content, encoding);
 };
+const writeBlob$1 = async (uri, blob) => {
+  const protocol = getProtocol(uri);
+  const path = getPath$1(protocol, uri);
+  const fileSystem = await getFileSystem(protocol);
+  await fileSystem.writeBlob(path, blob);
+};
 const readDirWithFileTypes$9 = async uri => {
   const protocol = getProtocol(uri);
   const path = getPath$1(protocol, uri);
@@ -1763,11 +1769,11 @@ const state$A = {
 };
 
 /* istanbul ignore file */
-const invoke$q = async (method, ...params) => {
+const invoke$s = async (method, ...params) => {
   const {
     ipc
   } = state$A;
-  const result = await invoke$t(ipc, method, ...params);
+  const result = await invoke$v(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$7 = async (method, ...params) => {
@@ -1812,7 +1818,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$q(PreferencesGetAll);
+  return invoke$s(PreferencesGetAll);
 };
 const getPreferences = async () => {
   // TODO cache preferences, but they should not be stale
@@ -1871,7 +1877,7 @@ const state$z = {
 };
 
 const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$q(/* Workspace.resolveRoot */WorkspaceResolveRoot);
+  const resolvedRoot = await invoke$s(/* Workspace.resolveRoot */WorkspaceResolveRoot);
   return resolvedRoot;
 };
 const isValid$1 = resolvedRoot => {
@@ -1937,20 +1943,20 @@ const getResolvedRoot = async href => {
 };
 
 const getHref = () => {
-  return invoke$s(/* Location.getHref */'Location.getHref');
+  return invoke$u(/* Location.getHref */'Location.getHref');
 };
 const setPathName = pathName => {
-  return invoke$s(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+  return invoke$u(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
 const hydrate$a = () => {
-  return invoke$s(/* Location.hydrate */'Location.hydrate');
+  return invoke$u(/* Location.hydrate */'Location.hydrate');
 };
 const getHost = () => {
   return location.host;
 };
 
 const set$f = title => {
-  return invoke$s('WindowTitle.set', title);
+  return invoke$u('WindowTitle.set', title);
 };
 
 /**
@@ -2082,15 +2088,15 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$t(ipc, 'Workspace.setWorkspacePath', state$z.workspacePath);
+  await invoke$v(ipc, 'Workspace.setWorkspacePath', state$z.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$t(ipc, 'Workspace.setWorkspacePath', state$z.workspacePath);
+    await invoke$v(ipc, 'Workspace.setWorkspacePath', state$z.workspacePath);
   });
   return ipc;
 };
 
 const {
-  invoke: invoke$p,
+  invoke: invoke$r,
   invokeAndTransfer: invokeAndTransfer$6
 } = getOrCreateWorker(launchExtensionHostWorker);
 
@@ -2120,11 +2126,11 @@ const getColorThemeCssCached = async (colorThemeId, getData) => {
 };
 
 const getColorThemeJson = colorThemeId => {
-  return invoke$p('ColorTheme.getColorThemeJson', colorThemeId);
+  return invoke$r('ColorTheme.getColorThemeJson', colorThemeId);
 };
 
 const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
-  return invoke$p('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
+  return invoke$r('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
 };
 const getColorThemeCssNew = async colorThemeId => {
   const colorThemeJson = await getColorThemeJson(colorThemeId);
@@ -2140,7 +2146,7 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$s(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$u(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
 };
 
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
@@ -2189,7 +2195,7 @@ const watch$1 = async id => {
     return;
   }
   state$y.watchedTheme = id;
-  await invoke$q('ExtensionHost.watchColorTheme', id);
+  await invoke$s('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get$e('workbench.colorTheme');
@@ -2216,10 +2222,34 @@ const hydrate$8 = async () => {
   }
 };
 
+const state$x = {
+  ipc: undefined
+};
+
+/**
+ *
+ * @returns {any}
+ */
+const get$d = () => {
+  return state$x.ipc;
+};
+const set$e = ipc => {
+  state$x.ipc = ipc;
+};
+
 const map$3 = Object.create(null);
-const handleEvent = (id, event) => {
+const handleEvent = async (id, event) => {
   const eventTarget = map$3[id];
   if (!eventTarget) {
+    const alternate = map2[id];
+    if (alternate) {
+      const ipc = get$d();
+      if (!ipc) {
+        return;
+      }
+      await invoke$v(ipc, alternate.callBackCommandId, event);
+      return;
+    }
     console.warn(`target not found ${id}`);
     return;
   }
@@ -2227,28 +2257,39 @@ const handleEvent = (id, event) => {
     detail: event
   }));
 };
+const map2 = Object.create(null);
+const watchFile = async (rpcId, callBackCommandId, uri) => {
+  const id = create$$();
+  map2[id] = {
+    rpcId,
+    callBackCommandId
+  };
+  // TODO use filesystem worker / file watcher worker
+  await invoke$s('FileWatcher.watchFile2', id, uri);
+  return map$3[id];
+};
 
-const state$x = {
+const state$w = {
   id: 0
 };
-const set$e = value => {
-  state$x.id = value;
+const set$d = value => {
+  state$w.id = value;
 };
-const get$d = () => {
-  return state$x.id;
+const get$c = () => {
+  return state$w.id;
 };
 
 // TODO cache window id
 
 const getWindowId = async () => {
-  const webContentsId = get$d();
-  const windowId = await invoke$q('GetWindowId.getWindowId', webContentsId);
+  const webContentsId = get$c();
+  const windowId = await invoke$s('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
 
 const forward$2 = key => async (...args) => {
   const windowId = await getWindowId();
-  return invoke$q(key, windowId, ...args);
+  return invoke$s(key, windowId, ...args);
 };
 const reload$3 = forward$2('ElectronWindow.reload');
 const minimize$1 = forward$2('ElectronWindow.minimize');
@@ -2267,7 +2308,7 @@ const reloadElectron = () => {
 };
 
 const reloadWeb = () => {
-  return invoke$s('Window.reload');
+  return invoke$u('Window.reload');
 };
 
 const getFn$2 = () => {
@@ -2306,49 +2347,49 @@ const getUrlBaseName = href => {
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$q(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+  return invoke$s(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
 };
 const getCachedExtensionsPath = () => {
-  return invoke$q(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
+  return invoke$s(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
 };
 const getLogsDir = () => {
   if (platform === Web$1) {
     return 'memfs://output';
   }
-  return invoke$q(/* Platform.getLogsDir */'Platform.getLogsDir');
+  return invoke$s(/* Platform.getLogsDir */'Platform.getLogsDir');
 };
 const getDownloadDir = () => {
-  return invoke$q(/* Platform.getDownloadDir */'Platform.getDownloadDir');
+  return invoke$s(/* Platform.getDownloadDir */'Platform.getDownloadDir');
 };
 const getUserSettingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$q(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
+  return invoke$s(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
 };
 const getUserKeyBindingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$q(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
+  return invoke$s(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
 };
 const getRecentlyOpenedPath = () => {
   if (platform === Web$1) {
     return 'recently-opened';
   }
-  return invoke$q(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
+  return invoke$s(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
 };
 const getConfigPath = () => {
-  return invoke$q(/* Platform.getConfigDir */'Platform.getConfigDir');
+  return invoke$s(/* Platform.getConfigDir */'Platform.getConfigDir');
 };
 const getCachePath = () => {
-  return invoke$q(/* Platform.getCacheDir */'Platform.getCacheDir');
+  return invoke$s(/* Platform.getCacheDir */'Platform.getCacheDir');
 };
 const getCacheName = () => {
   return 'lvce-runtime';
 };
 const getTestPathRemote = () => {
-  return invoke$q(/* Platform.getTestPath */'Platform.getTestPath');
+  return invoke$s(/* Platform.getTestPath */'Platform.getTestPath');
 };
 const getTestPathWeb = () => {
   return `${assetDir}/packages/extension-host-worker-tests`;
@@ -2364,29 +2405,19 @@ const getTestPath = () => {
       return getTestPathWeb();
   }
 };
-const getTmpDir$1 = () => {
+const getTmpDir = () => {
   if (platform === Web$1) {
     throw new Error('not implemented in web');
   }
-  return invoke$q(/* Platform.getTmpDir */'Platform.getTmpDir');
-};
-const getRepository = () => {
-  return invoke$q('Platform.getRepository');
+  return invoke$s(/* Platform.getTmpDir */'Platform.getTmpDir');
 };
 
-// TODO determine with websocket request or some
-// data in html that shows whether this test is
-// a typescript or javascript file
 const existsTest = async url => {
-  const tsResponse = await fetch(url, {
-    method: 'HEAD'
-  });
-  if (tsResponse.ok) {
-    return true;
-  }
-  return false;
+  const uri = url.replace('/remote', 'file://');
+  const exists = await exists$2(uri);
+  return exists;
 };
-const getTestFilePath = async href => {
+const getTestFilePath = async (platform, href) => {
   const testPath = await getTestPath();
   const baseName = getUrlBaseName(href);
   const jsFileName = baseName + '.js';
@@ -2403,7 +2434,7 @@ const getTestFilePath = async href => {
   return jsPath;
 };
 
-const getConfiguredWorkerUrl$l = (preferenceKey, fallback) => {
+const getConfiguredWorkerUrl$n = (preferenceKey, fallback) => {
   let configuredWorkerUrl = get$e(preferenceKey) || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -2415,37 +2446,27 @@ const getConfiguredWorkerUrl$l = (preferenceKey, fallback) => {
   return configuredWorkerUrl;
 };
 
-const state$w = {
-  ipc: undefined
-};
-const get$c = () => {
-  return state$w.ipc;
-};
-const set$d = ipc => {
-  state$w.ipc = ipc;
-};
-
 const testWorkerUrl = `${assetDir}/packages/test-worker/dist/testWorkerMain.js`;
 
 const launchTestWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$l('develop.testWorkerPath', testWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$n('develop.testWorkerPath', testWorkerUrl);
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
     name: 'Test Worker'
   });
   handleIpc(ipc);
-  set$d(ipc);
+  set$e(ipc);
   return ipc;
 };
 
 const execute$3 = async href => {
   const ipc = await launchTestWorker();
-  await invoke$t(ipc, 'Test.execute', href, platform, assetDir);
+  await invoke$v(ipc, 'Test.execute', href, platform, assetDir);
 };
 
-const executeCurrentTest = async initData => {
-  const jsPath = await getTestFilePath(initData.Location.href);
+const executeCurrentTest = async (platform, initData) => {
+  const jsPath = await getTestFilePath(platform, initData.Location.href);
   await execute$3(jsPath);
 };
 
@@ -2564,7 +2585,7 @@ const getAvailableKeyBindings = keyBindings => {
 const update = () => {
   const matchingKeyBindings = getMatchingKeyBindings(state$u.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$s('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  invoke$u('KeyBindings.setIdentifiers', keyBindingIdentifiers);
   state$u.matchingKeyBindings = matchingKeyBindings;
   state$u.keyBindingIdentifiers = keyBindingIdentifiers;
 };
@@ -2741,13 +2762,13 @@ const serializeObjects = objects => {
 };
 
 const clear$5 = async storageType => {
-  await invoke$s(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$u(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$s('WebStorage.getAll', storageType);
+  return invoke$u('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$s(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$u(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$6 = async (storageType, key) => {
@@ -2762,7 +2783,7 @@ const getJson$6 = async (storageType, key) => {
   }
 };
 const setText$1 = async (storageType, key, value) => {
-  await invoke$s(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$u(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$5 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -2770,7 +2791,7 @@ const setJson$5 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = serializeObjects(objects);
-  await invoke$s('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$u('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -2957,7 +2978,7 @@ const ExtensionStateStorage = {
 };
 
 const saveState$k = async () => {
-  const state = await invoke$p('SaveState.saveState');
+  const state = await invoke$r('SaveState.saveState');
   return state;
 };
 const getSavedState = async () => {
@@ -3012,7 +3033,7 @@ const hydrate$5 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$s('Window.onVisibilityChange');
+  await invoke$u('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$4(viewletId);
@@ -3036,7 +3057,7 @@ const ViewletManagerVisitorCss = {
 
 const fileSearchWorkerUrl = `${assetDir}/packages/file-search-worker/dist/fileSearchWorkerMain.js`;
 
-const getConfiguredWorkerUrl$k = () => {
+const getConfiguredWorkerUrl$m = () => {
   let configuredWorkerUrl = get$e('develop.fileSearchWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -3052,14 +3073,14 @@ const launchFileSearchWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$k()
+    url: getConfiguredWorkerUrl$m()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$o} = getOrCreateWorker(launchFileSearchWorker);
+  invoke: invoke$q} = getOrCreateWorker(launchFileSearchWorker);
 
 const state$r = {
   /**
@@ -3075,7 +3096,7 @@ const add$1 = async menuEntries => {
   // TODO store menu entries here or in file search worker?
   // Usually don't want to start worker for the menu entries
   // But also quickpick menu entries would be better stored there
-  await invoke$o('QuickPick.addMenuEntries', menuEntries);
+  await invoke$q('QuickPick.addMenuEntries', menuEntries);
 };
 
 const loadModule$2 = async (id, module) => {
@@ -3134,7 +3155,7 @@ const QuickPick = 'QuickPick';
 const References = 'References';
 const RunAndDebug = 'Run And Debug';
 const ScreenCapture = 'ScreenCapture';
-const Search$1 = 'Search';
+const Search = 'Search';
 const SideBar$2 = 'SideBar';
 const SimpleBrowser$1 = 'SimpleBrowser';
 const SourceControl$1 = 'Source Control';
@@ -3205,7 +3226,7 @@ const ViewletModuleId = {
   References,
   RunAndDebug,
   ScreenCapture,
-  Search: Search$1,
+  Search,
   Settings: Settings$1,
   SideBar: SideBar$2,
   SimpleBrowser: SimpleBrowser$1,
@@ -3251,6 +3272,9 @@ const runFn = async (instance, id, key, fn, args) => {
   if (instance.factory && instance.factory.hasFunctionalRender) {
     const oldState = instance.state;
     const newState = await fn(oldState, ...args);
+    if (key === 'getAllQuickPickMenuEntries') {
+      return newState;
+    }
     if (!newState) {
       console.log({
         fn
@@ -3264,7 +3288,7 @@ const runFn = async (instance, id, key, fn, args) => {
     const commands = render$F(instance.factory, oldState, newState, newState.uid || id);
     updateDynamicFocusContext(commands);
     setRenderedState(id, newState);
-    await invoke$s(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$u(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3290,7 +3314,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
     return;
   }
   updateDynamicFocusContext(commands);
-  await invoke$s(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$u(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -3311,7 +3335,8 @@ const wrapViewletCommand = (id, key, fn$1) => {
   const wrappedViewletCommand = async (...args) => {
     // TODO get actual focused instance
     const activeInstance = getInstance(id);
-    await runFn(activeInstance, id, key, fn$1, args);
+    const result = await runFn(activeInstance, id, key, fn$1, args);
+    return result;
   };
   nameAnonymousFunction(wrappedViewletCommand, `${id}/${key}`);
   return wrappedViewletCommand;
@@ -3495,7 +3520,7 @@ const maybeRegisterEvents = module => {
       const commands = render$F(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
       instance.state = newState;
       instance.renderedState = newState;
-      await invoke$s(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$u(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     };
     addListener('workspace.change', handleUpdate);
   }
@@ -3522,7 +3547,7 @@ const maybeRegisterEvents = module => {
         const commands = render$F(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$s(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$u(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -3550,7 +3575,7 @@ const maybeRegisterMenuEntries = async module => {
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
   if (!module.hasFunctionalEvents) {
-    await invoke$s(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
+    await invoke$u(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
   }
   await loadModule$1(id, module);
   await maybeRegisterWrappedCommands(id, module);
@@ -3644,7 +3669,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.renderEventListeners) {
       // TODO reuse event listeners between components
       const eventListeners = await module.renderEventListeners();
-      await invoke$s('Viewlet.registerEventListeners', viewletUid, eventListeners);
+      await invoke$u('Viewlet.registerEventListeners', viewletUid, eventListeners);
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
       await module.show(newState);
@@ -3698,7 +3723,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$s(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$u(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -3756,7 +3781,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       commands.push(...extraCommands);
       updateDynamicFocusContext(commands);
-      await invoke$s(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$u(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else if (!module.hasFunctionalEvents && shouldRender) {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -3777,7 +3802,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$s(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$u(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -3799,10 +3824,10 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$s(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$u(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$s(kLoadModule, Error$3);
+      await invoke$u(kLoadModule, Error$3);
       commands.push([kCreate, Error$3, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -3811,7 +3836,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       if (module && module.customErrorRenderer) {
         const errorModule = await loadModule(viewlet.getModule, module.customErrorRenderer);
         const dom = await errorModule.render(error);
-        await invoke$s(kLoadModule, module.customErrorRenderer);
+        await invoke$u(kLoadModule, module.customErrorRenderer);
         commands.push([kCreate, module.customErrorRenderer, viewletUid]);
         commands.push(['Viewlet.setDom2', viewletUid, dom]);
         commands.push([kAppend, parentUid, viewletUid]);
@@ -3863,7 +3888,7 @@ const load$4 = async moduleId => {
 };
 
 const disposeBrowserViewQuickPick = () => {
-  return invoke$q('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
+  return invoke$s('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
 const handleKeyBinding$1 = async identifier => {
@@ -3913,7 +3938,7 @@ const focus$5 = async id => {
     commands.push(...render$F(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$s('Viewlet.sendMultiple', commands);
+  await invoke$u('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -3956,7 +3981,7 @@ const dispose$r = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$s(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$u(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -4137,7 +4162,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$s(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$u(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -4180,7 +4205,7 @@ const openWidget = async (moduleId, ...args) => {
   // TODO send focus changes to renderer process together with other message
   updateDynamicFocusContext(commands);
   commands.push(['Viewlet.focus', childUid]);
-  await invoke$s('Viewlet.executeCommands', commands);
+  await invoke$u('Viewlet.executeCommands', commands);
 };
 const closeWidget = async id => {
   try {
@@ -4192,7 +4217,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$s(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$u(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4250,7 +4275,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$s(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$u(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 
 // @ts-ignore
@@ -4290,7 +4315,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$s('Viewlet.sendMultiple', commands);
+    await invoke$u('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4326,7 +4351,7 @@ const handleIconThemeChange$1 = async () => {
 
 const iconThemeWorkerUrl = `${assetDir}/packages/icon-theme-worker/dist/iconThemeWorkerMain.js`;
 
-const getConfiguredWorkerUrl$j = () => {
+const getConfiguredWorkerUrl$l = () => {
   let configuredWorkerUrl = get$e('develop.iconThemeWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -4342,37 +4367,37 @@ const launchIconThemeWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$j()
+    url: getConfiguredWorkerUrl$l()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$n,
+  invoke: invoke$p,
   invokeAndTransfer: invokeAndTransfer$5
 } = getOrCreateWorker(launchIconThemeWorker);
 
 const getFileIcon$1 = file => {
-  return invoke$n('IconTheme.getFileIcon', file);
+  return invoke$p('IconTheme.getFileIcon', file);
 };
 const getFileIcons = fileNames => {
-  return invoke$n('IconTheme.getFileIcons', fileNames);
+  return invoke$p('IconTheme.getFileIcons', fileNames);
 };
 const getFolderIcon = folder => {
-  return invoke$n('IconTheme.getFolderIcon', folder);
+  return invoke$p('IconTheme.getFolderIcon', folder);
 };
 const getIcon = dirent => {
-  return invoke$n('IconTheme.getIcon', dirent);
+  return invoke$p('IconTheme.getIcon', dirent);
 };
 const getIcons = iconRequests => {
-  return invoke$n('IconTheme.getIcons', iconRequests);
+  return invoke$p('IconTheme.getIcons', iconRequests);
 };
 
 const setIconTheme = async iconThemeId => {
   try {
-    const extensions = await invoke$p('Extensions.getExtensions');
-    await invoke$n('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, platform);
+    const extensions = await invoke$r('Extensions.getExtensions');
+    await invoke$p('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, platform);
     await handleIconThemeChange$1();
   } catch (error) {
     if (isTest()) ; else {
@@ -4387,7 +4412,7 @@ const hydrate$4 = async () => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$s('InitData.getInitData');
+  const rendererProcessInitData = await invoke$u('InitData.getInitData');
   // TODO get the following items
   // - location.href
   // - workspace
@@ -4536,7 +4561,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$q(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  const languageConfiguration = await invoke$s(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
   if (languageConfiguration) {
     return languageConfiguration;
   }
@@ -4549,7 +4574,7 @@ const getLanguageConfiguration$2 = async languageId => {
 
 const getLanguages = async () => {
   try {
-    return invoke$p('Languages.getLanguages');
+    return invoke$r('Languages.getLanguages');
   } catch (error) {
     throw new VError(error, 'Failed to load languages');
   }
@@ -4693,7 +4718,7 @@ const hydrate$3 = async () => {
   const languages = await getLanguages();
   // TODO avoid side effect here, but how?
   // possible icon theme worker can ask for languages to be loaded, that way the dependency is reversed
-  await invoke$n('IconTheme.addLanguages', languages);
+  await invoke$p('IconTheme.addLanguages', languages);
   await addLanguages(languages);
   const useJsx = get$e('languages.jsFilesAsJsx');
   if (useJsx) {
@@ -5215,7 +5240,7 @@ const addToRecentlyOpenedWeb = async path => {
   await setRecentlyOpened(newRecentlyOpened);
 };
 const addToRecentlyOpenedRemote = async path => {
-  await invoke$q(RecentlyOpenedAddPath, path);
+  await invoke$s(RecentlyOpenedAddPath, path);
 };
 const addToRecentlyOpened = async path => {
   switch (platform) {
@@ -5253,16 +5278,16 @@ const hydrate$2 = async () => {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const saveValue$1 = async (storeId, value) => {
-  await invoke$p('IndexedDb.saveValue', storeId, value);
+  await invoke$r('IndexedDb.saveValue', storeId, value);
 };
 const getValuesByIndexName$1 = async (storeId, indexName, only) => {
-  return invoke$p('IndexedDb.getValuesByIndexName', storeId, indexName, only);
+  return invoke$r('IndexedDb.getValuesByIndexName', storeId, indexName, only);
 };
 const addHandle$1 = async (uri, handle) => {
-  return invoke$p('IndexedDb.addHandle', uri, handle);
+  return invoke$r('IndexedDb.addHandle', uri, handle);
 };
 const getHandle$1 = async uri => {
-  return invoke$p('IndexedDb.getHandle', uri);
+  return invoke$r('IndexedDb.getHandle', uri);
 };
 
 const saveValue = async (sessionId, value) => {
@@ -5539,7 +5564,7 @@ const map = {
   [References]: () => Promise.resolve().then(function () { return ViewletReferences_ipc; }),
   [RunAndDebug]: () => Promise.resolve().then(function () { return ViewletRunAndDebug_ipc; }),
   [ScreenCapture]: () => Promise.resolve().then(function () { return ViewletScreenCapture_ipc; }),
-  [Search$1]: () => Promise.resolve().then(function () { return ViewletSearch_ipc; }),
+  [Search]: () => Promise.resolve().then(function () { return ViewletSearch_ipc; }),
   [Settings$1]: () => Promise.resolve().then(function () { return ViewletSettings_ipc; }),
   [SideBar$2]: () => Promise.resolve().then(function () { return ViewletSideBar_ipc; }),
   [SimpleBrowser$1]: () => Promise.resolve().then(function () { return ViewletSimpleBrowser_ipc; }),
@@ -5655,7 +5680,7 @@ const watchFilesForHotReload = async platform => {
     if (config.length === 0) {
       return;
     }
-    await invoke$q('ExtensionHost.watchForHotReload', config);
+    await invoke$s('ExtensionHost.watchForHotReload', config);
   } catch (error) {
     console.warn(`Failed to watch ${error}`);
   }
@@ -5773,7 +5798,7 @@ const startup = async () => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$s('Viewlet.executeCommands', commands);
+  await invoke$u('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
@@ -5783,7 +5808,7 @@ const startup = async () => {
   await Promise.all(actions.map(action => action()));
   mark$1(Fifteen);
   if (isTest()) {
-    await executeCurrentTest(initData);
+    await executeCurrentTest(platform, initData);
     return;
   }
   mark(WillLoadSaveState);
@@ -5799,8 +5824,7 @@ const startup = async () => {
   mark(WillLoadLocation);
   await hydrate$a();
   mark(DidLoadLocation);
-  await hydrate$7();
-  await watchFilesForHotReload();
+  const watcherPromises = Promise.all([hydrate$7(), watchFilesForHotReload()]);
   measure(OpenWorkspace, WillOpenWorkspace, DidOpenWorkspace);
   measure(LoadMain, WillLoadMain, DidLoadMain);
   measure(LoadSideBar, WillLoadSideBar, DidLoadSideBar);
@@ -5811,6 +5835,16 @@ const startup = async () => {
   measure(LoadPreferences, WillLoadPreferences, DidLoadPreferences);
   measure(LoadColorTheme, WillLoadColorTheme, DidLoadColorTheme);
   measure(LoadIconTheme, WillLoadIconTheme, DidLoadIconTheme);
+  const autoUpdate = get$e('application.updateMode');
+  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$4('AutoUpdater.checkForUpdates', autoUpdate);
+    } catch {
+      // ignore
+    }
+  }
+  await watcherPromises;
 };
 
 const main = async () => {
@@ -5874,7 +5908,7 @@ const getPort = async ipcId => {
     ipcId
   });
   // TODO avoid side effect?
-  set$e(webContentsId);
+  set$d(webContentsId);
   return port2;
 };
 const create$X = async options => {
@@ -6310,7 +6344,7 @@ const IpcParentWithWebSocket = {
   wrap: wrap$2
 };
 
-const getModule$6 = () => {
+const getModule$5 = () => {
   switch (platform) {
     case Web$1:
     case Remote:
@@ -6322,7 +6356,7 @@ const getModule$6 = () => {
   }
 };
 const create$R = async options => {
-  const module = await getModule$6();
+  const module = await getModule$5();
   const rawIpc = await module.create(options);
   if (options.raw) {
     return rawIpc;
@@ -6436,10 +6470,10 @@ const GetColorThemeCssCachedLocalStorage = {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const set$8 = async (key, value) => {
-  await invoke$p('IndexedDb.set', key, value);
+  await invoke$r('IndexedDb.set', key, value);
 };
 const get$6 = async key => {
-  return invoke$p('IndexedDb.get', key);
+  return invoke$r('IndexedDb.get', key);
 };
 
 const getCacheKey = colorThemeId => {
@@ -6511,7 +6545,7 @@ const get$3 = () => {
 };
 
 const addWebExtension = async path => {
-  const manifest = await invoke$p('Extensions.addWebExtension', path);
+  const manifest = await invoke$r('Extensions.addWebExtension', path);
   // TODO avoid side effect here
   if (manifest.languages) {
     for (const language of manifest.languages) {
@@ -6625,7 +6659,7 @@ const handleRejectedExtensions = async extensions => {
   }
 };
 const getExtensions$1 = async () => {
-  return invoke$p('Extensions.getExtensions');
+  return invoke$r('Extensions.getExtensions');
 };
 const addNodeExtension = async path => {
   // TODO add support for dynamically loading node extensions
@@ -6667,13 +6701,13 @@ const state$j = {
 const actuallyActivateExtension = async (extension, event) => {
   if (!(extension.id in state$j.activatedExtensions)) {
     const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin, platform);
-    state$j.activatedExtensions[extension.id] = invoke$p(ExtensionActivate, extension, absolutePath, event);
+    state$j.activatedExtensions[extension.id] = invoke$r(ExtensionActivate, extension, absolutePath, event);
   }
   return state$j.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async event => {
   // TODO should not query extensions multiple times
-  const extensions = await invoke$p('Extensions.getExtensions');
+  const extensions = await invoke$r('Extensions.getExtensions');
   const {
     resolved,
     rejected
@@ -6719,7 +6753,7 @@ const executeProviders = async ({
   combineResults
 }) => {
   await activateByEvent(event);
-  const result = await invoke$p(method, ...params);
+  const result = await invoke$r(method, ...params);
   return result;
 };
 const executeProvider = async ({
@@ -6729,14 +6763,14 @@ const executeProvider = async ({
   noProviderFoundMessage
 }) => {
   await activateByEvent(event);
-  const result = invoke$p(method, ...params);
+  const result = invoke$r(method, ...params);
   return result;
 };
 const execute$2 = async ({
   method,
   params
 }) => {
-  await invoke$p(method, ...params);
+  await invoke$r(method, ...params);
 };
 
 const readFile$e = uri => {
@@ -6853,7 +6887,7 @@ const ExtensionHostFileSystem = {
 };
 
 const name$2r = 'App';
-const getModule$5 = uri => {
+const getModule$4 = uri => {
   switch (uri) {
     case 'startup-performance':
       return Promise.resolve().then(function () { return FileSystemAppStartupPerformance; });
@@ -6872,16 +6906,16 @@ const getModule$5 = uri => {
   }
 };
 const readFile$d = async uri => {
-  const module = await getModule$5(uri);
+  const module = await getModule$4(uri);
   return module.readFile();
 };
 const readJson$5 = async uri => {
-  const module = await getModule$5(uri);
+  const module = await getModule$4(uri);
   // @ts-ignore
   return module.readJson();
 };
 const writeFile$d = async (uri, content) => {
-  const module = await getModule$5(uri);
+  const module = await getModule$4(uri);
   return module.writeFile(content);
 };
 const readDirWithFileTypes$7 = () => {
@@ -6962,46 +6996,46 @@ const FileSystemData = {
 
 const name$2p = 'Memory';
 const readFile$b = uri => {
-  return invoke$p('FileSystemMemory.readFile', uri);
+  return invoke$r('FileSystemMemory.readFile', uri);
 };
 const exists$1 = uri => {
-  return invoke$p('FileSystemMemory.exists', uri);
+  return invoke$r('FileSystemMemory.exists', uri);
 };
 const writeFile$b = (uri, content) => {
-  return invoke$p('FileSystemMemory.writeFile', uri, content);
+  return invoke$r('FileSystemMemory.writeFile', uri, content);
 };
 const mkdir$4 = uri => {
-  return invoke$p('FileSystemMemory.mkdir', uri);
+  return invoke$r('FileSystemMemory.mkdir', uri);
 };
 const getPathSeparator$5 = () => {
   return Slash;
 };
 const remove$4 = uri => {
-  return invoke$p('FileSystemMemory.remove', uri);
+  return invoke$r('FileSystemMemory.remove', uri);
 };
 const readDirWithFileTypes$5 = uri => {
-  return invoke$p('FileSystemMemory.readDirWithFileTypes', uri);
+  return invoke$r('FileSystemMemory.readDirWithFileTypes', uri);
 };
 const getBlobUrl$2 = uri => {
-  return invoke$p('FileSystemMemory.getBlobUrl', uri);
+  return invoke$r('FileSystemMemory.getBlobUrl', uri);
 };
 const getBlob$5 = async uri => {
-  return invoke$p('FileSystemMemory.getBlob', uri);
+  return invoke$r('FileSystemMemory.getBlob', uri);
 };
 const chmod$3 = (path, permissions) => {
-  return invoke$p('FileSystemMemory.chmod', path, permissions);
+  return invoke$r('FileSystemMemory.chmod', path, permissions);
 };
 const rename$3 = (oldPath, newPath) => {
-  return invoke$p('FileSystemMemory.rename', oldPath, newPath);
+  return invoke$r('FileSystemMemory.rename', oldPath, newPath);
 };
 const copy$4 = (oldPath, newPath) => {
-  return invoke$p('FileSystemMemory.copy', oldPath, newPath);
+  return invoke$r('FileSystemMemory.copy', oldPath, newPath);
 };
 const stat$1 = uri => {
-  return invoke$p('FileSystemMemory.stat', uri);
+  return invoke$r('FileSystemMemory.stat', uri);
 };
 const getFiles$1 = () => {
-  return invoke$p('FileSystemMemory.getFiles');
+  return invoke$r('FileSystemMemory.getFiles');
 };
 
 const FileSystemMemory = {
@@ -7324,7 +7358,7 @@ const FileSystemWeb = {
 
 const fileSystemWorkerUrl = `${assetDir}/packages/file-system-worker/dist/fileSystemWorkerMain.js`;
 
-const getConfiguredWorkerUrl$i = () => {
+const getConfiguredWorkerUrl$k = () => {
   let configuredWorkerUrl = get$e('develop.fileSystemWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -7340,15 +7374,15 @@ const launchFileSystemWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$i()
+    url: getConfiguredWorkerUrl$k()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Initialize.initialize', platform);
+  await invoke$v(ipc, 'Initialize.initialize', platform);
   return ipc;
 };
 
 const {
-  invoke: invoke$m,
+  invoke: invoke$o,
   invokeAndTransfer: invokeAndTransfer$4} = getOrCreateWorker(launchFileSystemWorker);
 
 // TODO move all of this to an extension
@@ -7360,42 +7394,42 @@ const state$h = {
 };
 const readFile$9 = async uri => {
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
-    return invoke$m('FileSystem.readFile', `${location.protocol}//${uri}`);
+    return invoke$o('FileSystem.readFile', `${location.protocol}//${uri}`);
   }
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
-    return invoke$m('FileSystemFetch.readFile', uri);
+    return invoke$o('FileSystemFetch.readFile', uri);
   }
-  return invoke$p('FileSystemFetch.readFile', uri);
+  return invoke$r('FileSystemFetch.readFile', uri);
 };
 const readJson$4 = async uri => {
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
-    return invoke$m('FileSystem.readJson', `${location.protocol}//${uri}`);
+    return invoke$o('FileSystem.readJson', `${location.protocol}//${uri}`);
   }
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
-    return invoke$m('FileSystem.readJson', uri);
+    return invoke$o('FileSystem.readJson', uri);
   }
-  return invoke$p('FileSystemFetch.readJson', uri);
+  return invoke$r('FileSystemFetch.readJson', uri);
 };
 const writeFile$9 = (uri, content) => {
-  return invoke$p('FileSystemFetch.writeFile', uri);
+  return invoke$r('FileSystemFetch.writeFile', uri);
 };
 const mkdir$2 = uri => {
-  return invoke$p('FileSystemFetch.mkdir', uri);
+  return invoke$r('FileSystemFetch.mkdir', uri);
 };
 const getPathSeparator$3 = () => {
   return Slash;
 };
 const remove$2 = uri => {
-  return invoke$p('FileSystemFetch.remove', uri);
+  return invoke$r('FileSystemFetch.remove', uri);
 };
 const readDirWithFileTypes$3 = async uri => {
-  return invoke$p('FileSystemFetch.readDirWithFileTypes', uri);
+  return invoke$r('FileSystemFetch.readDirWithFileTypes', uri);
 };
 const chmod$2 = (path, permissions) => {
-  return invoke$p('FileSystemFetch.chmod', path, permissions);
+  return invoke$r('FileSystemFetch.chmod', path, permissions);
 };
 const getBlob$4 = async (uri, type) => {
-  return invoke$p('FileSystemFetch.getBlob', uri, type);
+  return invoke$r('FileSystemFetch.getBlob', uri, type);
 };
 
 const FileSystemFetch = {
@@ -7429,41 +7463,45 @@ const toUri = item => {
 const copy$3 = (source, target) => {
   source = toUri(source);
   target = toUri(target);
-  return invoke$m('FileSystem.copy', /* source */source, /* target */target);
+  return invoke$o('FileSystem.copy', /* source */source, /* target */target);
 };
 const readFile$8 = (path, encoding) => {
   path = toUri(path);
-  return invoke$m('FileSystem.readFile', /* path */path, /* encoding */encoding);
+  return invoke$o('FileSystem.readFile', /* path */path, /* encoding */encoding);
 };
 const exists = (path, encoding) => {
   path = toUri(path);
-  return invoke$m('FileSystem.exists', /* path */path);
+  return invoke$o('FileSystem.exists', /* path */path);
 };
 const readJson$3 = path => {
   path = toUri(path);
-  return invoke$m('FileSystem.readJson', /* path */path);
+  return invoke$o('FileSystem.readJson', /* path */path);
 };
 const remove$1 = path => {
   path = toUri(path);
-  return invoke$m('FileSystem.remove', /* path */path);
+  return invoke$o('FileSystem.remove', /* path */path);
 };
 const rename$1 = (oldUri, newUri) => {
   oldUri = toUri(oldUri);
   newUri = toUri(newUri);
-  return invoke$m('FileSystem.rename', /* oldPath */oldUri, /* newPath */newUri);
+  return invoke$o('FileSystem.rename', /* oldPath */oldUri, /* newPath */newUri);
 };
 const mkdir$1 = path => {
   path = toUri(path);
-  return invoke$m('FileSystem.mkdir', /* path */path);
+  return invoke$o('FileSystem.mkdir', /* path */path);
 };
 const writeFile$8 = async (path, content, encoding) => {
   path = toUri(path);
-  await invoke$m(/* FileSystem.writeFile */'FileSystem.writeFile', /* path */path, /* content */content, /* encoding */encoding);
+  await invoke$o(/* FileSystem.writeFile */'FileSystem.writeFile', /* path */path, /* content */content, /* encoding */encoding);
+};
+const writeBlob = async (path, blob) => {
+  path = toUri(path);
+  await invoke$o('FileSystem.writeBlob', path, blob);
 };
 const ensureFile = async () => {};
 const readDirWithFileTypes$2 = path => {
   path = toUri(path);
-  return invoke$m('FileSystem.readDirWithFileTypes', /* path */path);
+  return invoke$o('FileSystem.readDirWithFileTypes', /* path */path);
 };
 const getBlobUrl$1 = path => {
   if (!path.startsWith('/')) {
@@ -7472,7 +7510,7 @@ const getBlobUrl$1 = path => {
   return getRemoteSrc(path);
 };
 const getBlob$3 = async (path, type) => {
-  const content = await invoke$m('FileSystem.readFileAsBuffer', path);
+  const content = await invoke$o('FileSystem.readFileAsBuffer', path);
   const array = new Uint8Array(content.data);
   const blob = new Blob([array], {
     type
@@ -7483,22 +7521,22 @@ const getPathSeparator$2 = () => {
   if (platform === Web$1) {
     return Slash;
   }
-  return invoke$m('FileSystem.getPathSeparator');
+  return invoke$o('FileSystem.getPathSeparator');
 };
 const getRealPath = path => {
-  return invoke$m('FileSystem.getRealPath', /* path */path);
+  return invoke$o('FileSystem.getRealPath', /* path */path);
 };
 const stat = path => {
   path = toUri(path);
-  return invoke$m('FileSystem.stat', /* path */path);
+  return invoke$o('FileSystem.stat', /* path */path);
 };
 const getFolderSize = path => {
   path = toUri(path);
-  return invoke$m('FileSystem.getFolderSize', /* path */path);
+  return invoke$o('FileSystem.getFolderSize', /* path */path);
 };
 const chmod$1 = (path, permissions) => {
   path = toUri(path);
-  return invoke$m('FileSystem.chmod', /* path */path, /* permissions */permissions);
+  return invoke$o('FileSystem.chmod', /* path */path, /* permissions */permissions);
 };
 const canBeRestored$2 = true;
 
@@ -7522,6 +7560,7 @@ const FileSystemDisk = {
   remove: remove$1,
   rename: rename$1,
   stat,
+  writeBlob,
   writeFile: writeFile$8
 };
 
@@ -7638,7 +7677,7 @@ const requestPermission = async (handle, options) => {
   // query permission, but from renderer process
   // because handle.requestPermission is not implemented
   // in a worker, see https://github.com/WICG/file-system-access/issues/289
-  const permissionTypeNow = await invoke$s('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$u('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -7696,36 +7735,36 @@ const getHandle = async uri => {
   }
 };
 
-const pathSeparator$3 = '/';
+const pathSeparator$2 = '/';
 const getDirectoryHandle = async uri => {
   const handle = await getHandle(uri);
   if (handle) {
     return handle;
   }
-  const dirname$1 = dirname(pathSeparator$3, uri);
+  const dirname$1 = dirname(pathSeparator$2, uri);
   if (uri === dirname$1) {
     return undefined;
   }
   return getDirectoryHandle(dirname$1);
 };
 
-const pathSeparator$2 = '/';
+const pathSeparator$1 = '/';
 const getFileHandle = async uri => {
   const handle = await getHandle(uri);
   if (handle) {
     return handle;
   }
-  const dirname$1 = dirname(pathSeparator$2, uri);
+  const dirname$1 = dirname(pathSeparator$1, uri);
   const parentHandle = await getDirectoryHandle(dirname$1);
   if (!parentHandle) {
     return undefined;
   }
-  const baseName = getBaseName(pathSeparator$2, uri);
+  const baseName = getBaseName(pathSeparator$1, uri);
   const fileHandle = await getFileHandle$1(parentHandle, baseName);
   return fileHandle;
 };
 
-const pathSeparator$1 = '/';
+const pathSeparator = '/';
 const getDirent = handle => {
   const {
     name,
@@ -7827,7 +7866,7 @@ const writeFile$7 = async (uri, content) => {
   }
 };
 const getPathSeparator$1 = () => {
-  return pathSeparator$1;
+  return pathSeparator;
 };
 const getBlobSrc = async uri => {
   const handle = await getFileHandle(uri);
@@ -7864,7 +7903,7 @@ const FileSystemHtml = {
 
 const debugWorkerUrl = `${assetDir}/packages/debug-worker/dist/debugWorkerMain.js`;
 
-const getConfiguredWorkerUrl$h = () => {
+const getConfiguredWorkerUrl$j = () => {
   let configuredWorkerUrl = get$e('develop.debugWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -7880,21 +7919,21 @@ const launchDebugWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$h()
+    url: getConfiguredWorkerUrl$j()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Initialize.initialize');
+  await invoke$v(ipc, 'Initialize.initialize');
   return ipc;
 };
 
 const {
-  invoke: invoke$l,
+  invoke: invoke$n,
   restart: restart$9
 } = getOrCreateWorker(launchDebugWorker);
 
 const name$2l = 'Debug';
 const readFile$6 = uri => {
-  return invoke$l('RunAndDebug.readFile', uri);
+  return invoke$n('RunAndDebug.readFile', uri);
 };
 const writeFile$6 = (uri, content) => {
   throw new Error('not implemented');
@@ -7966,7 +8005,7 @@ const IsImportError = {
 
 const aboutViewWorkerUrl = `${assetDir}/packages/about-view-worker/dist/aboutWorkerMain.js`;
 
-const getConfiguredWorkerUrl$g = () => {
+const getConfiguredWorkerUrl$i = () => {
   let configuredWorkerUrl = get$e('develop.aboutViewWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -7982,18 +8021,18 @@ const launchAboutViewWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$g()
+    url: getConfiguredWorkerUrl$i()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$k
+  invoke: invoke$m
 } = getOrCreateWorker(launchAboutViewWorker);
 
 const showAboutElectron = async () => {
-  return invoke$k('About.showAboutElectron');
+  return invoke$m('About.showAboutElectron');
 };
 
 const showAboutDefault = async () => {
@@ -8103,7 +8142,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$s(/* Audio.play */3211, /* src */src);
+  await invoke$u(/* Audio.play */3211, /* src */src);
 };
 
 const name$2i = 'Audio';
@@ -8117,88 +8156,37 @@ const Audio_ipc = {
   name: name$2i
 };
 
-const AppImage = 'AppImage';
-const WindowsNsis = 'WindowsNsis';
-const Deb = 'Deb';
+const updateWorkerUrl = `${assetDir}/packages/update-worker/dist/updateWorkerMain.js`;
 
-const getModule$4 = type => {
-  switch (type) {
-    case AppImage:
-      return Promise.resolve().then(function () { return AutoUpdaterAppImage; });
-    case WindowsNsis:
-      return Promise.resolve().then(function () { return AutoUpdaterNsis; });
-    case Deb:
-      return Promise.resolve().then(function () { return AutoUpdaterDeb; });
-    default:
-      return undefined;
+const getConfiguredWorkerUrl$h = () => {
+  let configuredWorkerUrl = get$e('develop.updateWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
-};
-
-const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
-
-/**
- *
- * @param {string} key
- * @param {any} placeholders
- * @returns {string}
- */
-const i18nString = (key, placeholders = emptyObject) => {
-  if (placeholders === emptyObject) {
-    return key;
+  configuredWorkerUrl = configuredWorkerUrl || updateWorkerUrl;
+  {
+    configuredWorkerUrl = updateWorkerUrl;
   }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
-};
-
-/**
- * @enum {string}
- */
-const UiStrings$h = {
-  DoYouWantToUpdate: 'Do you want to update to version {PH1}?',
-  DoYouWantToRestart: 'The Update has been downloaded. Do you want to restart now?'
+  return configuredWorkerUrl;
 };
-const promptMessage = version => {
-  return i18nString(UiStrings$h.DoYouWantToUpdate, {
-    PH1: version
+const launchUpdateWorker = async () => {
+  const name = 'Update Worker';
+  const ipc = await create$10({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl$h()
   });
-};
-const promptRestart = () => {
-  return i18nString(UiStrings$h.DoYouWantToRestart);
+  handleIpc(ipc);
+  return ipc;
 };
 
-const getAutoUpdateType = () => {
-  return invoke$q('AutoUpdater.getAutoUpdateType');
-};
+const {
+  invoke: invoke$l
+} = getOrCreateWorker(launchUpdateWorker);
 
-const getLatestVersion = () => {
-  return invoke$q('AutoUpdater.getLatestVersion');
-};
-
-const checkForUpdates$1 = async () => {
-  const info = await getLatestVersion();
-  if (!info || !info.version) {
-    return;
-  }
-  const type = await getAutoUpdateType();
-  const message = promptMessage(info.version);
-  const shouldUpdate = await execute$4('ConfirmPrompt.prompt', message);
-  if (!shouldUpdate) {
-    return;
-  }
-  const module = await getModule$4(type);
-  if (!module) {
-    return;
-  }
-  const downloadPath = await module.downloadUpdate(info.version);
-  const messageRestart = promptRestart();
-  const shouldRestart = await execute$4('ConfirmPrompt.prompt', messageRestart);
-  if (!shouldRestart) {
-    return;
-  }
-  await module.installAndRestart(downloadPath);
+const checkForUpdates$1 = async updateSetting => {
+  const repository = 'lvce-editor/lvce-editor';
+  await invoke$l('Update.checkForUpdates', updateSetting, repository);
 };
 
 const name$2h = 'AutoUpdater';
@@ -8232,7 +8220,7 @@ const GetActiveEditor_ipc = {
 };
 
 const getSelectionText = () => {
-  return invoke$s('Css.getSelectionText');
+  return invoke$u('Css.getSelectionText');
 };
 
 const name$2f = 'Document';
@@ -8247,15 +8235,15 @@ const Document_ipc = {
 };
 
 const cache = Object.create(null);
-const id$m = 1;
+const id$l = 1;
 const get$2 = () => {
-  return cache[id$m];
+  return cache[id$l];
 };
 const has$1 = () => {
-  return id$m in cache;
+  return id$l in cache;
 };
 const set$5 = value => {
-  cache[id$m] = value;
+  cache[id$l] = value;
 };
 
 const getExtensions = () => {
@@ -8295,7 +8283,8 @@ const GetEditorSourceActions_ipc = {
 const name$2d = 'PlatformPaths';
 const Commands$29 = {
   getLogsDir: getLogsDir,
-  getTmpDir: getTmpDir$1
+  getTmpDir: getTmpDir,
+  getCachePath: getCachePath
 };
 
 const PlatformPaths_ipc = {
@@ -8305,14 +8294,14 @@ const PlatformPaths_ipc = {
 };
 
 const getFileHandles = ids => {
-  return invoke$s('FileHandles.get', ids);
+  return invoke$u('FileHandles.get', ids);
 };
 const addFileHandle = fileHandle => {
-  return invoke$s('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$u('FileSystemHandle.addFileHandle', fileHandle);
 };
 
 const getFilePathElectron = async file => {
-  return invoke$s('GetFilePathElectron.getFilePathElectron', file);
+  return invoke$u('GetFilePathElectron.getFilePathElectron', file);
 };
 
 const name$2c = 'FileSystemHandle';
@@ -8506,10 +8495,10 @@ const applyLegacyBulkReplacement = async (files, ranges, replacement) => {
   array(ranges);
   string(replacement);
   if (isSpecialScheme(files)) {
-    await invoke$p('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+    await invoke$r('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
     return;
   }
-  await invoke$q('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$s('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const applyFileReplacement = async edit => {
@@ -8745,7 +8734,7 @@ const Chrome_ipc = {
 
 const clipBoardWorkerUrl = `${assetDir}/packages/clipboard-worker/dist/clipBoardWorkerMain.js`;
 
-const getConfiguredWorkerUrl$f = () => {
+const getConfiguredWorkerUrl$g = () => {
   let configuredWorkerUrl = get$e('develop.clipBoardWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -8761,50 +8750,50 @@ const launchClipBoardWorker = async () => {
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$f()
+    url: getConfiguredWorkerUrl$g()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'ClipBoard.initialize', platform);
+  await invoke$v(ipc, 'ClipBoard.initialize', platform);
   return ipc;
 };
 
 const {
-  invoke: invoke$j} = getOrCreateWorker(launchClipBoardWorker);
+  invoke: invoke$k} = getOrCreateWorker(launchClipBoardWorker);
 
 const readText = async () => {
-  return await invoke$j('ClipBoard.readText');
+  return await invoke$k('ClipBoard.readText');
 };
 const writeText$1 = async text => {
-  return await invoke$j('ClipBoard.writeText', text);
+  return await invoke$k('ClipBoard.writeText', text);
 };
 const enableMemoryClipBoard = async () => {
-  return await invoke$j('ClipBoard.enableMemoryClipBoard');
+  return await invoke$k('ClipBoard.enableMemoryClipBoard');
 };
 const readMemoryText = async () => {
-  return await invoke$j('ClipBoard.readMemoryText');
+  return await invoke$k('ClipBoard.readMemoryText');
 };
 const disableMemoryClipBoard = async () => {
-  return await invoke$j('ClipBoard.disableMemoryClipBoard');
+  return await invoke$k('ClipBoard.disableMemoryClipBoard');
 };
 const hotReload$b = async () => {
-  return await invoke$j('ClipBoard.hotReload');
+  return await invoke$k('ClipBoard.hotReload');
 };
 const writeNativeFiles = async (type, files) => {
-  return await invoke$j('ClipBoard.writeNativeFiles', type, files);
+  return await invoke$k('ClipBoard.writeNativeFiles', type, files);
 };
 const readNativeFiles = async () => {
-  return await invoke$j('ClipBoard.readNativeFiles');
+  return await invoke$k('ClipBoard.readNativeFiles');
 };
 const writeImage = async blob => {
   try {
-    return await invoke$s('ClipBoard.writeImage', blob);
+    return await invoke$u('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$s('ClipBoard.execCopy');
+    return await invoke$u('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
@@ -8831,7 +8820,7 @@ const ClipBoard_ipc = {
 };
 
 const getColorThemeNames = async () => {
-  return invoke$p('ColorTheme.getColorThemeNames');
+  return invoke$r('ColorTheme.getColorThemeNames');
 };
 
 const name$25 = 'ColorTheme';
@@ -8854,7 +8843,7 @@ const getProductNameLong = () => {
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$q('ElectronDialog.showOpenDialog', title, properties);
+  return invoke$s('ElectronDialog.showOpenDialog', title, properties);
 };
 const showMessageBox = async options => {
   // TODO maybe request window id here instead of at caller
@@ -8866,7 +8855,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$q('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$s('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Question = 'question';
@@ -8883,10 +8872,29 @@ const prompt$3 = async (message, confirmMessage, title, cancelMessage) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$s('ConfirmPrompt.prompt', message);
+  const result = await invoke$u('ConfirmPrompt.prompt', message);
   return result;
 };
 
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+
+/**
+ *
+ * @param {string} key
+ * @param {any} placeholders
+ * @returns {string}
+ */
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
 /**
  * @enum {string}
  */
@@ -8903,11 +8911,12 @@ const ok = () => {
 
 let _mockId$1 = 0;
 const showMockConfirmPrompt = async (message, options) => {
-  const ipc = get$c();
-  const result = await invoke$t(ipc, 'Test.executeMock', _mockId$1, message, options);
+  const ipc = get$d();
+  const result = await invoke$v(ipc, 'Test.executeMock', _mockId$1, message, options);
   return result;
 };
 const prompt$1 = async (message, {
+  platform: platform$1 = platform,
   confirmMessage = ok(),
   title = '',
   cancelMessage = cancel()
@@ -8922,7 +8931,7 @@ const prompt$1 = async (message, {
   // TODO always ask shared process for prompts
   // when running in electron it uses native prompts
   // when running in node or web it uses browser prompts
-  if (platform === Electron$1) {
+  if (platform$1 === Electron$1) {
     return prompt$3(message, confirmMessage, title, cancelMessage);
   }
   return prompt$2(message);
@@ -8944,21 +8953,21 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = options => {
-  return invoke$q('ElectronContentTracing.startRecording', options);
+  return invoke$s('ElectronContentTracing.startRecording', options);
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$q('ElectronContentTracing.stopRecording');
+  return invoke$s('ElectronContentTracing.stopRecording');
 };
 
 const showItemInFolder = fullPath => {
-  return invoke$q('OpenExternal.showItemInFolder', fullPath);
+  return invoke$s('OpenExternal.showItemInFolder', fullPath);
 };
 const openExternal$2 = url => {
-  return invoke$q('OpenExternal.openExternal', url);
+  return invoke$s('OpenExternal.openExternal', url);
 };
 
 const openNativeFolderWeb = absolutePath => {
@@ -8966,7 +8975,7 @@ const openNativeFolderWeb = absolutePath => {
 };
 const openNativeFolderRemote = async absolutePath => {
   try {
-    await invoke$q(OpenNativeFolder, /* path */absolutePath);
+    await invoke$s(OpenNativeFolder, /* path */absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`);
   }
@@ -9089,26 +9098,26 @@ const Debug_ipc = {
 
 const attachDebugger = async pid => {
   number(pid);
-  await invoke$q('AttachDebugger.attachDebugger', pid);
+  await invoke$s('AttachDebugger.attachDebugger', pid);
 };
 
 const getPid = () => {
-  return invoke$q('Process.getPid');
+  return invoke$s('Process.getPid');
 };
 const getElectronVersion = () => {
-  return invoke$q('ElectronProcess.getElectronVersion');
+  return invoke$s('ElectronProcess.getElectronVersion');
 };
 const getNodeVersion = () => {
-  return invoke$q('Process.getNodeVersion');
+  return invoke$s('Process.getNodeVersion');
 };
 const getChromeVersion = () => {
-  return invoke$q('ElectronProcess.getChromeVersion');
+  return invoke$s('ElectronProcess.getChromeVersion');
 };
 const getV8Version = () => {
-  return invoke$q('Process.getV8Version');
+  return invoke$s('Process.getV8Version');
 };
 const getArch = () => {
-  return invoke$q('Process.getArch');
+  return invoke$s('Process.getArch');
 };
 
 const debugSharedProcess = async () => {
@@ -9128,10 +9137,10 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$q('Crash.crashSharedProcess');
+  return invoke$s('Crash.crashSharedProcess');
 };
 const crashMainProcess = () => {
-  return invoke$q('Crash.crashMainProcess');
+  return invoke$s('Crash.crashMainProcess');
 };
 
 const toggleDeveloperTools$1 = () => {
@@ -9147,7 +9156,7 @@ const openCacheFolder = async () => {
   await openNativeFolder(cacheFolder);
 };
 const openDataFolder = async () => {
-  const dataFolder = await invoke$q(/* Platform.getDataDir */'Platform.getDataDir');
+  const dataFolder = await invoke$s(/* Platform.getDataDir */'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 const openLogsFolder = async () => {
@@ -9156,11 +9165,12 @@ const openLogsFolder = async () => {
     return;
   }
   const logsFolder = await getLogsDir();
+  await invoke$s('FileSystem.mkdir', /* path */logsFolder);
   await openNativeFolder(logsFolder);
 };
 
 const getPerformanceEntries = () => {
-  return invoke$q('ElectronDeveloper.getPerformanceEntries');
+  return invoke$s('ElectronDeveloper.getPerformanceEntries');
 };
 
 const toMarkdownTable = (header, rows) => {
@@ -9401,7 +9411,7 @@ const getNodeTiming = () => {
   if (platform === Web$1) {
     return undefined;
   }
-  return invoke$q(/* command */'Performance.getNodeStartupTiming');
+  return invoke$s(/* command */'Performance.getNodeStartupTiming');
 };
 const getMeasureEntries = () => {
   const measureEntries = getEntriesByType(Measure);
@@ -9490,13 +9500,13 @@ const formatRendererProcessData = ({
   return toMarkdownTable(header, rows);
 };
 const getSharedProcessMemoryUsage = () => {
-  return invoke$q(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
+  return invoke$s(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$s('Performance.getMemory');
+  return invoke$u('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$s('Performance.measureUserAgentSpecificMemory');
+  return invoke$u('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -9545,13 +9555,13 @@ const showMemoryUsage = async () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$q(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
+  return invoke$s(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
 };
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$q(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
+  await invoke$s(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
 };
 const createSharedProcessProfile = async () => {
-  await invoke$q(/* Developer.createProfile */'Developer.createProfile');
+  await invoke$s(/* Developer.createProfile */'Developer.createProfile');
 };
 const reloadIconTheme = async () => {
   await hydrate$4();
@@ -9739,12 +9749,12 @@ const revokeObjectUrl = url => {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$s(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$u(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$q(DownloadDownload, /* url */url, /* outFile */outFile);
+  await invoke$s(DownloadDownload, /* url */url, /* outFile */outFile);
 };
 const downloadJson = async (json, fileName) => {
   let url = '';
@@ -9762,11 +9772,6 @@ const downloadJson = async (json, fileName) => {
     revokeObjectUrl(url);
   }
 };
-const downloadUrl = (url, outFile) => {
-  string(url);
-  string(outFile);
-  return invoke$q('Download.download', url, outFile);
-};
 
 const name$1Z = 'Download';
 const Commands$1V = {
@@ -9843,7 +9848,7 @@ const show$9 = async (editor, message, rowIndex, columnIndex) => {
   const x$1 = x(editor, rowIndex, columnIndex);
   // @ts-ignore
   const y$1 = y(editor, rowIndex);
-  await invoke$s(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$u(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$1T = {
@@ -9965,7 +9970,6 @@ const Terminal = 14;
 const TitleBar$1 = 15;
 const View$1 = 16;
 const ActivityBarAdditionalViews = 17;
-const Search = 18;
 const SimpleBrowser = 21;
 const SourceControl = 22;
 const Problems = 23;
@@ -9974,8 +9978,8 @@ const ProblemsFilter = 25;
 const KeyBindingsTable = 26;
 const E2eTests = 27;
 
-const id$l = Edit;
-const getMenuEntries$q = () => {
+const id$k = Edit;
+const getMenuEntries$p = () => {
   return [{
     id: 'undo',
     label: undo(),
@@ -10016,8 +10020,8 @@ const getMenuEntries$q = () => {
 
 const MenuEntriesEdit = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$q,
-  id: id$l
+  getMenuEntries: getMenuEntries$p,
+  id: id$k
 };
 
 /**
@@ -10058,8 +10062,8 @@ const exit$1 = () => {
   return i18nString(UiStrings$e.Exit);
 };
 
-const id$k = File;
-const getMenuEntries$p = () => {
+const id$j = File;
+const getMenuEntries$o = () => {
   const entries = [{
     id: 'newFile',
     label: newFile(),
@@ -10109,19 +10113,19 @@ const getMenuEntries$p = () => {
 
 const MenuEntriesFile = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$p,
-  id: id$k
+  getMenuEntries: getMenuEntries$o,
+  id: id$j
 };
 
-const id$j = Go;
-const getMenuEntries$o = () => {
+const id$i = Go;
+const getMenuEntries$n = () => {
   return [];
 };
 
 const MenuEntriesGo = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$o,
-  id: id$j
+  getMenuEntries: getMenuEntries$n,
+  id: id$i
 };
 
 /**
@@ -10166,11 +10170,11 @@ const isAutoUpdateSupported = () => {
   if (platform !== Electron$1) {
     return false;
   }
-  return invoke$q('IsAutoUpdateSupported.isAutoUpdateSupported');
+  return invoke$s('IsAutoUpdateSupported.isAutoUpdateSupported');
 };
 
-const id$i = Help$1;
-const getMenuEntries$n = async () => {
+const id$h = Help$1;
+const getMenuEntries$m = async () => {
   const autoUpdateSupported = await isAutoUpdateSupported();
   const entries = [];
   if (platform !== Web$1) {
@@ -10208,23 +10212,23 @@ const getMenuEntries$n = async () => {
 
 const MenuEntriesHelp = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$n,
-  id: id$i
+  getMenuEntries: getMenuEntries$m,
+  id: id$h
 };
 
-const id$h = Run;
-const getMenuEntries$m = () => {
+const id$g = Run;
+const getMenuEntries$l = () => {
   return [];
 };
 
 const MenuEntriesRun = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$m,
-  id: id$h
+  getMenuEntries: getMenuEntries$l,
+  id: id$g
 };
 
-const id$g = Selection;
-const getMenuEntries$l = () => {
+const id$f = Selection;
+const getMenuEntries$k = () => {
   return [{
     id: 'selectAll',
     label: selectAll(),
@@ -10255,8 +10259,8 @@ const getMenuEntries$l = () => {
 
 const MenuEntriesSelection = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$l,
-  id: id$g
+  getMenuEntries: getMenuEntries$k,
+  id: id$f
 };
 
 /**
@@ -10277,8 +10281,8 @@ const newTerminal = () => {
   return i18nString(UiStrings$c.NewTerminal);
 };
 
-const id$f = Terminal;
-const getMenuEntries$k = () => {
+const id$e = Terminal;
+const getMenuEntries$j = () => {
   return [{
     id: 'newTerminal',
     label: newTerminal(),
@@ -10290,8 +10294,8 @@ const getMenuEntries$k = () => {
 
 const MenuEntriesTerminal = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$k,
-  id: id$f
+  getMenuEntries: getMenuEntries$j,
+  id: id$e
 };
 
 const getModule$1 = () => {
@@ -10302,27 +10306,27 @@ const getModule$1 = () => {
       return Promise.resolve().then(function () { return MenuEntriesTitleBarRemote; });
   }
 };
-const id$e = TitleBar$1;
-const getMenuEntries$j = async () => {
+const id$d = TitleBar$1;
+const getMenuEntries$i = async () => {
   const module = await getModule$1();
   return module.getMenuEntries();
 };
 
 const MenuEntriesTitleBar = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$j,
-  id: id$e
+  getMenuEntries: getMenuEntries$i,
+  id: id$d
 };
 
-const id$d = View$1;
-const getMenuEntries$i = () => {
+const id$c = View$1;
+const getMenuEntries$h = () => {
   return [];
 };
 
 const MenuEntriesView = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$i,
-  id: id$d
+  getMenuEntries: getMenuEntries$h,
+  id: id$c
 };
 
 // based on https://www.electronjs.org/docs/latest/api/menu-item#new-menuitemoptions
@@ -10478,7 +10482,7 @@ const state$f = {
 };
 const setItems = async items => {
   const windowId = await getWindowId();
-  return invoke$q('ElectronApplicationMenu.setItems', windowId, items);
+  return invoke$s('ElectronApplicationMenu.setItems', windowId, items);
 };
 const getEntryMap = async modules => {
   const map = Object.create(null);
@@ -10541,7 +10545,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$q('ElectronClipBoard.writeText', text);
+  return invoke$s('ElectronClipBoard.writeText', text);
 };
 
 const name$1V = 'ElectronClipBoard';
@@ -10600,7 +10604,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$q('Exit.exit');
+  return invoke$s('Exit.exit');
 };
 
 const name$1R = 'Exit';
@@ -10641,13 +10645,13 @@ const executeCommand = (id, ...args) => {
   });
 };
 const searchFileWithFetch = (...args) => {
-  return invoke$p('SearchFileWithFetch.searchFileWithFetch', ...args);
+  return invoke$r('SearchFileWithFetch.searchFileWithFetch', ...args);
 };
 const searchFileWithHtml = (...args) => {
-  return invoke$p('SearchFileWithHtml.searchFileWithHtml', ...args);
+  return invoke$r('SearchFileWithHtml.searchFileWithHtml', ...args);
 };
 const searchFileWithMemory = (...args) => {
-  return invoke$p('SearchFileWithMemory.searchFileWithMemory', ...args);
+  return invoke$r('SearchFileWithMemory.searchFileWithMemory', ...args);
 };
 
 const state$e = {
@@ -10740,7 +10744,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$s('FilePicker.showDirectoryPicker', options);
+    return await invoke$u('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10751,11 +10755,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$s('FilePicker.showFilePicker', options);
+  return invoke$u('FilePicker.showFilePicker', options);
 };
 const doShowSaveFilePicker = async options => {
   try {
-    return await invoke$s('FilePicker.showSaveFilePicker', options);
+    return await invoke$u('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10767,8 +10771,8 @@ const doShowSaveFilePicker = async options => {
 };
 let _mockId = 0;
 const doShowMockSaveFilePicker = async () => {
-  const ipc = get$c();
-  const result = await invoke$t(ipc, 'Test.executeMock', _mockId);
+  const ipc = get$d();
+  const result = await invoke$v(ipc, 'Test.executeMock', _mockId);
   return result;
 };
 const showSaveFilePicker = async options => {
@@ -10811,7 +10815,8 @@ const Commands$1H = {
   remove: remove$a,
   rename: rename$7,
   stat: stat$2,
-  writeFile: writeFile$f
+  writeFile: writeFile$f,
+  writeBlob: writeBlob$1
 };
 
 const FileSystem_ipc = {
@@ -10858,15 +10863,15 @@ const show$8 = async (uri, top, left) => {
     if (version !== state$d.versionId) {
       return;
     }
-    await invoke$s(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$u(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$s(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$u(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
   }
 };
 const hide$4 = async () => {
   ++state$d.versionId;
-  await invoke$s(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$u(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -11002,7 +11007,7 @@ const getCompletionWorkerUrl = () => {
 
 const extensionHostSubWorkerUrl = `${assetDir}/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js`;
 
-const getConfiguredWorkerUrl$e = () => {
+const getConfiguredWorkerUrl$f = () => {
   let configuredWorkerUrl = get$e('develop.extensionHostSubWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -11014,7 +11019,7 @@ const getConfiguredWorkerUrl$e = () => {
   return configuredWorkerUrl;
 };
 const getExtensionHostSubWorkerUrl = () => {
-  return getConfiguredWorkerUrl$e();
+  return getConfiguredWorkerUrl$f();
 };
 
 const findWidgetWorkerUrl = `${assetDir}/packages/find-widget-worker/dist/findWidgetWorkerMain.js`;
@@ -11203,41 +11208,6 @@ const LocalStorage_ipc = {
   name: name$1D
 };
 
-const executeMenuItemCommand = async item => {
-  if (!item.command) {
-    warn('item has missing command', item);
-    return;
-  }
-  const args = item.args || [];
-  await execute$4(item.command, ...args);
-};
-
-const matchesArgs = (a, b) => {
-  if (!a && !b) {
-    return true;
-  }
-  if (!a && b || !b && a) {
-    return false;
-  }
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-const getCommandKeyBinding = (keyBindings, command, args) => {
-  for (const keyBinding of keyBindings) {
-    if (keyBinding.command === command && matchesArgs(keyBinding.args, args)) {
-      return keyBinding;
-    }
-  }
-  return undefined;
-};
-
 const load$1 = id => {
   switch (id) {
     case TitleBar$1:
@@ -11260,7 +11230,7 @@ const getModule = id => {
   }
   return load$1(id);
 };
-const getMenuEntries$h = async (id, ...args) => {
+const getMenuEntries$g = async (id, ...args) => {
   try {
     const module = await getModule(id);
     // @ts-ignore
@@ -11281,6 +11251,41 @@ const getMenuEntries2 = async (uid, menuId, ...args) => {
   }
 };
 
+const executeMenuItemCommand = async item => {
+  if (!item.command) {
+    warn('item has missing command', item);
+    return;
+  }
+  const args = item.args || [];
+  await execute$4(item.command, ...args);
+};
+
+const matchesArgs = (a, b) => {
+  if (!a && !b) {
+    return true;
+  }
+  if (!a && b || !b && a) {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const getCommandKeyBinding = (keyBindings, command, args) => {
+  for (const keyBinding of keyBindings) {
+    if (keyBinding.command === command && matchesArgs(keyBinding.args, args)) {
+      return keyBinding;
+    }
+  }
+  return undefined;
+};
+
 const addKeyBindings = menuEntries => {
   const keyBindings = state$u.matchingKeyBindings;
   const newMenuEntries = [];
@@ -11296,7 +11301,7 @@ const addKeyBindings = menuEntries => {
   return newMenuEntries;
 };
 const getMenuEntriesWithKeyBindings = async (id, ...args) => {
-  const menuEntries = await getMenuEntries$h(id, ...args);
+  const menuEntries = await getMenuEntries$g(id, ...args);
   const newMenuEntries = addKeyBindings(menuEntries);
   return newMenuEntries;
 };
@@ -11897,6 +11902,34 @@ const getVisible = (items, focusedIndex, expanded, level) => {
   return visibleItems;
 };
 
+const menuWorkerUrl = `${assetDir}/packages/menu-worker/dist/menuWorkerMain.js`;
+
+const getConfiguredWorkerUrl$e = () => {
+  let configuredWorkerUrl = get$e('develop.menuWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || menuWorkerUrl;
+  {
+    configuredWorkerUrl = menuWorkerUrl;
+  }
+  return configuredWorkerUrl;
+};
+const launchMenuWorker = async () => {
+  const name = 'Menu Worker';
+  const ipc = await create$10({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl$e()
+  });
+  handleIpc(ipc);
+  return ipc;
+};
+
+const {
+  invoke: invoke$j
+} = getOrCreateWorker(launchMenuWorker);
+
 const state$a = {
   /**
    * @type {any[]}
@@ -11938,64 +11971,30 @@ const addMenuInternal = menu => {
   state$a.menus.push(menu);
   return menu;
 };
-const getMenuBounds = (x, y, items) => {
-  const menuWidth = CONTEXT_MENU_WIDTH;
-  const menuHeight = getMenuHeight(items);
-  const layoutState = getState$1(Layout);
-  const windowWidth = layoutState.points[0];
-  const windowHeight = layoutState.points[1];
-  // TODO maybe only send labels and keybindings to ui (id not needed on ui)
-  // TODO what about separators?
-
-  if (x + menuWidth > windowWidth) {
-    x -= menuWidth;
-  }
-  if (y + menuHeight > windowHeight) {
-    y -= menuHeight;
-  }
-  return {
-    x,
-    y,
-    width: menuWidth,
-    height: menuHeight
-  };
-};
-const show$7 = async (x, y, id, mouseBlocking = false, ...args) => {
-  const items = await getMenuEntriesWithKeyBindings(id, ...args);
-  const bounds = getMenuBounds(x, y, items);
-  const menu = addMenuInternal({
-    id,
-    items,
-    focusedIndex: -1,
-    level: state$a.menus.length,
-    x: bounds.x,
-    y: bounds.y
-  });
-  const visible = getVisible(menu.items, -1, false, menu.level);
-  const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke$s(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
+const show$7 = async (x, y, menuId, mouseBlocking = false, ...args) => {
+  const items = await getMenuEntriesWithKeyBindings(menuId, ...args);
+  const {
+    commands,
+    menu
+  } = await invoke$j('Menu.getShowCommands', items, menuId, x, y, mouseBlocking);
+  addMenuInternal(menu);
+  await invoke$u(...commands);
 };
 const show2$1 = async (uid, menuId, x, y, mouseBlocking = false, ...args) => {
   const items = await getMenuEntriesWithKeyBindings2(uid, menuId, ...args);
-  const bounds = getMenuBounds(x, y, items);
-  const menu = addMenuInternal({
-    id: menuId,
-    items,
-    focusedIndex: -1,
-    level: state$a.menus.length,
-    x: bounds.x,
-    y: bounds.y
-  });
-  const visible = getVisible(menu.items, -1, false, menu.level);
-  const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke$s(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
+  const {
+    commands,
+    menu
+  } = await invoke$j('Menu.getShowCommands', items, menuId, x, y, mouseBlocking);
+  addMenuInternal(menu);
+  await invoke$u(...commands);
 };
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
   state$a.menus = state$a.menus.slice(0, level + 1);
   const parentMenu = state$a.menus[level];
   const item = parentMenu.items[index];
-  const subMenuItems = await getMenuEntries$h(item.id);
+  const subMenuItems = await getMenuEntries$g(item.id);
   const subMenu = addMenuInternal({
     id: item.id,
     items: subMenuItems,
@@ -12010,15 +12009,15 @@ const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   const height = getMenuHeight(subMenuItems);
   const visible = getVisible(subMenu.items, -1, false, subMenu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  invoke$s(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
+  invoke$u(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
 };
 const showSubMenu = async (level, index) => {
   await showSubMenuAtEnter(level, index, -1, -1);
 };
-const selectIndexNone = async (menu, item, index) => {
+const selectIndexNone = async (menu, item) => {
   await Promise.all([hide$3(/* restoreFocus */false), executeMenuItemCommand(item)]);
 };
-const selectIndexRestoreFocus = async (menu, item, index) => {
+const selectIndexRestoreFocus = async (menu, item) => {
   await Promise.all([hide$3(/* restoreFocus */true), executeMenuItemCommand(item)]);
 };
 const selectIndexSubMenu = async (menu, item, index) => {
@@ -12027,8 +12026,8 @@ const selectIndexSubMenu = async (menu, item, index) => {
   }
   await showSubMenu(menu.level, menu.focusedIndex);
 };
-const selectIndexDefault = async (menu, item, index) => {};
-const selectIndexIgnore = async (menu, item, index) => {
+const selectIndexDefault = async () => {};
+const selectIndexIgnore = async (menu, item) => {
   await executeMenuItemCommand(item);
 };
 const getSelectIndexFunction = flags => {
@@ -12066,11 +12065,14 @@ const selectItem = text => {
   throw new Error(`menu item not found: ${text}`);
 };
 const hide$3 = async (restoreFocus = true) => {
-  if (state$a.menus.length === 0) {
-    return;
+  const {
+    commands,
+    newMenus
+  } = await invoke$j('Menu.getHideCommands', restoreFocus);
+  state$a.menus = newMenus;
+  if (commands.length > 0) {
+    await invoke$u(...commands);
   }
-  state$a.menus = [];
-  await invoke$s(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
 };
 
 // TODO difference between focusing with mouse or keyboard
@@ -12080,7 +12082,7 @@ const hide$3 = async (restoreFocus = true) => {
 const hideSubMenus = async level => {
   if (level < state$a.menus.length) {
     state$a.menus = state$a.menus.slice(0, level + 1);
-    await invoke$s(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
+    await invoke$u(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
   }
 };
 const MENU_DELAY_TRIANGLE = 300;
@@ -12125,7 +12127,7 @@ const handleMouseLeave = async () => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = -1;
-  await invoke$s(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
+  await invoke$u(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
 };
 const focusIndex$3 = async (menu, index) => {
   if (menu.items.length === 0) {
@@ -12133,7 +12135,7 @@ const focusIndex$3 = async (menu, index) => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = index;
-  await invoke$s(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
+  await invoke$u(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
 };
 const getIndexToFocusNextStartingAt = (items, startIndex) => {
   for (let i = startIndex; i < startIndex + items.length; i++) {
@@ -12225,7 +12227,9 @@ const Commands$1w = {
   hide: hide$3,
   selectIndex: selectIndex$2,
   selectItem: selectItem,
-  show: show$7
+  show: show$7,
+  getMenuEntries: getMenuEntries$g,
+  getMenuEntries2
 };
 
 const Menu_ipc = {
@@ -12361,22 +12365,22 @@ const state$9 = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$s(/* ActivityBar.focus */717115);
+  await invoke$u(/* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$s(/* StatusBar.focus */8882);
+  await invoke$u(/* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$s(/* Panel.focus */6664);
+  await invoke$u(/* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$s(/* SideBar.focus */5554);
+  await invoke$u(/* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$s(/* TitleBar.focus */1331);
+  await invoke$u(/* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$s(/* Main.focus */2145);
+  await invoke$u(/* Main.focus */2145);
 };
 const focusPart = part => {
   state$9.focusedPart = part;
@@ -12487,7 +12491,7 @@ const create$P = async (type, text) => {
     type,
     text
   });
-  await invoke$s(/* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$u(/* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -12496,7 +12500,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$s(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$u(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$2 = index => {
   console.log('handle click');
@@ -12512,7 +12516,7 @@ const handleClick$2 = index => {
   });
 };
 const dispose$q = async id => {
-  await invoke$s(/* Notification.dispose */'Notification.dispose', /* id */id);
+  await invoke$u(/* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$1y = 'Notification';
@@ -12531,7 +12535,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async url => {
   try {
-    await invoke$s(/* Open.openUrl */'Open.openUrl', /* url */url);
+    await invoke$u(/* Open.openUrl */'Open.openUrl', /* url */url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -12608,7 +12612,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$s('Prompt.prompt', message, defaultValue);
+  return invoke$u('Prompt.prompt', message, defaultValue);
 };
 
 const name$1t = 'Prompt';
@@ -12623,7 +12627,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$q('RebuildNodePty.rebuildNodePty');
+  await invoke$s('RebuildNodePty.rebuildNodePty');
 };
 
 const name$1s = 'RebuildNodePty';
@@ -12759,19 +12763,19 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$s('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$u('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$s('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$u('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$s('TestFrameWork.showOverlay', ...args);
+  return invoke$u('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$s('TestFrameWork.performAction', ...args);
+  return invoke$u('TestFrameWork.performAction', ...args);
 };
 const checkConditionError = (...args) => {
-  return invoke$s('TestFrameWork.checkConditionError', ...args);
+  return invoke$u('TestFrameWork.checkConditionError', ...args);
 };
 
 const name$1k = 'TestFrameWork';
@@ -12866,10 +12870,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$s('PointerCapture.mock');
+  return invoke$u('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$s('PointerCapture.unmock');
+  return invoke$u('PointerCapture.unmock');
 };
 
 const name$1e = 'PointerCapture';
@@ -12972,7 +12976,7 @@ const set$4 = async (url, contentSecurityPolicy) => {
   if (platform === Web$1) {
     return;
   }
-  await invoke$q('ContentSecurityPolicy.set', url, contentSecurityPolicy);
+  await invoke$s('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
 const set$3 = async (url, contentSecurityPolicy) => {
@@ -13022,7 +13026,7 @@ const {
 const create$O = async canvasId => {
   number(canvasId);
   const id = create$$();
-  await invoke$s('OffscreenCanvas.create', canvasId, id);
+  await invoke$u('OffscreenCanvas.create', canvasId, id);
   const canvas = acquire(id);
   return canvas;
 };
@@ -13079,7 +13083,8 @@ const Languages_ipc = {
 
 const name$14 = 'FileWatcher';
 const Commands$_ = {
-  handleEvent: handleEvent
+  handleEvent: handleEvent,
+  watchFile: watchFile
 };
 
 const FileWatcher_ipc = {
@@ -13351,7 +13356,7 @@ const ExtensionHostHover_ipc = {
 const editorWorkerUrl = `${assetDir}/packages/editor-worker/dist/editorWorkerMain.js`;
 
 const launchEditorWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$l('developer.editorWorkerPath', editorWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$n('developer.editorWorkerPath', editorWorkerUrl);
   const id = create$$();
   let ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
@@ -13368,7 +13373,7 @@ const launchEditorWorker = async () => {
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
-  await invoke$t(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  await invoke$v(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
@@ -13546,7 +13551,7 @@ const Transferrable_ipc = {
 };
 
 const getWebViewsNode = async () => {
-  const webViews = await invoke$q('ExtensionHost.getWebViews');
+  const webViews = await invoke$s('ExtensionHost.getWebViews');
   return webViews;
 };
 
@@ -13586,13 +13591,13 @@ const setPort = async (uid, port, origin, portType) => {
  * @deprecated
  */
 const getWebViewInfo = providerId => {
-  return invoke$p('ExtensionHostWebView.getWebViewInfo', providerId);
+  return invoke$r('ExtensionHostWebView.getWebViewInfo', providerId);
 };
 const getWebViewInfo2 = providerId => {
-  return invoke$p('ExtensionHostWebView.getWebViewInfo2', providerId);
+  return invoke$r('ExtensionHostWebView.getWebViewInfo2', providerId);
 };
 const create3 = async (uri, id) => {
-  await invoke$p('WebView.create3', {
+  await invoke$r('WebView.create3', {
     id,
     uri,
     platform: platform,
@@ -13609,14 +13614,14 @@ const registerInterceptor = async (id, port) => {
   await invokeAndTransfer$6('WebView.registerInterceptor', id, port);
 };
 const unregisterInterceptor = async id => {
-  await invoke$p('WebView.unregisterInterceptor', id);
+  await invoke$r('WebView.unregisterInterceptor', id);
 };
 const compat = {
   sharedProcessInvoke(...args) {
-    return invoke$q(...args);
+    return invoke$s(...args);
   },
   rendererProcessInvoke(...args) {
-    return invoke$s(...args);
+    return invoke$u(...args);
   },
   rendererProcessInvokeAndTransfer(...args) {
     return invokeAndTransfer$9(...args);
@@ -13625,7 +13630,7 @@ const compat = {
     return invokeAndTransfer$6(...args);
   },
   extensionHostWorkerInvoke(...args) {
-    return invoke$p(...args);
+    return invoke$r(...args);
   },
   getWebViews() {
     return getWebViews$1();
@@ -13684,7 +13689,7 @@ const getOrCreate$1 = () => {
 };
 const invoke$f = async (method, ...params) => {
   const ipc = await getOrCreate$1();
-  return invoke$t(ipc, method, ...params);
+  return invoke$v(ipc, method, ...params);
 };
 
 const name$R = 'SearchProcess';
@@ -13713,16 +13718,16 @@ const executeTextSearchProvider = async (scheme, query) => {
   return result;
 };
 const textSearchHtml = (...args) => {
-  return invoke$p('TextSearchHtml.textSearch', ...args);
+  return invoke$r('TextSearchHtml.textSearch', ...args);
 };
 const textSearchFetch = (...args) => {
-  return invoke$p('TextSearchFetch.textSearch', ...args);
+  return invoke$r('TextSearchFetch.textSearch', ...args);
 };
 const textSearchMemory = (...args) => {
-  return invoke$p('TextSearchMemory.textSearch', ...args);
+  return invoke$r('TextSearchMemory.textSearch', ...args);
 };
 const textSearchMemory2 = (...args) => {
-  return invoke$p('TextSearchMemory.textSearch2', ...args);
+  return invoke$r('TextSearchMemory.textSearch2', ...args);
 };
 
 const name$Q = 'ExtensionHostTextSearch';
@@ -13767,7 +13772,8 @@ const Commands$H = {
   getNodeVersion: getNodeVersion,
   getElectronVersion: getElectronVersion,
   getChromeVersion: getChromeVersion,
-  getV8Version: getV8Version
+  getV8Version: getV8Version,
+  getArch: getArch
 };
 
 const Process_ipc = {
@@ -13781,17 +13787,21 @@ const handleExtensionStatusUpdate = async () => {
 };
 const invalidateExtensionsCache = async () => {
   try {
-    await invoke$p('Extensions.invalidateExtensionsCache');
+    await invoke$r('Extensions.invalidateExtensionsCache');
   } catch {
     // ignore
   }
 };
+const uninstall = async id => {
+  await invoke$s(/* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
+  invalidateExtensionsCache();
+};
 const disable = async id => {
   try {
     if (isTest()) {
       disabledIds = [...disabledIds, id];
     } else {
-      await invoke$q(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
+      await invoke$s(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -13804,7 +13814,7 @@ const enable = async id => {
     if (isTest()) {
       disabledIds = disabledIds.filter(existing => existing !== id);
     } else {
-      await invoke$q(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
+      await invoke$s(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -13816,11 +13826,11 @@ const getAllExtensions = async () => {
   if (platform === Web$1) {
     return [];
   }
-  return invoke$q(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+  return invoke$s(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
 };
 let disabledIds = [];
 const getExtension2 = async id => {
-  const extension = await invoke$p('Extensions.getExtension', id);
+  const extension = await invoke$r('Extensions.getExtension', id);
   if (disabledIds.includes(id)) {
     return {
       ...extension,
@@ -13831,7 +13841,7 @@ const getExtension2 = async id => {
   return extension;
 };
 const getExtensionsEtag = async () => {
-  const etag = await invoke$q('ExtensionManagement.getExtensionsEtag');
+  const etag = await invoke$s('ExtensionManagement.getExtensionsEtag');
   return etag;
 };
 
@@ -13843,7 +13853,8 @@ const Commands$G = {
   getExtension: getExtension2,
   getExtensions: getAllExtensions,
   getExtensionsEtag: getExtensionsEtag,
-  handleExtensionStatusUpdate: handleExtensionStatusUpdate
+  handleExtensionStatusUpdate: handleExtensionStatusUpdate,
+  uninstall: uninstall
 };
 
 const ExtensionManagement_ipc = {
@@ -13872,10 +13883,10 @@ const Markdown_ipc = {
 };
 
 const measureTextHeight = (text, fontFamily, fontSize) => {
-  return invoke$s('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
+  return invoke$u('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
 };
 const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke$s('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+  return invoke$u('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
 };
 
 const name$K = 'MeasureTextHeight';
@@ -13900,10 +13911,10 @@ const loadContent$J = async state => {
   const {
     id
   } = state;
-  await invoke$k('About.create', id);
-  await invoke$k('About.loadContent2', id);
-  const diffResult = await invoke$k('About.diff2', id);
-  const commands = await invoke$k('About.render2', id, diffResult);
+  await invoke$m('About.create', id);
+  await invoke$m('About.loadContent2', id);
+  const diffResult = await invoke$m('About.diff2', id);
+  const commands = await invoke$m('About.render2', id, diffResult);
   return {
     ...state,
     commands
@@ -13912,9 +13923,9 @@ const loadContent$J = async state => {
 
 const wrapAboutCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$k(`About.${key}`, state.id, ...args);
-    const diffResult = await invoke$k(`About.diff2`, state.id);
-    const commands = await invoke$k('About.render2', state.id, diffResult);
+    await invoke$m(`About.${key}`, state.id, ...args);
+    const diffResult = await invoke$m(`About.diff2`, state.id);
+    const commands = await invoke$m('About.render2', state.id, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -13928,8 +13939,11 @@ const wrapAboutCommand = key => {
 
 const Commands$D = {};
 const getCommands$f = async () => {
-  const commands = await invoke$k('About.getCommandIds');
+  const commands = await invoke$m('About.getCommandIds');
   for (const command of commands) {
+    if (command === 'About.showAbout') {
+      continue;
+    }
     Commands$D[command] = wrapAboutCommand(command);
   }
   return Commands$D;
@@ -13938,7 +13952,7 @@ const getCommands$f = async () => {
 const Css$D = ["/css/parts/ViewletAbout.css", "/css/parts/ViewletDialog.css"];
 
 const getKeyBindings$i = () => {
-  return invoke$k('About.getKeyBindings');
+  return invoke$m('About.getKeyBindings');
 };
 
 const name$J = 'About';
@@ -13997,7 +14011,7 @@ const renderDialog$2 = {
 };
 const render$E = [renderDialog$2];
 const renderEventListeners$f = async () => {
-  const listeners = await invoke$k('About.renderEventListeners');
+  const listeners = await invoke$m('About.renderEventListeners');
   return listeners;
 };
 
@@ -14021,7 +14035,7 @@ const ViewletAbout_ipc = {
 const activityBarWorkerUrl = `${assetDir}/packages/activity-bar-worker/dist/activityBarWorkerMain.js`;
 
 const launchActivityBarWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$l('develop.activityBarWorkerPath', activityBarWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$n('develop.activityBarWorkerPath', activityBarWorkerUrl);
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
@@ -14158,21 +14172,21 @@ const toContextMenuItem$1 = activityBarItem => {
     command: -1
   };
 };
-const id$c = ActivityBarAdditionalViews;
-const getMenuEntries$g = async () => {
+const id$b = ActivityBarAdditionalViews;
+const getMenuEntries$f = async () => {
   const hiddenActivityBarItems = await execute$4(/* ActivityBar.getHiddenItems */8011);
   return hiddenActivityBarItems.map(toContextMenuItem$1);
 };
 
 const MenuEntriesActivityBarAdditionalViews = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$g,
-  id: id$c
+  getMenuEntries: getMenuEntries$f,
+  id: id$b
 };
 
 const keyBindingsUri = 'app://keybindings';
-const id$b = Settings;
-const getMenuEntries$f = () => {
+const id$a = Settings;
+const getMenuEntries$e = () => {
   return [{
     id: 'commandPalette',
     label: commandPalette(),
@@ -14204,8 +14218,8 @@ const getMenuEntries$f = () => {
 
 const MenuEntriesSettings = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$f,
-  id: id$b
+  getMenuEntries: getMenuEntries$e,
+  id: id$a
 };
 
 const Left$1 = 1;
@@ -14269,8 +14283,8 @@ const menuEntryMoveSideBar = sideBarLocation => {
       throw new Error('unexpected side bar location');
   }
 };
-const id$a = ActivityBar$1;
-const getMenuEntries$e = async (layoutState, activityBarState) => {
+const id$9 = ActivityBar$1;
+const getMenuEntries$d = async (layoutState, activityBarState) => {
   const {
     activityBarItems
   } = activityBarState;
@@ -14288,8 +14302,8 @@ const inject = [Layout, ActivityBar$2];
 
 const MenuEntriesActivityBar = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$e,
-  id: id$a,
+  getMenuEntries: getMenuEntries$d,
+  id: id$9,
   inject
 };
 
@@ -14543,7 +14557,7 @@ const create$K = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$G = async state => {
-  const browserViewMap = await invoke$q('ElectronBrowserView.getAll');
+  const browserViewMap = await invoke$s('ElectronBrowserView.getAll');
   return {
     ...state,
     browserViewMap
@@ -14593,7 +14607,7 @@ const create$J = (id, uri, x, y, width, height) => {
 };
 const loadContent$F = state => {
   const update = async () => {
-    await invoke$s(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$u(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -16125,8 +16139,8 @@ const getKeyBindings$e = () => {
   return [];
 };
 
-const id$9 = E2eTests;
-const getMenuEntries$d = () => {
+const id$8 = E2eTests;
+const getMenuEntries$c = () => {
   return [{
     id: 'openInNewTab',
     label: 'Open in New Tab',
@@ -16137,8 +16151,8 @@ const getMenuEntries$d = () => {
 
 const MenuEntriesE2eTests = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$d,
-  id: id$9
+  getMenuEntries: getMenuEntries$c,
+  id: id$8
 };
 
 const menus$b = [MenuEntriesE2eTests];
@@ -16248,8 +16262,8 @@ const create$z = (id, uri, x, y, width, height) => {
   };
 };
 const getTests = async () => {
-  const root = await invoke$q('Platform.getRoot');
-  const testPath = await invoke$q('Platform.getTestPath');
+  const root = await invoke$s('Platform.getRoot');
+  const testPath = await invoke$s('Platform.getTestPath');
   const absolutePath = `${root}/${testPath}/src`;
   const dirents = await readDirWithFileTypes$9(absolutePath);
   const filteredDirents = dirents.slice(1);
@@ -17013,7 +17027,7 @@ const Commands$s = {
   ...wrapEditorCommands(ids),
   // TODO
   async showOverlayMessage(state, editor, ...args) {
-    await invoke$s(...args);
+    await invoke$u(...args);
     return state;
   },
   async hotReload(state, editor, ...args) {
@@ -17260,14 +17274,14 @@ const ViewletEmptyEditor_ipc = {
 const explorerWorkerUrl = `${assetDir}/packages/explorer-worker/dist/explorerViewWorkerMain.js`;
 
 const launchExplorerWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$l('develop.explorerWorkerPath', explorerWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$n('develop.explorerWorkerPath', explorerWorkerUrl);
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
     name: 'Explorer Worker'
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Explorer.initialize');
+  await invoke$v(ipc, 'Explorer.initialize');
   return ipc;
 };
 
@@ -17391,16 +17405,16 @@ const getKeyBindings$b = () => {
   return invoke$c('Explorer.getKeyBindings');
 };
 
-const id$8 = Explorer;
-const getMenuEntries$c = () => {
+const id$7 = Explorer;
+const getMenuEntries$b = () => {
   const explorerState = getState('Explorer');
   return invoke$c('Explorer.getMenuEntries2', explorerState.uid);
 };
 
 const MenuEntriesExplorer = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$c,
-  id: id$8
+  getMenuEntries: getMenuEntries$b,
+  id: id$7
 };
 
 const menus$9 = [MenuEntriesExplorer];
@@ -17527,7 +17541,7 @@ const launchExtensionDetailViewWorker = async () => {
     url: getConfiguredWorkerUrl$b()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'ExtensionDetail.initialize');
+  await invoke$v(ipc, 'ExtensionDetail.initialize');
   return ipc;
 };
 
@@ -17622,14 +17636,16 @@ const getCommands$c = async () => {
 const Css$o = ["/css/parts/AdditionalDetails.css", "/css/parts/BrowserScrollBar.css", "/css/parts/Category.css", "/css/parts/FeatureContent.css", "/css/parts/Features.css", "/css/parts/Markdown.css", "/css/parts/Message.css", "/css/parts/ScrollToTop.css", "/css/parts/ViewletExtensionDetail.css", "/css/parts/ViewletExtensionDetailHeader.css", "/css/parts/ViewletExtensionDetailTabs.css"];
 
 const menus$8 = [];
-const getMenus$1 = async () => {
+const getMenus$2 = async () => {
   try {
-    const modules = await invoke$b('ExtensionDetail.getMenus');
-    const adjusted = modules.map(module => {
+    const ids = await invoke$b('ExtensionDetail.getMenuIds');
+    const adjusted = ids.map(id => {
       return {
-        ...module,
-        async getMenuEntries() {
-          return module.entries;
+        id,
+        async getMenuEntries(...args) {
+          // TODO pass menu id also
+          const entries = await invoke$b('ExtensionDetail.getMenuEntries2', ...args);
+          return entries;
         }
       };
     });
@@ -17663,7 +17679,7 @@ const ViewletExtensionDetail_ipc = {
   Css: Css$o,
   create: create$s,
   getCommands: getCommands$c,
-  getMenus: getMenus$1,
+  getMenus: getMenus$2,
   hasFunctionalEvents: hasFunctionalEvents$c,
   hasFunctionalRender: hasFunctionalRender$o,
   hasFunctionalResize: hasFunctionalResize$d,
@@ -17699,7 +17715,7 @@ const launchExtensionSearchViewWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$t(ipc, 'SearchExtensions.initialize');
+    await invoke$v(ipc, 'SearchExtensions.initialize');
   } catch {
     // ignore
   }
@@ -17798,7 +17814,7 @@ const getKeyBindings$a = () => {
   return invoke$a('SearchExtensions.getKeyBindings');
 };
 
-const getMenuEntries$b = async () => {
+const getMenuEntries$a = async () => {
   const entries = await invoke$a('SearchExtensions.getMenuEntries');
   return entries;
   // {
@@ -17829,7 +17845,7 @@ const getMenuEntries$b = async () => {
 
 const MenuEntriesManageExtension = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$b
+  getMenuEntries: getMenuEntries$a
 };
 
 const menus$7 = [{
@@ -18118,7 +18134,7 @@ const launchReferencesWorker = async () => {
     url: getConfiguredWorkerUrl$8()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'References.initialize');
+  await invoke$v(ipc, 'References.initialize');
   return ipc;
 };
 
@@ -18708,8 +18724,8 @@ const getKeyBindings$8 = () => {
   return invoke$7('KeyBindings.getKeyBindings');
 };
 
-const id$7 = KeyBindingsTable;
-const getMenuEntries$a = () => {
+const id$6 = KeyBindingsTable;
+const getMenuEntries$9 = () => {
   return [{
     id: 'copy',
     label: copy$1(),
@@ -18760,8 +18776,8 @@ const getMenuEntries$a = () => {
 
 const MenuEntriesKeyBindingsTable = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$a,
-  id: id$7
+  getMenuEntries: getMenuEntries$9,
+  id: id$6
 };
 
 const menus$6 = [MenuEntriesKeyBindingsTable];
@@ -19157,7 +19173,9 @@ const create$l = id => {
     sideBarVisible: false,
     statusBarVisible: false,
     titleBarVisible: false,
-    workbenchVisible: false
+    workbenchVisible: false,
+    updateState: 'none',
+    updateProgress: 0
   };
 };
 const saveState$b = state => {
@@ -19712,7 +19730,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$s('Viewlet.sendMultiple', commands);
+    await invoke$u('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -19926,9 +19944,50 @@ const getInitialPlaceholderCommands = state => {
   }
   return commands;
 };
+const getAllQuickPickMenuEntries = () => {
+  return getAll();
+};
+const setUpdateState = async (state, updateState) => {
+  if (state.updateState === updateState.state && state.updateProgress === updateState.progress) {
+    return {
+      newState: state,
+      commands: []
+    };
+  }
+  const instances = getAllInstances();
+  const allCommands = [];
+  // @ts-ignore
+  for (const [key, value] of Object.entries(instances)) {
+    // @ts-ignore
+    if (value.factory.Commands && value.factory.Commands.handleUpdateStateChange) {
+      // @ts-ignore
+      const oldState = value.state;
+      // @ts-ignore
+      const newState = await value.factory.Commands.handleUpdateStateChange(oldState, updateState);
+      if (oldState !== newState) {
+        // @ts-ignore
+        const commands = render$F(value.factory, value.renderedState, newState);
+        // @ts-ignore
+        allCommands.push(...commands);
+      }
+    }
+  }
+  // TODO send all commands to renderer process, and update viewlet states
+  // TODO update all viewlets with this new update info
+  return {
+    newState: {
+      ...state,
+      updateState: updateState.state,
+      updateProgress: updateState.progress
+    },
+    commands: allCommands
+  };
+};
 
 // prettier-ignore
-const Commands$j = {};
+const Commands$j = {
+  getAllQuickPickMenuEntries: getAllQuickPickMenuEntries
+};
 const CommandsWithSideEffects$1 = {
   handleSashPointerDown: handleSashPointerDown,
   handleSashPointerUp: handleSashPointerUp,
@@ -19968,7 +20027,8 @@ const CommandsWithSideEffects$1 = {
   toggleSideBarPosition: toggleSideBarPosition,
   handleBlur: handleBlur$1,
   handleFocus: handleFocus,
-  showE2eTests: showE2eTests
+  showE2eTests: showE2eTests,
+  setUpdateState: setUpdateState
 };
 
 const Css$j = [];
@@ -20145,6 +20205,9 @@ const getKeyBindings$7 = () => {
 
 const getQuickPickMenuEntries$1 = () => {
   return [{
+    id: 'AutoUpdater.checkForUpdates',
+    label: 'Updater: Check for Updates'
+  }, {
     id: 'Layout.toggleSideBar',
     label: 'Layout: Toggle Side Bar'
   }, {
@@ -20686,6 +20749,7 @@ const ViewletLayout_ipc = {
   CommandsWithSideEffects: CommandsWithSideEffects$1,
   Css: Css$j,
   create: create$l,
+  getAllQuickPickMenuEntries,
   getInitialPlaceholderCommands,
   getKeyBindings: getKeyBindings$7,
   getPoints,
@@ -20720,6 +20784,7 @@ const ViewletLayout_ipc = {
   name: name$p,
   render: render$i,
   saveState: saveState$b,
+  setUpdateState,
   showActivityBar,
   showE2eTests,
   showMain,
@@ -21783,7 +21848,7 @@ const loadContent$l = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$s('Viewlet.loadModule', MainTabs);
+  await invoke$u('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -21872,7 +21937,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$s(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$u(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
   const y = state.y + state.tabHeight;
   const x = state.x;
   const width = state.width;
@@ -21897,7 +21962,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
     title,
     ...props
   });
-  await invoke$s('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$u('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state;
 };
@@ -22697,7 +22762,7 @@ const create$j = (id, uri, x, y, width, height) => {
 };
 const loadContent$k = state => {
   const update = async () => {
-    await invoke$s(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$u(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -22772,7 +22837,7 @@ const launchOutputViewWorker = async () => {
     url: getConfiguredWorkerUrl$6()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Output.initialize');
+  await invoke$v(ipc, 'Output.initialize');
   return ipc;
 };
 
@@ -23056,7 +23121,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     const currentViewletUid = currentViewletState.uid;
     number(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    await invoke$s('Viewlet.sendMultiple', commands);
+    await invoke$u('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$3)) {
       state.currentViewletId = Error$3;
     }
@@ -23207,7 +23272,7 @@ const launchProblemsWorker = async () => {
     url: getConfiguredWorkerUrl$5()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Problems.initialize');
+  await invoke$v(ipc, 'Problems.initialize');
   return ipc;
 };
 
@@ -23325,8 +23390,8 @@ const getKeyBindings$5 = () => {
   }];
 };
 
-const id$6 = Problems;
-const getMenuEntries$9 = () => {
+const id$5 = Problems;
+const getMenuEntries$8 = () => {
   // TODO
   return [
     // {
@@ -23346,12 +23411,12 @@ const getMenuEntries$9 = () => {
 
 const MenuEntriesProblems = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$9,
-  id: id$6
+  getMenuEntries: getMenuEntries$8,
+  id: id$5
 };
 
-const id$5 = ProblemsFilter;
-const getMenuEntries$8 = () => {
+const id$4 = ProblemsFilter;
+const getMenuEntries$7 = () => {
   return [{
     id: 'show-errors',
     label: 'Show Errors',
@@ -23372,8 +23437,8 @@ const getMenuEntries$8 = () => {
 
 const MenuEntriesProblemsFilter = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$8,
-  id: id$5
+  getMenuEntries: getMenuEntries$7,
+  id: id$4
 };
 
 const menus$5 = [MenuEntriesProblems, MenuEntriesProblemsFilter];
@@ -23742,10 +23807,10 @@ const loadContent$f = async state => {
   } = state;
   const listItemHeight = 22;
   const renderAllItems = true;
-  await invoke$o('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$z.workspacePath);
-  await invoke$o('QuickPick.loadContent', state.uid);
-  const diffResult = await invoke$o('QuickPick.diff2', state.uid);
-  const commands = await invoke$o('QuickPick.render2', state.uid, diffResult);
+  await invoke$q('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$z.workspacePath);
+  await invoke$q('QuickPick.loadContent', state.uid);
+  const diffResult = await invoke$q('QuickPick.diff2', state.uid);
+  const commands = await invoke$q('QuickPick.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -23757,12 +23822,12 @@ const dispose$b = state => {
 
 const wrapQuickPickCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$o(`QuickPick.${key}`, state.uid, ...args);
-    const diffResult = await invoke$o('QuickPick.diff2', state.uid);
+    await invoke$q(`QuickPick.${key}`, state.uid, ...args);
+    const diffResult = await invoke$q('QuickPick.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$o('QuickPick.render2', state.uid, diffResult);
+    const commands = await invoke$q('QuickPick.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -23773,7 +23838,7 @@ const wrapQuickPickCommand = key => {
 
 const Commands$c = {};
 const getCommands$6 = async () => {
-  const commands = await invoke$o('QuickPick.getCommandIds');
+  const commands = await invoke$q('QuickPick.getCommandIds');
   for (const command of commands) {
     Commands$c[command] = wrapQuickPickCommand(command);
   }
@@ -23787,7 +23852,7 @@ const Css$e = ["/css/parts/Progress.css"];
 const Variables$3 = ['QuickPickBackground', 'ListForeground', 'ListHoverBackground', 'ListHoverForeground', 'ListActiveSelectionBackground'];
 
 const getKeyBindings$4 = () => {
-  return invoke$o('QuickPick.getKeyBindings');
+  return invoke$q('QuickPick.getKeyBindings');
 };
 
 const hasFunctionalRender$d = true;
@@ -23802,7 +23867,7 @@ const renderItems$5 = {
 };
 const render$d = [renderItems$5];
 const renderEventListeners$5 = async () => {
-  const listeners = await invoke$o('QuickPick.renderEventListeners');
+  const listeners = await invoke$q('QuickPick.renderEventListeners');
   return listeners;
 };
 
@@ -23994,11 +24059,11 @@ const create$c = (id, uri, x, y, width, height, args, parentUid) => {
 };
 const loadContent$d = async (state, savedState) => {
   const isTest$1 = isTest();
-  await invoke$l('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$l('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
-  const diffResult = await invoke$l('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$l('RunAndDebug.render2', state.uid, diffResult);
-  const actionsDom = await invoke$l('RunAndDebug.renderActions', state.uid);
+  await invoke$n('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$n('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
+  const diffResult = await invoke$n('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$n('RunAndDebug.render2', state.uid, diffResult);
+  const actionsDom = await invoke$n('RunAndDebug.renderActions', state.uid);
   const debugId = isTest$1 ? 'test-debug' : 'node-debug'; // TODO
   return {
     ...state,
@@ -24019,17 +24084,17 @@ const hotReload$3 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$l('RunAndDebug.saveState', state.uid);
+  const savedState = await invoke$n('RunAndDebug.saveState', state.uid);
   await restart$9('RunAndDebug.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$l('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
-  await invoke$l('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
-  await invoke$l('RunAndDebug.loadContentLater', state.uid);
-  const diffResult = await invoke$l('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$l('RunAndDebug.render2', state.uid, diffResult);
+  await invoke$n('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$n('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
+  await invoke$n('RunAndDebug.loadContentLater', state.uid);
+  const diffResult = await invoke$n('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$n('RunAndDebug.render2', state.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -24084,19 +24149,19 @@ const resize$a = (state, dimensions) => {
   };
 };
 const saveState$4 = async state => {
-  const savedState = await invoke$l('RunAndDebug.saveState', state.uid);
+  const savedState = await invoke$n('RunAndDebug.saveState', state.uid);
   return savedState;
 };
 
 const wrapRunAndDebugCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$l(`RunAndDebug.${key}`, state.uid, ...args);
-    const diffResult = await invoke$l('RunAndDebug.diff2', state.uid);
+    await invoke$n(`RunAndDebug.${key}`, state.uid, ...args);
+    const diffResult = await invoke$n('RunAndDebug.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$l('RunAndDebug.render2', state.uid, diffResult);
-    const actionsDom = await invoke$l('RunAndDebug.renderActions', state.uid);
+    const commands = await invoke$n('RunAndDebug.render2', state.uid, diffResult);
+    const actionsDom = await invoke$n('RunAndDebug.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -24113,7 +24178,7 @@ const wrapRunAndDebugCommand = key => {
 
 const Commands$a = {};
 const getCommands$4 = async () => {
-  const commands = await invoke$l('RunAndDebug.getCommandIds');
+  const commands = await invoke$n('RunAndDebug.getCommandIds');
   for (const command of commands) {
     Commands$a[command] = wrapRunAndDebugCommand(command);
   }
@@ -24127,13 +24192,13 @@ const Variables$2 = ['TitleBarForeground', 'DebugSectionHeaderBackground', 'Side
 const Events$2 = {};
 
 const getKeyBindings$3 = () => {
-  return invoke$l('RunAndDebug.getKeyBindings');
+  return invoke$n('RunAndDebug.getKeyBindings');
 };
 
 const menus$4 = [];
-const getMenus = async () => {
+const getMenus$1 = async () => {
   try {
-    const modules = await invoke$l('RunAndDebug.getMenuEntries');
+    const modules = await invoke$n('RunAndDebug.getMenuEntries');
     const adjusted = modules.map(module => {
       return {
         ...module,
@@ -24160,7 +24225,7 @@ const renderItems$4 = {
 };
 const render$c = [renderItems$4];
 const renderEventListeners$4 = async () => {
-  const listeners = await invoke$l('RunAndDebug.renderEventListeners');
+  const listeners = await invoke$n('RunAndDebug.renderEventListeners');
   return listeners;
 };
 
@@ -24187,7 +24252,7 @@ const ViewletRunAndDebug_ipc = {
   dispose: dispose$9,
   getCommands: getCommands$4,
   getKeyBindings: getKeyBindings$3,
-  getMenus,
+  getMenus: getMenus$1,
   handleDebugInput,
   handleEvaluate,
   hasFunctionalEvents: hasFunctionalEvents$4,
@@ -24206,18 +24271,18 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async options => {
-  const sources = await invoke$q('DesktopCapturer.getSources', options);
+  const sources = await invoke$s('DesktopCapturer.getSources', options);
   return sources;
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$s('ScreenCapture.start', captureId, options);
+  await invoke$u('ScreenCapture.start', captureId, options);
 };
 const dispose$8 = async captureId => {
   number(captureId);
-  await invoke$s('ScreenCapture.dispose', captureId);
+  await invoke$u('ScreenCapture.dispose', captureId);
 };
 
 const createScreenCaptureStream = async captureId => {
@@ -24317,7 +24382,7 @@ const launchTextSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$t(ipc, 'TextSearch.initialize', platform);
+    await invoke$v(ipc, 'TextSearch.initialize', platform);
   } catch (error) {
     // ignore
   }
@@ -24430,30 +24495,25 @@ const getKeyBindings$2 = async () => {
   return keyBindings;
 };
 
-const id$4 = Search;
-const getMenuEntries$7 = () => {
-  // TODO move this to search worker
-  return [{
-    id: 'dismiss',
-    label: 'dismiss',
-    flags: None$a,
-    command: /* TODO */-1
-  }, {
-    id: 'copyPath',
-    label: 'copyPath',
-    flags: None$a,
-    command: /* TODO */-1
-  }];
-};
-
-const MenuEntriesSearch = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$7,
-  id: id$4
+const menus$3 = [];
+const getMenus = async () => {
+  try {
+    const ids = await invoke$4('Search.getMenuEntryIds');
+    const adjusted = ids.map(id => {
+      return {
+        id,
+        async getMenuEntries(...args) {
+          const entries = await invoke$4('Search.getMenuEntries', ...args);
+          return entries;
+        }
+      };
+    });
+    return adjusted;
+  } catch {
+    return [];
+  }
 };
 
-const menus$3 = [MenuEntriesSearch];
-
 const name$e = 'Search';
 
 const hasFunctionalRender$a = true;
@@ -24497,6 +24557,7 @@ const ViewletSearch_ipc = {
   dispose: dispose$6,
   getCommands: getCommands$3,
   getKeyBindings: getKeyBindings$2,
+  getMenus,
   hasFunctionalEvents: hasFunctionalEvents$3,
   hasFunctionalRender: hasFunctionalRender$a,
   hasFunctionalResize: hasFunctionalResize$7,
@@ -24533,7 +24594,7 @@ const launchSettingsWorker = async () => {
     url: getConfiguredWorkerUrl$3()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Initialize.initialize');
+  await invoke$v(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -24806,7 +24867,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
       activityBar.state = newState;
       commands.push(...extraCommands);
     }
-    await invoke$s('Viewlet.sendMultiple', commands);
+    await invoke$u('Viewlet.sendMultiple', commands);
   }
 
   // // TODO race condition (check if disposed after created)
@@ -24886,6 +24947,9 @@ const focus$1 = async state => {
   // currentViewlet.state = newState
   return state;
 };
+const handleUpdateStateChange = state => {
+  return state;
+};
 
 // prettier-ignore
 const Commands$7 = {
@@ -24893,7 +24957,8 @@ const Commands$7 = {
   openViewlet: openViewlet,
   show: openViewlet,
   open: openViewlet,
-  handleClickAction: handleClickAction
+  handleClickAction: handleClickAction,
+  handleUpdateStateChange: handleUpdateStateChange
 };
 
 const Css$8 = [];
@@ -24922,6 +24987,7 @@ const ViewletSideBar_ipc = {
   focus: focus$1,
   getChildren: getChildren$1,
   handleClickAction,
+  handleUpdateStateChange,
   hasFunctionalRender: hasFunctionalRender$8,
   loadContent: loadContent$9,
   name: name$c,
@@ -24954,7 +25020,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Initialize.initialize');
+  await invoke$v(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -24981,7 +25047,7 @@ const disposeWebContentsView = async id => {
 const getWindowZoomLevel = async () => {
   // TODO speed up resizing by avoid too many round trips
   const windowId = await getWindowId();
-  const zoomLevel = await invoke$q('ElectronWindow.getZoom', windowId);
+  const zoomLevel = await invoke$s('ElectronWindow.getZoom', windowId);
   return zoomLevel;
 };
 
@@ -25927,7 +25993,7 @@ const launchSourceControlWorker = async () => {
     url: getConfiguredWorkerUrl$1()
   });
   handleIpc(ipc);
-  await invoke$t(ipc, 'Initialize.initialize');
+  await invoke$v(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -26620,7 +26686,7 @@ const ViewletStorage_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$q('GetTerminalSpawnOptions.getTerminalSpawnOptions');
+  return invoke$s('GetTerminalSpawnOptions.getTerminalSpawnOptions');
 };
 
 // TODO implement a functional terminal component, maybe using offscreencanvas
@@ -26738,7 +26804,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$s(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$u(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 const getActions = state => {
@@ -26886,7 +26952,7 @@ const addTerminal = async state => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$s('Viewlet.sendMultiple', commands);
+  await invoke$u('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -26927,7 +26993,7 @@ const focusIndex = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$s('Viewlet.sendMultiple', commands);
+  await invoke$u('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index
@@ -27199,7 +27265,7 @@ const getRealUri = pathOrUri => {
   if (protocol) {
     return pathOrUri;
   }
-  return invoke$q('FileSystem.getRealUri', pathOrUri);
+  return invoke$s('FileSystem.getRealUri', pathOrUri);
 };
 
 const create = (id, uri, x, y, width, height) => {
@@ -27241,7 +27307,7 @@ const resize = (state, dimensions) => {
   };
 };
 const dispose = async state => {
-  await invoke$s('WebView.dispose', state.uid);
+  await invoke$u('WebView.dispose', state.uid);
   return state;
 };
 
@@ -27472,101 +27538,6 @@ const FileSystemAppKeyBindings = {
   writeJson
 };
 
-const downloadUpdate$2 = version => {
-  string(version);
-  return invoke$q('AutoUpdaterAppImage.downloadUpdate', version);
-};
-const installAndRestart$2 = downloadPath => {
-  string(downloadPath);
-  return invoke$q('AutoUpdaterAppImage.installAndRestart', downloadPath);
-};
-
-const AutoUpdaterAppImage = {
-  __proto__: null,
-  downloadUpdate: downloadUpdate$2,
-  installAndRestart: installAndRestart$2
-};
-
-const downloadUpdate$1 = version => {
-  string(version);
-  return invoke$q('AutoUpdaterWindowsNsis.downloadUpdate', version);
-};
-const installAndRestart$1 = downloadPath => {
-  string(downloadPath);
-  return invoke$q('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
-};
-
-const AutoUpdaterNsis = {
-  __proto__: null,
-  downloadUpdate: downloadUpdate$1,
-  installAndRestart: installAndRestart$1
-};
-
-const exec = (command, args, options) => {
-  string(command);
-  array(args);
-  object(options);
-  return invoke$q('Exec.exec', command, args, options);
-};
-
-const getDebArch = processArch => {
-  switch (processArch) {
-    case 'arm64':
-      return 'arm64';
-    case 'x64':
-      return 'amd64';
-    case 'arm':
-      return 'armhf';
-    default:
-      return '';
-  }
-};
-
-const getDownloadUrl = (repository, version, applicationName, debArch) => {
-  string(repository);
-  string(version);
-  string(applicationName);
-  string(debArch);
-  return `https://github.com/${repository}/releases/download/v${version}/${applicationName}-v${version}_${debArch}.deb`;
-};
-
-const getTmpDir = () => {
-  return invoke$q('Os.getTmpDir');
-};
-
-// TODO remove this code when auto update through apt is supported
-
-const pathSeparator = '/';
-const getOutFilePath = (tmpDir, applicationName, debArch, version) => {
-  return `${tmpDir}${pathSeparator}${applicationName}-${version}_${debArch}.deb`;
-};
-const downloadUpdate = async version => {
-  string(version);
-  const repository = await getRepository();
-  const applicationName = await getRepository();
-  const arch = await getArch();
-  const debArch = getDebArch(arch);
-  const downloadUrl$1 = getDownloadUrl(repository, version, applicationName, debArch);
-  const tmpDir = await getTmpDir();
-  const outFilePath = getOutFilePath(tmpDir, applicationName, debArch, version);
-  await downloadUrl(downloadUrl$1, outFilePath);
-  return outFilePath;
-};
-const installAndRestart = async downloadPath => {
-  try {
-    string(downloadPath);
-    await exec('sudo', ['dpkg', '-i', downloadPath]);
-  } catch (error) {
-    throw new VError(error, 'Failed to install deb update');
-  }
-};
-
-const AutoUpdaterDeb = {
-  __proto__: null,
-  downloadUpdate,
-  installAndRestart
-};
-
 const Separator = 'separator';
 
 const convertMenuItem = menuItem => {
@@ -27597,9 +27568,9 @@ const getItem = (items, label) => {
   return undefined;
 };
 const openContextMenu = async (x, y, id, ...args) => {
-  const entries = await getMenuEntries$h(id, ...args);
+  const entries = await getMenuEntries$g(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$q('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$s('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -27645,7 +27616,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$q('ElectronWindowProcessExplorer.open');
+    await invoke$s('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, 'Failed to open process explorer');
   }
@@ -29137,7 +29108,7 @@ const QuickPickEntriesView = {
 };
 
 const searchFile$1 = async (path, value, prepare) => {
-  return invoke$o('SearchFile.searchFile', path, value, prepare, assetDir);
+  return invoke$q('SearchFile.searchFile', path, value, prepare, assetDir);
 };
 
 const searchFile = async (path, value) => {