@lvce-editor/static-server 0.77.11 → 0.77.12

package/static/{c0b16fe → 9d77d9c}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -108,7 +108,7 @@ const getAssetDir$1 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/c0b16fe';
+    return '/9d77d9c';
   }
 };
 const assetDir = getAssetDir$1();
@@ -829,10 +829,10 @@ const listen$1 = async () => {
   const rpc = await getRpc();
   state$C.rpc = rpc;
 };
-const invoke$E = (method, ...params) => {
+const invoke$F = (method, ...params) => {
   return state$C.rpc.invoke(method, ...params);
 };
-const invokeAndTransfer$q = (method, ...params) => {
+const invokeAndTransfer$r = (method, ...params) => {
   return state$C.rpc.invokeAndTransfer(method, ...params);
 };
 
@@ -851,7 +851,7 @@ const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
 };
 const addCssStyleSheet = (id, css) => {
-  return invoke$E('Css.addCssStyleSheet', id, css);
+  return invoke$F('Css.addCssStyleSheet', id, css);
 };
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
   const css = await getCss(preferences);
@@ -1508,10 +1508,10 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const invoke$D = (ipc, method, ...params) => {
+const invoke$E = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$p = (ipc, method, ...params) => {
+const invokeAndTransfer$q = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -1526,11 +1526,11 @@ const getOrCreateWorker = fn => {
   return {
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invoke$D(ipc, method, ...params);
+      return invoke$E(ipc, method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invokeAndTransfer$p(ipc, method, ...params);
+      return invokeAndTransfer$q(ipc, method, ...params);
     },
     async dispose() {
       const promise = workers$1.get(fn);
@@ -1692,8 +1692,8 @@ const launchErrorWorker = async () => {
 };
 
 const {
-  invoke: invoke$C,
-  invokeAndTransfer: invokeAndTransfer$o
+  invoke: invoke$D,
+  invokeAndTransfer: invokeAndTransfer$p
 } = getOrCreateWorker(launchErrorWorker);
 
 const serializeError = error => {
@@ -1714,14 +1714,14 @@ const serializeError = error => {
 const prepare = async error => {
   try {
     const serialized = serializeError(error);
-    const prepared = await invoke$C('Errors.prepare', serialized);
+    const prepared = await invoke$D('Errors.prepare', serialized);
     return prepared;
   } catch {
     return error;
   }
 };
 const print = async (error, prefix = '') => {
-  await invoke$C('Errors.print', error, prefix);
+  await invoke$D('Errors.print', error, prefix);
 };
 const getMessage$3 = error => {
   if (error && error.type && error.message) {
@@ -2042,18 +2042,18 @@ const state$x = {
 };
 
 /* istanbul ignore file */
-const invoke$B = async (method, ...params) => {
+const invoke$C = async (method, ...params) => {
   const {
     ipc
   } = state$x;
-  const result = await invoke$D(ipc, method, ...params);
+  const result = await invoke$E(ipc, method, ...params);
   return result;
 };
-const invokeAndTransfer$n = async (method, ...params) => {
+const invokeAndTransfer$o = async (method, ...params) => {
   const {
     ipc
   } = state$x;
-  const result = await invokeAndTransfer$p(ipc, method, ...params);
+  const result = await invokeAndTransfer$q(ipc, method, ...params);
   return result;
 };
 
@@ -2087,7 +2087,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$3(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$B(PreferencesGetAll);
+  return invoke$C(PreferencesGetAll);
 };
 const getPreferences = async () => {
   // TODO cache preferences, but they should not be stale
@@ -2160,13 +2160,13 @@ const launchExtensionManagementWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.extensionManagementWorkerPath', extensionManagementWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Extensions.initialize', getPlatform$1());
+  await invoke$E(ipc, 'Extensions.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invoke: invoke$A,
-  invokeAndTransfer: invokeAndTransfer$m} = getOrCreateWorker(launchExtensionManagementWorker);
+  invoke: invoke$B,
+  invokeAndTransfer: invokeAndTransfer$n} = getOrCreateWorker(launchExtensionManagementWorker);
 
 // TODO make storage configurable via settings as localstorage or indexeddb
 // also allow disabling caching via settings
@@ -2197,11 +2197,11 @@ const getColorThemeJson = (colorThemeId, platform, assetDir) => {
   string(colorThemeId);
   number(platform);
   string(assetDir);
-  return invoke$A('Extensions.getColorThemeJson', colorThemeId, platform, assetDir);
+  return invoke$B('Extensions.getColorThemeJson', colorThemeId, platform, assetDir);
 };
 
 const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
-  return invoke$A('Extensions.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
+  return invoke$B('Extensions.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
 };
 const getColorThemeCssNew = async colorThemeId => {
   const platform = getPlatform$1();
@@ -2218,7 +2218,7 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$E(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$F(/* 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
@@ -2267,7 +2267,7 @@ const watch$1 = async id => {
     return;
   }
   state$w.watchedTheme = id;
-  await invoke$B('ExtensionHost.watchColorTheme', id);
+  await invoke$C('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get$e('workbench.colorTheme');
@@ -2326,7 +2326,7 @@ const handleEvent = async (id, event) => {
       if (!ipc) {
         return;
       }
-      await invoke$D(ipc, alternate.callBackCommandId, event);
+      await invoke$E(ipc, alternate.callBackCommandId, event);
       return;
     }
     console.warn(`target not found ${id}`);
@@ -2344,7 +2344,7 @@ const watchFile = async (rpcId, callBackCommandId, uri) => {
     callBackCommandId
   };
   // TODO use filesystem worker / file watcher worker
-  await invoke$B('FileWatcher.watchFile2', id, uri);
+  await invoke$C('FileWatcher.watchFile2', id, uri);
   return map$3[id];
 };
 
@@ -2362,13 +2362,13 @@ const get$c = () => {
 
 const getWindowId = async () => {
   const webContentsId = get$c();
-  const windowId = await invoke$B('GetWindowId.getWindowId', webContentsId);
+  const windowId = await invoke$C('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
 
 const forward$2 = key => async (...args) => {
   const windowId = await getWindowId();
-  return invoke$B(key, windowId, ...args);
+  return invoke$C(key, windowId, ...args);
 };
 const reload$3 = forward$2('ElectronWindow.reload');
 const minimize$1 = forward$2('ElectronWindow.minimize');
@@ -2387,7 +2387,7 @@ const reloadElectron = () => {
 };
 
 const reloadWeb = () => {
-  return invoke$E('Window.reload');
+  return invoke$F('Window.reload');
 };
 
 const getFn$2 = () => {
@@ -2426,55 +2426,55 @@ const getUrlBaseName = href => {
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$B(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+  return invoke$C(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
 };
 const getDisabledExtensionsJsonPath = () => {
-  return invoke$B(/* Platform.getDisabledExtensionsJsonPath */'Platform.getDisabledExtensionsJsonPath');
+  return invoke$C(/* Platform.getDisabledExtensionsJsonPath */'Platform.getDisabledExtensionsJsonPath');
 };
 const getCachedExtensionsPath = () => {
-  return invoke$B(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
+  return invoke$C(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
 };
 const getLogsDir = () => {
   if (getPlatform$1() === Web$1) {
     return 'memfs://output';
   }
-  return invoke$B(/* Platform.getLogsDir */'Platform.getLogsDir');
+  return invoke$C(/* Platform.getLogsDir */'Platform.getLogsDir');
 };
 const getDownloadDir = () => {
-  return invoke$B(/* Platform.getDownloadDir */'Platform.getDownloadDir');
+  return invoke$C(/* Platform.getDownloadDir */'Platform.getDownloadDir');
 };
 const getUserSettingsPath = () => {
   if (getPlatform$1() === Web$1) {
     return 'settings';
   }
-  return invoke$B(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
+  return invoke$C(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
 };
 const getUserKeyBindingsPath = () => {
   if (getPlatform$1() === Web$1) {
     return 'settings';
   }
-  return invoke$B(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
+  return invoke$C(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
 };
 const getRecentlyOpenedPath = () => {
   if (getPlatform$1() === Web$1) {
     return 'recently-opened';
   }
-  return invoke$B(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
+  return invoke$C(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
 };
 const getConfigPath = () => {
-  return invoke$B(/* Platform.getConfigDir */'Platform.getConfigDir');
+  return invoke$C(/* Platform.getConfigDir */'Platform.getConfigDir');
 };
 const getCachePath = () => {
-  return invoke$B(/* Platform.getCacheDir */'Platform.getCacheDir');
+  return invoke$C(/* Platform.getCacheDir */'Platform.getCacheDir');
 };
 const getCacheUri = () => {
-  return invoke$B(/* Platform.getCacheDir */'Platform.getCacheUri');
+  return invoke$C(/* Platform.getCacheDir */'Platform.getCacheUri');
 };
 const getCacheName = () => {
   return 'lvce-runtime';
 };
 const getTestPathRemote = () => {
-  return invoke$B(/* Platform.getTestPath */'Platform.getTestPath');
+  return invoke$C(/* Platform.getTestPath */'Platform.getTestPath');
 };
 const getTestPathWeb = () => {
   return `${assetDir}/packages/extension-host-worker-tests`;
@@ -2494,7 +2494,7 @@ const getTmpDir = () => {
   if (getPlatform$1() === Web$1) {
     throw new Error('not implemented in web');
   }
-  return invoke$B(/* Platform.getTmpDir */'Platform.getTmpDir');
+  return invoke$C(/* Platform.getTmpDir */'Platform.getTmpDir');
 };
 
 const existsTest = async url => {
@@ -2535,7 +2535,7 @@ const launchTestWorker = async () => {
 
 const execute$2 = async href => {
   const ipc = await launchTestWorker();
-  await invoke$D(ipc, 'Test.execute', href, getPlatform$1(), assetDir);
+  await invoke$E(ipc, 'Test.execute', href, getPlatform$1(), assetDir);
 };
 
 const executeCurrentTest = async (platform, initData) => {
@@ -2694,7 +2694,7 @@ const getAvailableKeyBindings = keyBindings => {
 const update = () => {
   const matchingKeyBindings = getMatchingKeyBindings(state$r.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$E('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  invoke$F('KeyBindings.setIdentifiers', keyBindingIdentifiers);
   state$r.matchingKeyBindings = matchingKeyBindings;
   state$r.keyBindingIdentifiers = keyBindingIdentifiers;
 };
@@ -2979,13 +2979,13 @@ const serializeObjects = objects => {
 };
 
 const clear$6 = async storageType => {
-  await invoke$E(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$F(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$E('WebStorage.getAll', storageType);
+  return invoke$F('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$E(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$F(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$6 = async (storageType, key) => {
@@ -3000,7 +3000,7 @@ const getJson$6 = async (storageType, key) => {
   }
 };
 const setText$1 = async (storageType, key, value) => {
-  await invoke$E(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$F(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$5 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -3008,7 +3008,7 @@ const setJson$5 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = serializeObjects(objects);
-  await invoke$E('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$F('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -3066,7 +3066,7 @@ const Slash = Slash$1;
 
 const SharedProcessCliArgSource = 'shared-process-cli-arg';
 const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$B(/* Workspace.resolveRoot */WorkspaceResolveRoot);
+  const resolvedRoot = await invoke$C(/* Workspace.resolveRoot */WorkspaceResolveRoot);
   return resolvedRoot;
 };
 const isValid$1 = resolvedRoot => {
@@ -3136,20 +3136,20 @@ const getResolvedRoot = async href => {
 };
 
 const getHref$1 = () => {
-  return invoke$E(/* Location.getHref */'Location.getHref');
+  return invoke$F(/* Location.getHref */'Location.getHref');
 };
 const setPathName = pathName => {
-  return invoke$E(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+  return invoke$F(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
 const hydrate$6 = () => {
-  return invoke$E(/* Location.hydrate */'Location.hydrate');
+  return invoke$F(/* Location.hydrate */'Location.hydrate');
 };
 const getHost = () => {
   return location.host;
 };
 
 const set$9 = title => {
-  return invoke$E('WindowTitle.set', title);
+  return invoke$F('WindowTitle.set', title);
 };
 
 const state$o = {
@@ -3376,7 +3376,7 @@ const create$15 = async ({
     port1,
     port2
   } = getPortTuple(port);
-  await invokeAndTransfer$q('IpcParent.create', {
+  await invokeAndTransfer$r('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
@@ -3452,7 +3452,7 @@ const getConfig = () => {
 
 const objects = Object.create(null);
 const transferToRendererProcess = async (objectId, transferable) => {
-  await invokeAndTransfer$q('Transferrable.transfer', transferable, objectId);
+  await invokeAndTransfer$r('Transferrable.transfer', transferable, objectId);
 };
 const transfer = (objectId, transferable) => {
   number(objectId);
@@ -3484,16 +3484,16 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$D(ipc, 'Workspace.setWorkspacePath', state$o.workspacePath);
+  await invoke$E(ipc, 'Workspace.setWorkspacePath', state$o.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$D(ipc, 'Workspace.setWorkspacePath', state$o.workspacePath);
+    await invoke$E(ipc, 'Workspace.setWorkspacePath', state$o.workspacePath);
   });
   return ipc;
 };
 
 const {
-  invoke: invoke$z,
-  invokeAndTransfer: invokeAndTransfer$l
+  invoke: invoke$A,
+  invokeAndTransfer: invokeAndTransfer$m
 } = getOrCreateWorker(launchExtensionHostWorker);
 
 const ActivityBar$3 = 'ActivityBar';
@@ -3513,7 +3513,7 @@ const ExtensionStateStorage = {
 };
 
 const saveState$j = async () => {
-  const state = await invoke$z('SaveState.saveState');
+  const state = await invoke$A('SaveState.saveState');
   return state;
 };
 const getSavedState = async () => {
@@ -3574,7 +3574,7 @@ const hydrate$4 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$E('Window.onVisibilityChange');
+  await invoke$F('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$4(viewletId);
@@ -3610,8 +3610,8 @@ const launchQuickPickWorker = async () => {
 };
 
 const {
-  invoke: invoke$y,
-  invokeAndTransfer: invokeAndTransfer$k} = getOrCreateWorker(launchQuickPickWorker);
+  invoke: invoke$z,
+  invokeAndTransfer: invokeAndTransfer$l} = getOrCreateWorker(launchQuickPickWorker);
 
 const state$m = {
   /**
@@ -3627,7 +3627,7 @@ const add = 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$y('QuickPick.addMenuEntries', menuEntries);
+  await invoke$z('QuickPick.addMenuEntries', menuEntries);
 };
 
 const loadModule$2 = async (id, module) => {
@@ -3831,7 +3831,7 @@ const runFn = async (instance, id, key, fn, args) => {
     const commands = render$L(instance.factory, oldState, newState, newState.uid || id);
     updateDynamicFocusContext(commands);
     setRenderedState(id, newState);
-    await invoke$E(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$F(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3857,7 +3857,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
     return;
   }
   updateDynamicFocusContext(commands);
-  await invoke$E(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$F(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -4084,7 +4084,7 @@ const maybeRegisterEvents = module => {
       const commands = render$L(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
       instance.state = newState;
       instance.renderedState = newState;
-      await invoke$E(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$F(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     };
     addListener('workspace.change', handleUpdate);
   }
@@ -4111,7 +4111,7 @@ const maybeRegisterEvents = module => {
         const commands = render$L(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$E(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$F(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -4142,7 +4142,7 @@ const actuallyLoadModule = async (getModule, id) => {
   }
   const module = await getModule(id);
   if (!module.hasFunctionalEvents) {
-    await invoke$E(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
+    await invoke$F(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
   }
   await loadModule$1(id, module);
   await maybeRegisterWrappedCommands(id, module);
@@ -4218,7 +4218,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       if (shouldRenderEvents === false) {
         commands.push(['Viewlet.registerEventListeners', viewletUid, eventListeners]);
       } else {
-        await invoke$E('Viewlet.registerEventListeners', viewletUid, eventListeners);
+        await invoke$F('Viewlet.registerEventListeners', viewletUid, eventListeners);
       }
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
@@ -4273,7 +4273,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$E(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$F(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -4333,7 +4333,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       commands.push(...extraCommands);
       updateDynamicFocusContext(commands);
-      await invoke$E(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$F(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else if (!module.hasFunctionalEvents && shouldRender) {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -4354,7 +4354,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$E(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$F(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -4376,10 +4376,10 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$E(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$F(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$E(kLoadModule, Error$4);
+      await invoke$F(kLoadModule, Error$4);
       commands.push([kCreate, Error$4, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -4388,7 +4388,7 @@ const load$5 = 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$E(kLoadModule, module.customErrorRenderer);
+        await invoke$F(kLoadModule, module.customErrorRenderer);
         commands.push([kCreate, module.customErrorRenderer, viewletUid]);
         commands.push(['Viewlet.setDom2', viewletUid, dom]);
         commands.push([kAppend, parentUid, viewletUid]);
@@ -4440,7 +4440,7 @@ const load$3 = async moduleId => {
 };
 
 const disposeBrowserViewQuickPick = () => {
-  return invoke$B('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
+  return invoke$C('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
 const handleKeyBinding$1 = async identifier => {
@@ -4489,7 +4489,7 @@ const focus$5 = async id => {
     const newState = instance.factory.focus(oldState);
     commands.push(...render$L(instance.factory, oldState, newState));
   }
-  await invoke$E('Viewlet.sendMultiple', commands);
+  await invoke$F('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -4532,7 +4532,7 @@ const dispose$u = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$E(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$F(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -4713,7 +4713,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$E(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$F(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -4756,7 +4756,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$E('Viewlet.executeCommands', commands);
+  await invoke$F('Viewlet.executeCommands', commands);
 };
 const closeWidget = async id => {
   try {
@@ -4768,7 +4768,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$E(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$F(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4826,7 +4826,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$E(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$F(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 
 // @ts-ignore
@@ -4866,7 +4866,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$E('Viewlet.sendMultiple', commands);
+    await invoke$F('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4914,31 +4914,31 @@ const launchIconThemeWorker = async () => {
 };
 
 const {
-  invoke: invoke$x,
-  invokeAndTransfer: invokeAndTransfer$j
+  invoke: invoke$y,
+  invokeAndTransfer: invokeAndTransfer$k
 } = getOrCreateWorker(launchIconThemeWorker);
 
 const getFileIcon$1 = file => {
-  return invoke$x('IconTheme.getFileIcon', file);
+  return invoke$y('IconTheme.getFileIcon', file);
 };
 const getFileIcons = fileNames => {
-  return invoke$x('IconTheme.getFileIcons', fileNames);
+  return invoke$y('IconTheme.getFileIcons', fileNames);
 };
 const getFolderIcon = folder => {
-  return invoke$x('IconTheme.getFolderIcon', folder);
+  return invoke$y('IconTheme.getFolderIcon', folder);
 };
 const getIcon = dirent => {
-  return invoke$x('IconTheme.getIcon', dirent);
+  return invoke$y('IconTheme.getIcon', dirent);
 };
 const getIcons = iconRequests => {
-  return invoke$x('IconTheme.getIcons', iconRequests);
+  return invoke$y('IconTheme.getIcons', iconRequests);
 };
 
 const setIconTheme = async (iconThemeId, platform, assetDir) => {
   try {
     const useCache = get$e('icon-theme.cache') ?? true;
-    const extensions = await invoke$A('Extensions.getAllExtensions', assetDir, platform);
-    await invoke$x('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, platform, useCache);
+    const extensions = await invoke$B('Extensions.getAllExtensions', assetDir, platform);
+    await invoke$y('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, platform, useCache);
     await handleIconThemeChange$1();
   } catch (error) {
     if (isTest()) ; else {
@@ -4953,7 +4953,7 @@ const hydrate$3 = async (platform, assetDir) => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$E('InitData.getInitData');
+  const rendererProcessInitData = await invoke$F('InitData.getInitData');
   // TODO get the following items
   // - location.href
   // - workspace
@@ -5102,7 +5102,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$B(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  const languageConfiguration = await invoke$C(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
   if (languageConfiguration) {
     return languageConfiguration;
   }
@@ -5115,7 +5115,7 @@ const getLanguageConfiguration$2 = async languageId => {
 
 const getLanguages = async (platform, assetDir) => {
   try {
-    return invoke$A('Extensions.getLanguages', platform, assetDir);
+    return invoke$B('Extensions.getLanguages', platform, assetDir);
   } catch (error) {
     throw new VError(error, 'Failed to load languages');
   }
@@ -5259,7 +5259,7 @@ const hydrate$2 = async (platform, assetDir) => {
   const languages = await getLanguages(platform, assetDir);
   // 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$x('IconTheme.addLanguages', languages);
+  await invoke$y('IconTheme.addLanguages', languages);
   await addLanguages(languages);
   const useJsx = get$e('languages.jsFilesAsJsx');
   if (useJsx) {
@@ -5772,7 +5772,7 @@ const addToRecentlyOpenedWeb = async path => {
   await setRecentlyOpened(newRecentlyOpened);
 };
 const addToRecentlyOpenedRemote = async path => {
-  await invoke$B(RecentlyOpenedAddPath, path);
+  await invoke$C(RecentlyOpenedAddPath, path);
 };
 const addToRecentlyOpened = async path => {
   switch (getPlatform$1()) {
@@ -5810,16 +5810,16 @@ const hydrate$1 = async () => {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const saveValue$1 = async (storeId, value) => {
-  await invoke$z('IndexedDb.saveValue', storeId, value);
+  await invoke$A('IndexedDb.saveValue', storeId, value);
 };
 const getValuesByIndexName$1 = async (storeId, indexName, only) => {
-  return invoke$z('IndexedDb.getValuesByIndexName', storeId, indexName, only);
+  return invoke$A('IndexedDb.getValuesByIndexName', storeId, indexName, only);
 };
 const addHandle$1 = async (uri, handle) => {
-  return invoke$z('IndexedDb.addHandle', uri, handle);
+  return invoke$A('IndexedDb.addHandle', uri, handle);
 };
 const getHandle$1 = async uri => {
-  return invoke$z('IndexedDb.getHandle', uri);
+  return invoke$A('IndexedDb.getHandle', uri);
 };
 
 const saveValue = async (sessionId, value) => {
@@ -6143,7 +6143,7 @@ const watchFilesForHotReload = async platform => {
     if (config.length === 0) {
       return;
     }
-    await invoke$B('ExtensionHost.watchForHotReload', config);
+    await invoke$C('ExtensionHost.watchForHotReload', config);
   } catch (error) {
     console.warn(`Failed to watch ${error}`);
   }
@@ -6259,7 +6259,7 @@ const startup = async (platform, assetDir) => {
   // const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state)
   // commands.push(...placeholderCommands)
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$E('Viewlet.executeCommands', commands);
+  await invoke$F('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
@@ -6610,6 +6610,7 @@ const commandMap = {
   'SendMessagePortToElectron.sendMessagePortToElectron': lazy('SendMessagePortToElectron.sendMessagePortToElectron'),
   'SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker'),
   'SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToAuthWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToAuthWorker'),
   'SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker'),
   'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker'),
   'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker'),
@@ -6739,6 +6740,7 @@ const commandMap = {
   'Layout.getActiveSecondarySideBarView': lazy('Layout.getActiveSecondarySideBarView'),
   'Layout.getSecondarySideBarVisible': lazy('Layout.getSecondarySideBarVisible'),
   'Layout.getAssetDir': lazy('Layout.getAssetDir'),
+  'Layout.getAuthState': lazy('Layout.getAuthState'),
   'Layout.getBackendUrl': lazy('Layout.getBackendUrl'),
   'Layout.getBadgeCounts': lazy('Layout.getBadgeCounts'),
   'Layout.getCommit': lazy('Layout.getCommit'),
@@ -6777,6 +6779,8 @@ const commandMap = {
   'Layout.openSideBarViewlet': lazy('Layout.openSideBarViewlet'),
   'Layout.openSecondarySideBarViewlet': lazy('Layout.openSecondarySideBarViewlet'),
   'Layout.setUpdateState': lazy('Layout.setUpdateState'),
+  'Layout.signIn': lazy('Layout.signIn'),
+  'Layout.signOut': lazy('Layout.signOut'),
   'Layout.showActivityBar': lazy('Layout.showActivityBar'),
   'Layout.showE2eTests': lazy('Layout.showE2eTests'),
   'Layout.showMain': lazy('Layout.showMain'),
@@ -6853,7 +6857,7 @@ const getPort = async ipcId => {
     port2
   } = getPortTuple();
   // TODO call sendMessagePortToElectron function
-  const webContentsId = await invokeAndTransfer$q('IpcParent.create', {
+  const webContentsId = await invokeAndTransfer$r('IpcParent.create', {
     method: Electron,
     port: port1,
     ipcId
@@ -7333,7 +7337,7 @@ const IpcParentWithNode = {
 const sendMessagePortToElectron = async (port, initialCommand, ipcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$n(initialCommand, port, ipcId);
+  await invokeAndTransfer$o(initialCommand, port, ipcId);
 };
 
 const create$X = async options => {
@@ -7421,10 +7425,10 @@ const GetColorThemeCssCachedLocalStorage = {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const set$7 = async (key, value) => {
-  await invoke$z('IndexedDb.set', key, value);
+  await invoke$A('IndexedDb.set', key, value);
 };
 const get$6 = async key => {
-  return invoke$z('IndexedDb.get', key);
+  return invoke$A('IndexedDb.get', key);
 };
 
 const getCacheKey = colorThemeId => {
@@ -7491,7 +7495,7 @@ const get$3 = () => {
 };
 
 const addWebExtension = async path => {
-  const manifest = await invoke$z('Extensions.addWebExtension', path);
+  const manifest = await invoke$A('Extensions.addWebExtension', path);
   // TODO avoid side effect here
   if (manifest.languages) {
     for (const language of manifest.languages) {
@@ -7605,7 +7609,7 @@ const handleRejectedExtensions = async extensions => {
   }
 };
 const getExtensions$1 = async (assetDir, platform) => {
-  return invoke$A('Extensions.getAllExtensions', assetDir, platform);
+  return invoke$B('Extensions.getAllExtensions', assetDir, platform);
 };
 const addNodeExtension = async path => {
   // TODO add support for dynamically loading node extensions
@@ -7648,13 +7652,13 @@ const actuallyActivateExtension = async (extension, event) => {
   const platform = getPlatform$1();
   if (!(extension.id in state$e.activatedExtensions)) {
     const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin, getPlatform$1());
-    state$e.activatedExtensions[extension.id] = invoke$A('Extensions.activate3', extension, absolutePath, event, platform);
+    state$e.activatedExtensions[extension.id] = invoke$B('Extensions.activate3', extension, absolutePath, event, platform);
   }
   return state$e.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async (event, assetDir, platform) => {
   // TODO should not query extensions multiple times
-  const extensions = await invoke$A('Extensions.getAllExtensions', assetDir, platform);
+  const extensions = await invoke$B('Extensions.getAllExtensions', assetDir, platform);
   const {
     resolved,
     rejected
@@ -7702,7 +7706,7 @@ const executeProviders = async ({
   platform
 }) => {
   await activateByEvent(event, assetDir, platform);
-  const result = await invoke$z(method, ...params);
+  const result = await invoke$A(method, ...params);
   return result;
 };
 const executeProvider = async ({
@@ -7714,7 +7718,7 @@ const executeProvider = async ({
   platform = getPlatform$1()
 }) => {
   await activateByEvent(event, assetDir, platform);
-  const result = invoke$z(method, ...params);
+  const result = invoke$A(method, ...params);
   return result;
 };
 
@@ -7941,46 +7945,46 @@ const FileSystemData = {
 
 const name$2n = 'Memory';
 const readFile$b = uri => {
-  return invoke$z('FileSystemMemory.readFile', uri);
+  return invoke$A('FileSystemMemory.readFile', uri);
 };
 const exists$2 = uri => {
-  return invoke$z('FileSystemMemory.exists', uri);
+  return invoke$A('FileSystemMemory.exists', uri);
 };
 const writeFile$b = (uri, content) => {
-  return invoke$z('FileSystemMemory.writeFile', uri, content);
+  return invoke$A('FileSystemMemory.writeFile', uri, content);
 };
 const mkdir$5 = uri => {
-  return invoke$z('FileSystemMemory.mkdir', uri);
+  return invoke$A('FileSystemMemory.mkdir', uri);
 };
 const getPathSeparator$5 = () => {
   return Slash;
 };
 const remove$4 = uri => {
-  return invoke$z('FileSystemMemory.remove', uri);
+  return invoke$A('FileSystemMemory.remove', uri);
 };
 const readDirWithFileTypes$5 = uri => {
-  return invoke$z('FileSystemMemory.readDirWithFileTypes', uri);
+  return invoke$A('FileSystemMemory.readDirWithFileTypes', uri);
 };
 const getBlobUrl$2 = uri => {
-  return invoke$z('FileSystemMemory.getBlobUrl', uri);
+  return invoke$A('FileSystemMemory.getBlobUrl', uri);
 };
 const getBlob$5 = async uri => {
-  return invoke$z('FileSystemMemory.getBlob', uri);
+  return invoke$A('FileSystemMemory.getBlob', uri);
 };
 const chmod$3 = (path, permissions) => {
-  return invoke$z('FileSystemMemory.chmod', path, permissions);
+  return invoke$A('FileSystemMemory.chmod', path, permissions);
 };
 const rename$3 = (oldPath, newPath) => {
-  return invoke$z('FileSystemMemory.rename', oldPath, newPath);
+  return invoke$A('FileSystemMemory.rename', oldPath, newPath);
 };
 const copy$2 = (oldPath, newPath) => {
-  return invoke$z('FileSystemMemory.copy', oldPath, newPath);
+  return invoke$A('FileSystemMemory.copy', oldPath, newPath);
 };
 const stat$1 = uri => {
-  return invoke$z('FileSystemMemory.stat', uri);
+  return invoke$A('FileSystemMemory.stat', uri);
 };
 const getFiles$1 = () => {
-  return invoke$z('FileSystemMemory.getFiles');
+  return invoke$A('FileSystemMemory.getFiles');
 };
 
 const FileSystemMemory = {
@@ -8310,13 +8314,13 @@ const launchFileSystemWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.fileSystemWorkerPath', fileSystemWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Initialize.initialize', getPlatform$1());
+  await invoke$E(ipc, 'Initialize.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invoke: invoke$w,
-  invokeAndTransfer: invokeAndTransfer$i} = getOrCreateWorker(launchFileSystemWorker);
+  invoke: invoke$x,
+  invokeAndTransfer: invokeAndTransfer$j} = getOrCreateWorker(launchFileSystemWorker);
 
 // TODO move all of this to an extension
 
@@ -8327,12 +8331,12 @@ const state$c = {
 };
 const readFile$9 = async uri => {
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
-    return invoke$w('FileSystem.readFile', `${location.protocol}//${uri}`);
+    return invoke$x('FileSystem.readFile', `${location.protocol}//${uri}`);
   }
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
-    return invoke$w('FileSystemFetch.readFile', uri);
+    return invoke$x('FileSystemFetch.readFile', uri);
   }
-  return invoke$z('FileSystemFetch.readFile', uri);
+  return invoke$A('FileSystemFetch.readFile', uri);
 };
 const exists$1 = async uri => {
   try {
@@ -8344,33 +8348,33 @@ const exists$1 = async uri => {
 };
 const readJson$4 = async uri => {
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
-    return invoke$w('FileSystem.readJson', `${location.protocol}//${uri}`);
+    return invoke$x('FileSystem.readJson', `${location.protocol}//${uri}`);
   }
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
-    return invoke$w('FileSystem.readJson', uri);
+    return invoke$x('FileSystem.readJson', uri);
   }
-  return invoke$z('FileSystemFetch.readJson', uri);
+  return invoke$A('FileSystemFetch.readJson', uri);
 };
 const writeFile$9 = (uri, content) => {
-  return invoke$z('FileSystemFetch.writeFile', uri);
+  return invoke$A('FileSystemFetch.writeFile', uri);
 };
 const mkdir$3 = uri => {
-  return invoke$z('FileSystemFetch.mkdir', uri);
+  return invoke$A('FileSystemFetch.mkdir', uri);
 };
 const getPathSeparator$3 = () => {
   return Slash;
 };
 const remove$2 = uri => {
-  return invoke$z('FileSystemFetch.remove', uri);
+  return invoke$A('FileSystemFetch.remove', uri);
 };
 const readDirWithFileTypes$3 = async uri => {
-  return invoke$z('FileSystemFetch.readDirWithFileTypes', uri);
+  return invoke$A('FileSystemFetch.readDirWithFileTypes', uri);
 };
 const chmod$2 = (path, permissions) => {
-  return invoke$z('FileSystemFetch.chmod', path, permissions);
+  return invoke$A('FileSystemFetch.chmod', path, permissions);
 };
 const getBlob$4 = async (uri, type) => {
-  return invoke$z('FileSystemFetch.getBlob', uri, type);
+  return invoke$A('FileSystemFetch.getBlob', uri, type);
 };
 
 const FileSystemFetch = {
@@ -8405,45 +8409,45 @@ const toUri = item => {
 const copy$1 = (source, target) => {
   source = toUri(source);
   target = toUri(target);
-  return invoke$w('FileSystem.copy', /* source */source, /* target */target);
+  return invoke$x('FileSystem.copy', /* source */source, /* target */target);
 };
 const readFile$8 = (path, encoding) => {
   path = toUri(path);
-  return invoke$w('FileSystem.readFile', /* path */path, /* encoding */encoding);
+  return invoke$x('FileSystem.readFile', /* path */path, /* encoding */encoding);
 };
 const exists = (path, encoding) => {
   path = toUri(path);
-  return invoke$w('FileSystem.exists', /* path */path);
+  return invoke$x('FileSystem.exists', /* path */path);
 };
 const readJson$3 = path => {
   path = toUri(path);
-  return invoke$w('FileSystem.readJson', /* path */path);
+  return invoke$x('FileSystem.readJson', /* path */path);
 };
 const remove$1 = path => {
   path = toUri(path);
-  return invoke$w('FileSystem.remove', /* path */path);
+  return invoke$x('FileSystem.remove', /* path */path);
 };
 const rename$1 = (oldUri, newUri) => {
   oldUri = toUri(oldUri);
   newUri = toUri(newUri);
-  return invoke$w('FileSystem.rename', /* oldPath */oldUri, /* newPath */newUri);
+  return invoke$x('FileSystem.rename', /* oldPath */oldUri, /* newPath */newUri);
 };
 const mkdir$2 = path => {
   path = toUri(path);
-  return invoke$w('FileSystem.mkdir', /* path */path);
+  return invoke$x('FileSystem.mkdir', /* path */path);
 };
 const writeFile$8 = async (path, content, encoding) => {
   path = toUri(path);
-  await invoke$w(/* FileSystem.writeFile */'FileSystem.writeFile', /* path */path, /* content */content, /* encoding */encoding);
+  await invoke$x(/* FileSystem.writeFile */'FileSystem.writeFile', /* path */path, /* content */content, /* encoding */encoding);
 };
 const writeBlob = async (path, blob) => {
   path = toUri(path);
-  await invoke$w('FileSystem.writeBlob', path, blob);
+  await invoke$x('FileSystem.writeBlob', path, blob);
 };
 const ensureFile = async () => {};
 const readDirWithFileTypes$2 = path => {
   path = toUri(path);
-  return invoke$w('FileSystem.readDirWithFileTypes', /* path */path);
+  return invoke$x('FileSystem.readDirWithFileTypes', /* path */path);
 };
 const getBlobUrl$1 = path => {
   if (!path.startsWith('/')) {
@@ -8452,7 +8456,7 @@ const getBlobUrl$1 = path => {
   return getRemoteSrc(path);
 };
 const getBlob$3 = async (path, type) => {
-  const content = await invoke$w('FileSystem.readFileAsBuffer', path);
+  const content = await invoke$x('FileSystem.readFileAsBuffer', path);
   const array = new Uint8Array(content.data);
   const blob = new Blob([array], {
     type
@@ -8463,22 +8467,22 @@ const getPathSeparator$2 = () => {
   if (getPlatform$1() === Web$1) {
     return Slash;
   }
-  return invoke$w('FileSystem.getPathSeparator');
+  return invoke$x('FileSystem.getPathSeparator');
 };
 const getRealPath = path => {
-  return invoke$w('FileSystem.getRealPath', /* path */path);
+  return invoke$x('FileSystem.getRealPath', /* path */path);
 };
 const stat = path => {
   path = toUri(path);
-  return invoke$w('FileSystem.stat', /* path */path);
+  return invoke$x('FileSystem.stat', /* path */path);
 };
 const getFolderSize = path => {
   path = toUri(path);
-  return invoke$w('FileSystem.getFolderSize', /* path */path);
+  return invoke$x('FileSystem.getFolderSize', /* path */path);
 };
 const chmod$1 = (path, permissions) => {
   path = toUri(path);
-  return invoke$w('FileSystem.chmod', /* path */path, /* permissions */permissions);
+  return invoke$x('FileSystem.chmod', /* path */path, /* permissions */permissions);
 };
 const canBeRestored$1 = true;
 
@@ -8616,7 +8620,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$E('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$F('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -8881,18 +8885,18 @@ const launchDebugWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.debugWorkerPath', debugWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Initialize.initialize');
+  await invoke$E(ipc, 'Initialize.initialize');
   return ipc;
 };
 
 const {
-  invoke: invoke$v,
+  invoke: invoke$w,
   restart: restart$h
 } = getOrCreateWorker(launchDebugWorker);
 
 const name$2j = 'Debug';
 const readFile$6 = uri => {
-  return invoke$v('RunAndDebug.readFile', uri);
+  return invoke$w('RunAndDebug.readFile', uri);
 };
 const writeFile$6 = (uri, content) => {
   throw new Error('not implemented');
@@ -8976,11 +8980,11 @@ const launchAboutViewWorker = async () => {
 };
 
 const {
-  invoke: invoke$u
+  invoke: invoke$v
 } = getOrCreateWorker(launchAboutViewWorker);
 
 const showAboutElectron = async () => {
-  return invoke$u('About.showAboutElectron');
+  return invoke$v('About.showAboutElectron');
 };
 
 const showAboutDefault = async () => {
@@ -9090,10 +9094,10 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$E(/* Audio.play */3211, /* src */src);
+  await invoke$F(/* Audio.play */3211, /* src */src);
 };
 const play = async url => {
-  await invoke$E('Audio.play', /* src */url);
+  await invoke$F('Audio.play', /* src */url);
 };
 
 const name$2g = 'Audio';
@@ -9122,12 +9126,12 @@ const launchUpdateWorker = async () => {
 };
 
 const {
-  invoke: invoke$t
+  invoke: invoke$u
 } = getOrCreateWorker(launchUpdateWorker);
 
 const checkForUpdates = async updateSetting => {
   const repository = 'lvce-editor/lvce-editor';
-  await invoke$t('Update.checkForUpdates', updateSetting, repository);
+  await invoke$u('Update.checkForUpdates', updateSetting, repository);
 };
 
 const name$2f = 'AutoUpdater';
@@ -9161,7 +9165,7 @@ const GetActiveEditor_ipc = {
 };
 
 const getSelectionText = () => {
-  return invoke$E('Css.getSelectionText');
+  return invoke$F('Css.getSelectionText');
 };
 
 const name$2d = 'Document';
@@ -9179,7 +9183,7 @@ const exec = (command, args, options) => {
   string(command);
   array(args);
   object(options);
-  return invoke$B('Exec.exec', command, args, options);
+  return invoke$C('Exec.exec', command, args, options);
 };
 
 const name$2c = 'Exec';
@@ -9255,14 +9259,14 @@ const PlatformPaths_ipc = {
 };
 
 const getFileHandles = ids => {
-  return invoke$E('FileHandles.get', ids);
+  return invoke$F('FileHandles.get', ids);
 };
 const addFileHandle = fileHandle => {
-  return invoke$E('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$F('FileSystemHandle.addFileHandle', fileHandle);
 };
 
 const getFilePathElectron = async file => {
-  return invoke$E('GetFilePathElectron.getFilePathElectron', file);
+  return invoke$F('GetFilePathElectron.getFilePathElectron', file);
 };
 
 const name$29 = 'FileSystemHandle';
@@ -9279,13 +9283,13 @@ const FileSystemHandle_ipc = {
 };
 
 const base64StringToBlob = base64String => {
-  return invoke$w('Blob.base64StringToBlob', base64String);
+  return invoke$x('Blob.base64StringToBlob', base64String);
 };
 const binaryStringToBlob = async (string, type) => {
-  return invoke$w('Blob.binaryStringToBlob', string, type);
+  return invoke$x('Blob.binaryStringToBlob', string, type);
 };
 const blobToBinaryString = async blob => {
-  return invoke$w('Blob.blobToBinaryString', blob);
+  return invoke$x('Blob.blobToBinaryString', blob);
 };
 
 const getSrc = uri => {
@@ -9357,10 +9361,10 @@ const applyLegacyBulkReplacement = async (files, ranges, replacement) => {
   array(ranges);
   string(replacement);
   if (isSpecialScheme(files)) {
-    await invoke$z('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+    await invoke$A('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
     return;
   }
-  await invoke$B('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$C('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const applyFileReplacement = async edit => {
@@ -9604,48 +9608,48 @@ const launchClipBoardWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.clipBoardWorkerPath', clipBoardWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'ClipBoard.initialize', getPlatform$1());
+  await invoke$E(ipc, 'ClipBoard.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invoke: invoke$s,
-  invokeAndTransfer: invokeAndTransfer$h} = getOrCreateWorker(launchClipBoardWorker);
+  invoke: invoke$t,
+  invokeAndTransfer: invokeAndTransfer$i} = getOrCreateWorker(launchClipBoardWorker);
 
 const readText = async () => {
-  return await invoke$s('ClipBoard.readText');
+  return await invoke$t('ClipBoard.readText');
 };
 const writeText$1 = async text => {
-  return await invoke$s('ClipBoard.writeText', text);
+  return await invoke$t('ClipBoard.writeText', text);
 };
 const enableMemoryClipBoard = async () => {
-  return await invoke$s('ClipBoard.enableMemoryClipBoard');
+  return await invoke$t('ClipBoard.enableMemoryClipBoard');
 };
 const readMemoryText = async () => {
-  return await invoke$s('ClipBoard.readMemoryText');
+  return await invoke$t('ClipBoard.readMemoryText');
 };
 const disableMemoryClipBoard = async () => {
-  return await invoke$s('ClipBoard.disableMemoryClipBoard');
+  return await invoke$t('ClipBoard.disableMemoryClipBoard');
 };
 const hotReload$k = async () => {
-  return await invoke$s('ClipBoard.hotReload');
+  return await invoke$t('ClipBoard.hotReload');
 };
 const writeNativeFiles = async (type, files) => {
-  return await invoke$s('ClipBoard.writeNativeFiles', type, files);
+  return await invoke$t('ClipBoard.writeNativeFiles', type, files);
 };
 const readNativeFiles = async () => {
-  return await invoke$s('ClipBoard.readNativeFiles');
+  return await invoke$t('ClipBoard.readNativeFiles');
 };
 const writeImage = async blob => {
   try {
-    return await invoke$E('ClipBoard.writeImage', blob);
+    return await invoke$F('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$E('ClipBoard.execCopy');
+    return await invoke$F('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
@@ -9672,7 +9676,7 @@ const ClipBoard_ipc = {
 };
 
 const getColorThemeNames = async (assetDir, platform) => {
-  return invoke$A('Extensions.getColorThemeNames', assetDir, platform);
+  return invoke$B('Extensions.getColorThemeNames', assetDir, platform);
 };
 
 const name$22 = 'ColorTheme';
@@ -9689,7 +9693,7 @@ const ColorTheme_ipc = {
   name: name$22
 };
 
-const product = {"backendUrl":"https://backend-2-975h.onrender.com/"};
+const product = {"backendUrl":"https://lvce-editor.dev"};
 
 const productNameLong$1 = 'Lvce Editor - OSS';
 const getProductNameLong$1 = () => {
@@ -9700,7 +9704,7 @@ const getBackendUrl$1 = () => {
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$B('ElectronDialog.showOpenDialog', title, properties);
+  return invoke$C('ElectronDialog.showOpenDialog', title, properties);
 };
 const showMessageBox = async options => {
   // TODO maybe request window id here instead of at caller
@@ -9712,7 +9716,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$B('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$C('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Error$2 = 'error';
@@ -9740,7 +9744,7 @@ const promptError = async (message, confirmMessage, title) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$E('ConfirmPrompt.prompt', message);
+  const result = await invoke$F('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -9780,7 +9784,7 @@ const ok = () => {
 let _mockId$1 = 0;
 const showMockConfirmPrompt = async (message, options) => {
   const ipc = get$d();
-  const result = await invoke$D(ipc, 'Test.executeMock', _mockId$1, message, options);
+  const result = await invoke$E(ipc, 'Test.executeMock', _mockId$1, message, options);
   return result;
 };
 const mock$1 = mockId => {
@@ -9834,21 +9838,21 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = options => {
-  return invoke$B('ElectronContentTracing.startRecording', options);
+  return invoke$C('ElectronContentTracing.startRecording', options);
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$B('ElectronContentTracing.stopRecording');
+  return invoke$C('ElectronContentTracing.stopRecording');
 };
 
 const showItemInFolder = fullPath => {
-  return invoke$B('OpenExternal.showItemInFolder', fullPath);
+  return invoke$C('OpenExternal.showItemInFolder', fullPath);
 };
 const openExternal$2 = url => {
-  return invoke$B('OpenExternal.openExternal', url);
+  return invoke$C('OpenExternal.openExternal', url);
 };
 
 const openNativeFolderWeb = absolutePath => {
@@ -9856,7 +9860,7 @@ const openNativeFolderWeb = absolutePath => {
 };
 const openNativeFolderRemote = async absolutePath => {
   try {
-    await invoke$B(OpenNativeFolder, /* path */absolutePath);
+    await invoke$C(OpenNativeFolder, /* path */absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`);
   }
@@ -9975,23 +9979,23 @@ const Debug_ipc = {
 
 const attachDebugger = async pid => {
   number(pid);
-  await invoke$B('AttachDebugger.attachDebugger', pid);
+  await invoke$C('AttachDebugger.attachDebugger', pid);
 };
 
-const version = '0.77.11';
-const commit$1 = 'c0b16fe';
+const version = '0.77.12';
+const commit$1 = '9d77d9c';
 const productNameLong = 'Lvce Editor - OSS';
 const getPid = () => {
-  return invoke$B('Process.getPid');
+  return invoke$C('Process.getPid');
 };
 const getElectronVersion = () => {
-  return invoke$B('ElectronProcess.getElectronVersion');
+  return invoke$C('ElectronProcess.getElectronVersion');
 };
 const getNodeVersion = () => {
-  return invoke$B('Process.getNodeVersion');
+  return invoke$C('Process.getNodeVersion');
 };
 const getChromeVersion = () => {
-  return invoke$B('ElectronProcess.getChromeVersion');
+  return invoke$C('ElectronProcess.getChromeVersion');
 };
 const getVersion = () => {
   return version;
@@ -10003,10 +10007,10 @@ const getProductNameLong = () => {
   return productNameLong;
 };
 const getV8Version = () => {
-  return invoke$B('Process.getV8Version');
+  return invoke$C('Process.getV8Version');
 };
 const getArch = () => {
-  return invoke$B('Process.getArch');
+  return invoke$C('Process.getArch');
 };
 
 const debugSharedProcess = async () => {
@@ -10026,10 +10030,10 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$B('Crash.crashSharedProcess');
+  return invoke$C('Crash.crashSharedProcess');
 };
 const crashMainProcess = () => {
-  return invoke$B('Crash.crashMainProcess');
+  return invoke$C('Crash.crashMainProcess');
 };
 
 const toggleDeveloperTools = () => {
@@ -10045,7 +10049,7 @@ const openCacheFolder = async () => {
   await openNativeFolder(cacheFolder);
 };
 const openDataFolder = async () => {
-  const dataFolder = await invoke$B(/* Platform.getDataDir */'Platform.getDataDir');
+  const dataFolder = await invoke$C(/* Platform.getDataDir */'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 const openLogsFolder = async () => {
@@ -10054,12 +10058,12 @@ const openLogsFolder = async () => {
     return;
   }
   const logsFolder = await getLogsDir();
-  await invoke$B('FileSystem.mkdir', /* path */logsFolder);
+  await invoke$C('FileSystem.mkdir', /* path */logsFolder);
   await openNativeFolder(logsFolder);
 };
 
 const getPerformanceEntries = () => {
-  return invoke$B('ElectronDeveloper.getPerformanceEntries');
+  return invoke$C('ElectronDeveloper.getPerformanceEntries');
 };
 
 const toMarkdownTable = (header, rows) => {
@@ -10300,7 +10304,7 @@ const getNodeTiming = () => {
   if (getPlatform$1() === Web$1) {
     return undefined;
   }
-  return invoke$B(/* command */'Performance.getNodeStartupTiming');
+  return invoke$C(/* command */'Performance.getNodeStartupTiming');
 };
 const getMeasureEntries = () => {
   const measureEntries = getEntriesByType(Measure);
@@ -10389,13 +10393,13 @@ const formatRendererProcessData = ({
   return toMarkdownTable(header, rows);
 };
 const getSharedProcessMemoryUsage = () => {
-  return invoke$B(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
+  return invoke$C(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$E('Performance.getMemory');
+  return invoke$F('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$E('Performance.measureUserAgentSpecificMemory');
+  return invoke$F('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -10444,13 +10448,13 @@ const showMemoryUsage = async () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$B(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
+  return invoke$C(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
 };
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$B(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
+  await invoke$C(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
 };
 const createSharedProcessProfile = async () => {
-  await invoke$B(/* Developer.createProfile */'Developer.createProfile');
+  await invoke$C(/* Developer.createProfile */'Developer.createProfile');
 };
 const reloadIconTheme = async (platform, assetDir) => {
   await hydrate$3(platform, assetDir);
@@ -10638,12 +10642,12 @@ const revokeObjectUrl = url => {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$E(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$F(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$B(DownloadDownload, /* url */url, /* outFile */outFile);
+  await invoke$C(DownloadDownload, /* url */url, /* outFile */outFile);
 };
 const downloadJson = async (json, fileName) => {
   let url = '';
@@ -10737,7 +10741,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$E(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$F(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$1Y = {
@@ -10763,7 +10767,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$B('ElectronClipBoard.writeText', text);
+  return invoke$C('ElectronClipBoard.writeText', text);
 };
 
 const name$1T = 'ElectronClipBoard';
@@ -10822,7 +10826,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$B('Exit.exit');
+  return invoke$C('Exit.exit');
 };
 
 const name$1P = 'Exit';
@@ -10863,13 +10867,13 @@ const executeCommand = (id, ...args) => {
   });
 };
 const searchFileWithFetch = (...args) => {
-  return invoke$z('SearchFileWithFetch.searchFileWithFetch', ...args);
+  return invoke$A('SearchFileWithFetch.searchFileWithFetch', ...args);
 };
 const searchFileWithHtml = (...args) => {
-  return invoke$z('SearchFileWithHtml.searchFileWithHtml', ...args);
+  return invoke$A('SearchFileWithHtml.searchFileWithHtml', ...args);
 };
 const searchFileWithMemory = (...args) => {
-  return invoke$z('SearchFileWithMemory.searchFileWithMemory', ...args);
+  return invoke$A('SearchFileWithMemory.searchFileWithMemory', ...args);
 };
 
 const state$a = {
@@ -10962,7 +10966,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$E('FilePicker.showDirectoryPicker', options);
+    return await invoke$F('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10973,11 +10977,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$E('FilePicker.showFilePicker', options);
+  return invoke$F('FilePicker.showFilePicker', options);
 };
 const doShowSaveFilePicker = async options => {
   try {
-    return await invoke$E('FilePicker.showSaveFilePicker', options);
+    return await invoke$F('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10990,7 +10994,7 @@ const doShowSaveFilePicker = async options => {
 let _mockId = 0;
 const doShowMockSaveFilePicker = async () => {
   const ipc = get$d();
-  const result = await invoke$D(ipc, 'Test.executeMock', _mockId);
+  const result = await invoke$E(ipc, 'Test.executeMock', _mockId);
   return result;
 };
 const showSaveFilePicker = async options => {
@@ -11081,15 +11085,15 @@ const show$8 = async (uri, top, left) => {
     if (version !== state$9.versionId) {
       return;
     }
-    await invoke$E(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$F(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$E(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$F(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
   }
 };
 const hide$4 = async () => {
   ++state$9.versionId;
-  await invoke$E(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$F(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -11388,23 +11392,23 @@ const launchMenuWorker = async () => {
 };
 
 const {
-  invoke: invoke$r
+  invoke: invoke$s
 } = getOrCreateWorker(launchMenuWorker);
 
 const show$7 = async (x, y, menuId, ...args) => {
-  await invoke$r('Menu.show', menuId, x, y, ...args);
+  await invoke$s('Menu.show', menuId, x, y, ...args);
 };
 const show2$2 = async (uid, menuId, x, y, ...args) => {
-  await invoke$r('Menu.show2', uid, menuId, x, y, ...args);
+  await invoke$s('Menu.show2', uid, menuId, x, y, ...args);
 };
 const selectIndex$1 = async (level, index) => {
-  await invoke$r('Menu.selectIndex', level, index);
+  await invoke$s('Menu.selectIndex', level, index);
 };
 const selectItem = async text => {
-  await invoke$r('Menu.selectItem', text);
+  await invoke$s('Menu.selectItem', text);
 };
 const hide$3 = async (restoreFocus = true) => {
-  await invoke$r('Menu.hide', restoreFocus);
+  await invoke$s('Menu.hide', restoreFocus);
 };
 
 // TODO difference between focusing with mouse or keyboard
@@ -11412,25 +11416,25 @@ const hide$3 = async (restoreFocus = true) => {
 // with keyboard -> don't open submenu, only focus
 
 const handleMouseEnter = async (level, index, enterX, enterY, enterTimeStamp) => {
-  await invoke$r('Menu.handleMouseEnter', level, index, enterX, enterY, enterTimeStamp);
+  await invoke$s('Menu.handleMouseEnter', level, index, enterX, enterY, enterTimeStamp);
 };
 const handleMouseLeave = async () => {
-  await invoke$r('Menu.handleMouseLeave');
+  await invoke$s('Menu.handleMouseLeave');
 };
 const focusIndex$3 = async (menu, index) => {
-  await invoke$r('Menu.focusIndex', menu, index);
+  await invoke$s('Menu.focusIndex', menu, index);
 };
 const focusFirst$1 = async () => {
-  await invoke$r('Menu.focusFirst');
+  await invoke$s('Menu.focusFirst');
 };
 const focusLast$1 = async () => {
-  await invoke$r('Menu.focusLast');
+  await invoke$s('Menu.focusLast');
 };
 const focusPrevious$1 = async () => {
-  await invoke$r('Menu.focusPrevious');
+  await invoke$s('Menu.focusPrevious');
 };
 const focusNext$1 = async () => {
-  await invoke$r('Menu.focusNext');
+  await invoke$s('Menu.focusNext');
 };
 
 // TODO handle printable letter and focus item that starts with that letter
@@ -11589,22 +11593,22 @@ const state$7 = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$E(/* ActivityBar.focus */717115);
+  await invoke$F(/* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$E(/* StatusBar.focus */8882);
+  await invoke$F(/* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$E(/* Panel.focus */6664);
+  await invoke$F(/* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$E(/* SideBar.focus */5554);
+  await invoke$F(/* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$E(/* TitleBar.focus */1331);
+  await invoke$F(/* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$E(/* Main.focus */2145);
+  await invoke$F(/* Main.focus */2145);
 };
 const focusPart = part => {
   state$7.focusedPart = part;
@@ -11715,7 +11719,7 @@ const create$W = async (type, text) => {
     type,
     text
   });
-  await invoke$E(/* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$F(/* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -11724,7 +11728,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$E(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$F(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$1 = index => {
   console.log('handle click');
@@ -11740,7 +11744,7 @@ const handleClick$1 = index => {
   });
 };
 const dispose$t = async id => {
-  await invoke$E(/* Notification.dispose */'Notification.dispose', /* id */id);
+  await invoke$F(/* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$1x = 'Notification';
@@ -11759,7 +11763,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async (url, useRedirect) => {
   try {
-    await invoke$E(/* Open.openUrl */'Open.openUrl', /* url */url, useRedirect);
+    await invoke$F(/* Open.openUrl */'Open.openUrl', /* url */url, useRedirect);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -11790,13 +11794,13 @@ const Open_ipc = {
 };
 
 const create$V = id => {
-  return invoke$B('OAuthServer.create', id);
+  return invoke$C('OAuthServer.create', id);
 };
 const getCode = id => {
-  return invoke$B('OAuthServer.getCode', id);
+  return invoke$C('OAuthServer.getCode', id);
 };
 const dispose$s = id => {
-  return invoke$B('OAuthServer.dispose', id);
+  return invoke$C('OAuthServer.dispose', id);
 };
 
 const name$1v = 'OAuthServer';
@@ -11859,7 +11863,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$E('Prompt.prompt', message, defaultValue);
+  return invoke$F('Prompt.prompt', message, defaultValue);
 };
 
 const name$1r = 'Prompt';
@@ -11874,7 +11878,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$B('RebuildNodePty.rebuildNodePty');
+  await invoke$C('RebuildNodePty.rebuildNodePty');
 };
 
 const name$1q = 'RebuildNodePty';
@@ -12010,19 +12014,19 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$E('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$F('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$E('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$F('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$E('TestFrameWork.showOverlay', ...args);
+  return invoke$F('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$E('TestFrameWork.performAction', ...args);
+  return invoke$F('TestFrameWork.performAction', ...args);
 };
 const checkConditionError = (...args) => {
-  return invoke$E('TestFrameWork.checkConditionError', ...args);
+  return invoke$F('TestFrameWork.checkConditionError', ...args);
 };
 
 const name$1i = 'TestFrameWork';
@@ -12118,10 +12122,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$E('PointerCapture.mock');
+  return invoke$F('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$E('PointerCapture.unmock');
+  return invoke$F('PointerCapture.unmock');
 };
 
 const name$1c = 'PointerCapture';
@@ -12263,7 +12267,7 @@ const set$3 = async (url, contentSecurityPolicy) => {
   if (getPlatform$1() === Web$1) {
     return;
   }
-  await invoke$B('ContentSecurityPolicy.set', url, contentSecurityPolicy);
+  await invoke$C('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
 const set$2 = async (url, contentSecurityPolicy) => {
@@ -12307,8 +12311,8 @@ const launchTerminalWorker = async () => {
 };
 
 const {
-  invoke: invoke$q,
-  invokeAndTransfer: invokeAndTransfer$g
+  invoke: invoke$r,
+  invokeAndTransfer: invokeAndTransfer$h
 } = getOrCreateWorker(launchTerminalWorker);
 
 const previewWorkerUrl = `${assetDir}/packages/preview-worker/dist/previewWorkerMain.js`;
@@ -12325,33 +12329,33 @@ const launchPreviewWorker = async () => {
 };
 
 const {
-  invoke: invoke$p,
-  invokeAndTransfer: invokeAndTransfer$f,
+  invoke: invoke$q,
+  invokeAndTransfer: invokeAndTransfer$g,
   restart: restart$g
 } = getOrCreateWorker(launchPreviewWorker);
 
 const create$U = async canvasId => {
   number(canvasId);
   const id = create$16();
-  await invoke$E('OffscreenCanvas.create', canvasId, id);
+  await invoke$F('OffscreenCanvas.create', canvasId, id);
   const canvas = acquire(id);
   return canvas;
 };
 const create2 = async (canvasId, width, height) => {
   number(canvasId);
   const id = create$16();
-  await invoke$E('OffscreenCanvas.create2', canvasId, id, width, height);
+  await invoke$F('OffscreenCanvas.create2', canvasId, id, width, height);
   const canvas = acquire(id);
   return canvas;
 };
 const createForTerminal = async (canvasId, callbackId) => {
   const canvas = await create$U(canvasId);
-  await invokeAndTransfer$g('OffscreenCanvas.handleResult', callbackId, canvas);
+  await invokeAndTransfer$h('OffscreenCanvas.handleResult', callbackId, canvas);
 };
 const createForPreview = async (callbackId, width, height) => {
   const canvasId = create$16();
   const canvas = await create2(canvasId, width, height);
-  await invokeAndTransfer$f('Preview.executeCallback', callbackId, canvas, canvasId);
+  await invokeAndTransfer$g('Preview.executeCallback', callbackId, canvas, canvasId);
 };
 
 const name$16 = 'OffscreenCanvas';
@@ -12635,7 +12639,7 @@ const ExtensionHostClosingTagCompletion_ipc = {
 const sendMessagePortToRendererProcess$1 = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$q(initialCommand, port);
+  await invokeAndTransfer$r(initialCommand, port);
 };
 
 const name$W = 'SendMessagePortToRendererProcess';
@@ -12696,14 +12700,42 @@ const launchEditorWorker = async () => {
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
-  await invoke$D(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  await invoke$E(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  return ipc;
+};
+
+const {
+  invoke: invoke$p,
+  invokeAndTransfer: invokeAndTransfer$f} = getOrCreateWorker(launchEditorWorker);
+const actualInvoke = invoke$p;
+
+const authWorkerUrl = `${assetDir}/packages/auth-worker/dist/authWorkerMain.js`;
+
+const launchAuthWorker = async () => {
+  const name = 'Auth Worker';
+  const ipc = await create$17({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl$1('develop.authWorkerPath', authWorkerUrl)
+  });
+  handleIpc(ipc);
   return ipc;
 };
 
 const {
   invoke: invoke$o,
-  invokeAndTransfer: invokeAndTransfer$e} = getOrCreateWorker(launchEditorWorker);
-const actualInvoke = invoke$o;
+  invokeAndTransfer: invokeAndTransfer$e} = getOrCreateWorker(launchAuthWorker);
+const signIn$1 = (backendUrl, platform) => {
+  return invoke$o('Auth.login', {
+    backendUrl,
+    platform
+  });
+};
+const signOut$1 = backendUrl => {
+  return invoke$o('Auth.logout', {
+    backendUrl
+  });
+};
 
 const openerWorkerUrl = `${assetDir}/packages/opener-worker/dist/openerWorkerMain.js`;
 
@@ -12748,7 +12780,7 @@ const launchIframeWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.iframeWorkerPath', iframeWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Iframes.initialize', getPlatform$1());
+  await invoke$E(ipc, 'Iframes.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -12785,7 +12817,7 @@ const launchSourceControlWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.sourceControlWorkerPath', sourceControlWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Initialize.initialize');
+  await invoke$E(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -12823,7 +12855,7 @@ const launchTextSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$D(ipc, 'TextSearch.initialize', getPlatform$1());
+    await invoke$E(ipc, 'TextSearch.initialize', getPlatform$1());
   } catch (error) {
     // ignore
   }
@@ -12927,7 +12959,7 @@ const launchChatToolWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$D(ipc, 'ChatTool.initialize', getPlatform$1());
+    await invoke$E(ipc, 'ChatTool.initialize', getPlatform$1());
   } catch {
     // ignore
   }
@@ -12940,32 +12972,37 @@ const {
 const sendMessagePortToExtensionHostWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$l(initialCommand, port, rpcId);
+  await invokeAndTransfer$m(initialCommand, port, rpcId);
 };
 const sendMessagePortToSharedProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$n(initialCommand, port, rpcId);
+  await invokeAndTransfer$o(initialCommand, port, rpcId);
 };
 const sendMessagePortToTerminalProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$n(initialCommand, port, rpcId);
+  await invokeAndTransfer$o(initialCommand, port, rpcId);
 };
 const sendMessagePortToErrorWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$o(initialCommand, port, rpcId);
+  await invokeAndTransfer$p(initialCommand, port, rpcId);
 };
-const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
+const sendMessagePortToAuthWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
   await invokeAndTransfer$e(initialCommand, port, rpcId);
 };
+const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
+  object(port);
+  string(initialCommand);
+  await invokeAndTransfer$f(initialCommand, port, rpcId);
+};
 const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$q(initialCommand, port, rpcId);
+  await invokeAndTransfer$r(initialCommand, port, rpcId);
 };
 const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12975,7 +13012,7 @@ const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToClipBoardWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$h(initialCommand, port, rpcId);
+  await invokeAndTransfer$i(initialCommand, port, rpcId);
 };
 const sendMessagePortToMainAreaWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12985,12 +13022,12 @@ const sendMessagePortToMainAreaWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToFileSystemWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$i(initialCommand, port, rpcId);
+  await invokeAndTransfer$j(initialCommand, port, rpcId);
 };
 const sendMessagePortToIconThemeWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$j(initialCommand, port, rpcId);
+  await invokeAndTransfer$k(initialCommand, port, rpcId);
 };
 const sendMessagePortToTextMeasurementWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13010,7 +13047,7 @@ const sendMessagePortToSourceControlWorker = async (port, initialCommand, rpcId)
 const sendMessagePortToExtensionManagementWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$m(initialCommand, port, rpcId);
+  await invokeAndTransfer$n(initialCommand, port, rpcId);
 };
 const sendMessagePortToIframeWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13020,7 +13057,7 @@ const sendMessagePortToIframeWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToFileSearchWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$k(initialCommand, port, rpcId);
+  await invokeAndTransfer$l(initialCommand, port, rpcId);
 };
 const sendMessagePortToOpenerWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13067,6 +13104,7 @@ const sendMessagePortToChatToolWorker = async (port, initialCommand, rpcId) => {
 
 const name$U = 'SendMessagePortToExtensionHostWorker';
 const Commands$W = {
+  sendMessagePortToAuthWorker: sendMessagePortToAuthWorker,
   sendMessagePortToChatCoordinatorWorker: sendMessagePortToChatCoordinatorWorker,
   sendMessagePortToChatMathWorker: sendMessagePortToChatMathWorker,
   sendMessagePortToChatMessageParsingWorker: sendMessagePortToChatMessageParsingWorker,
@@ -13167,7 +13205,7 @@ const Transferrable_ipc = {
 };
 
 const getWebViewsNode = async () => {
-  const webViews = await invoke$B('ExtensionHost.getWebViews');
+  const webViews = await invoke$C('ExtensionHost.getWebViews');
   return webViews;
 };
 
@@ -13200,42 +13238,42 @@ getHost().endsWith('.gitpod.io');
 const WebView = 'lvce-oss-webview';
 
 const setPort = async (uid, port, origin, portType) => {
-  await invokeAndTransfer$q('WebView.setPort', uid, port, origin, portType);
+  await invokeAndTransfer$r('WebView.setPort', uid, port, origin, portType);
 };
 
 /**
  * @deprecated
  */
 const getWebViewInfo = providerId => {
-  return invoke$z('ExtensionHostWebView.getWebViewInfo', providerId);
+  return invoke$A('ExtensionHostWebView.getWebViewInfo', providerId);
 };
 const getWebViewInfo2 = providerId => {
-  return invoke$z('ExtensionHostWebView.getWebViewInfo2', providerId);
+  return invoke$A('ExtensionHostWebView.getWebViewInfo2', providerId);
 };
 const getSecret = key => {
   return get$e(key);
 };
 const registerInterceptor = async (id, port) => {
-  await invokeAndTransfer$l('WebView.registerInterceptor', id, port);
+  await invokeAndTransfer$m('WebView.registerInterceptor', id, port);
 };
 const unregisterInterceptor = async id => {
-  await invoke$z('WebView.unregisterInterceptor', id);
+  await invoke$A('WebView.unregisterInterceptor', id);
 };
 const compat = {
   sharedProcessInvoke(...args) {
-    return invoke$B(...args);
+    return invoke$C(...args);
   },
   rendererProcessInvoke(...args) {
-    return invoke$E(...args);
+    return invoke$F(...args);
   },
   rendererProcessInvokeAndTransfer(...args) {
-    return invokeAndTransfer$q(...args);
+    return invokeAndTransfer$r(...args);
   },
   extensionHostWorkerInvokeAndTransfer(...args) {
-    return invokeAndTransfer$l(...args);
+    return invokeAndTransfer$m(...args);
   },
   extensionHostWorkerInvoke(...args) {
-    return invoke$z(...args);
+    return invoke$A(...args);
   },
   getWebViews() {
     return getWebViews();
@@ -13294,7 +13332,7 @@ const getOrCreate$1 = () => {
 };
 const invoke$j = async (method, ...params) => {
   const ipc = await getOrCreate$1();
-  return invoke$D(ipc, method, ...params);
+  return invoke$E(ipc, method, ...params);
 };
 
 const name$P = 'SearchProcess';
@@ -13325,16 +13363,16 @@ const executeTextSearchProvider = async (scheme, query, assetDir, platform) => {
   return result;
 };
 const textSearchHtml = (...args) => {
-  return invoke$z('TextSearchHtml.textSearch', ...args);
+  return invoke$A('TextSearchHtml.textSearch', ...args);
 };
 const textSearchFetch = (...args) => {
-  return invoke$z('TextSearchFetch.textSearch', ...args);
+  return invoke$A('TextSearchFetch.textSearch', ...args);
 };
 const textSearchMemory = (...args) => {
-  return invoke$z('TextSearchMemory.textSearch', ...args);
+  return invoke$A('TextSearchMemory.textSearch', ...args);
 };
 const textSearchMemory2 = (...args) => {
-  return invoke$z('TextSearchMemory.textSearch2', ...args);
+  return invoke$A('TextSearchMemory.textSearch2', ...args);
 };
 
 const name$O = 'ExtensionHostTextSearch';
@@ -13397,14 +13435,14 @@ const handleExtensionStatusUpdate = async () => {
 };
 const invalidateExtensionsCache = async () => {
   try {
-    await invoke$A('Extensions.invalidateExtensionsCache');
+    await invoke$B('Extensions.invalidateExtensionsCache');
     await execute$3('Layout.handleExtensionsChanged');
   } catch {
     // ignore
   }
 };
 const uninstall = async id => {
-  await invoke$B(/* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
+  await invoke$C(/* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
   invalidateExtensionsCache();
 };
 const disable = async id => {
@@ -13412,7 +13450,7 @@ const disable = async id => {
     if (isTest()) {
       disabledIds = [...disabledIds, id];
     } else {
-      await invoke$B(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
+      await invoke$C(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -13425,7 +13463,7 @@ const enable = async id => {
     if (isTest()) {
       disabledIds = disabledIds.filter(existing => existing !== id);
     } else {
-      await invoke$B(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
+      await invoke$C(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -13437,11 +13475,11 @@ const getAllExtensions = async () => {
   if (getPlatform$1() === Web$1) {
     return [];
   }
-  return invoke$B(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+  return invoke$C(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
 };
 let disabledIds = [];
 const getExtension2 = async id => {
-  const extension = await invoke$z('Extensions.getExtension', id);
+  const extension = await invoke$A('Extensions.getExtension', id);
   if (disabledIds.includes(id)) {
     return {
       ...extension,
@@ -13452,7 +13490,7 @@ const getExtension2 = async id => {
   return extension;
 };
 const getExtensionsEtag = async () => {
-  const etag = await invoke$B('ExtensionManagement.getExtensionsEtag');
+  const etag = await invoke$C('ExtensionManagement.getExtensionsEtag');
   return etag;
 };
 
@@ -13495,10 +13533,10 @@ const Markdown_ipc = {
 };
 
 const measureTextHeight = (text, fontFamily, fontSize) => {
-  return invoke$E('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
+  return invoke$F('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
 };
 const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke$E('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+  return invoke$F('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
 };
 
 const name$I = 'MeasureTextHeight';
@@ -13523,10 +13561,10 @@ const loadContent$O = async state => {
   const {
     id
   } = state;
-  await invoke$u('About.create', id);
-  await invoke$u('About.loadContent2', id);
-  const diffResult = await invoke$u('About.diff2', id);
-  const commands = await invoke$u('About.render2', id, diffResult);
+  await invoke$v('About.create', id);
+  await invoke$v('About.loadContent2', id);
+  const diffResult = await invoke$v('About.diff2', id);
+  const commands = await invoke$v('About.render2', id, diffResult);
   return {
     ...state,
     commands
@@ -13535,9 +13573,9 @@ const loadContent$O = async state => {
 
 const wrapAboutCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$u(`About.${key}`, state.id, ...args);
-    const diffResult = await invoke$u(`About.diff2`, state.id);
-    const commands = await invoke$u('About.render2', state.id, diffResult);
+    await invoke$v(`About.${key}`, state.id, ...args);
+    const diffResult = await invoke$v(`About.diff2`, state.id);
+    const commands = await invoke$v('About.render2', state.id, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -13551,7 +13589,7 @@ const wrapAboutCommand = key => {
 
 const Commands$J = {};
 const getCommands$n = async () => {
-  const commands = await invoke$u('About.getCommandIds');
+  const commands = await invoke$v('About.getCommandIds');
   for (const command of commands) {
     if (command === 'showAbout' || command === 'showAboutElectron') {
       continue;
@@ -13564,7 +13602,7 @@ const getCommands$n = async () => {
 const Css$J = ["/css/parts/ViewletAbout.css"];
 
 const getKeyBindings$n = () => {
-  return invoke$u('About.getKeyBindings');
+  return invoke$v('About.getKeyBindings');
 };
 
 const name$H = 'About';
@@ -13632,7 +13670,7 @@ const renderDialog$4 = {
 };
 const render$K = [renderDialog$4];
 const renderEventListeners$o = async () => {
-  const listeners = await invoke$u('About.renderEventListeners');
+  const listeners = await invoke$v('About.renderEventListeners');
   return listeners;
 };
 
@@ -14144,7 +14182,7 @@ const create$Q = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$L = async state => {
-  const browserViewMap = await invoke$B('ElectronBrowserView.getAll');
+  const browserViewMap = await invoke$C('ElectronBrowserView.getAll');
   return {
     ...state,
     browserViewMap
@@ -14498,7 +14536,7 @@ const create$N = (id, uri, x, y, width, height) => {
 };
 const loadContent$I = state => {
   const update = async () => {
-    await invoke$E(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$F(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -16289,12 +16327,12 @@ const ViewletLanguageModels_ipc = {
 
 const wrapPreviewCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$p(`Preview.${key}`, state.uid, ...args);
-    const diffResult = await invoke$p('Preview.diff2', state.uid);
+    await invoke$q(`Preview.${key}`, state.uid, ...args);
+    const diffResult = await invoke$q('Preview.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$p('Preview.render2', state.uid, diffResult);
+    const commands = await invoke$q('Preview.render2', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -16323,10 +16361,10 @@ const loadContent$A = async state => {
   const layoutState = getState$1(Layout);
   const uri = layoutState.previewUri || state.uri;
   const savedState = {};
-  await invoke$p('Preview.create', state.uid, uri, state.x, state.y, state.width, state.height);
-  await invoke$p('Preview.loadContent', state.uid, savedState);
-  const diffResult = await invoke$p('Preview.diff2', state.uid);
-  const commands = await invoke$p('Preview.render2', state.uid, diffResult);
+  await invoke$q('Preview.create', state.uid, uri, state.x, state.y, state.width, state.height);
+  await invoke$q('Preview.loadContent', state.uid, savedState);
+  const diffResult = await invoke$q('Preview.diff2', state.uid);
+  const commands = await invoke$q('Preview.render2', state.uid, diffResult);
   return {
     ...state,
     uri,
@@ -16345,7 +16383,7 @@ const decrement = state => {
     count: state.count - 1
   };
 };
-const renderEventListeners$j = () => invoke$p('Preview.renderEventListeners');
+const renderEventListeners$j = () => invoke$q('Preview.renderEventListeners');
 const dispose$n = state => {
   return {
     ...state,
@@ -16360,12 +16398,12 @@ const hotReload$f = 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$p('Preview.saveState', state.uid);
+  const savedState = await invoke$q('Preview.saveState', state.uid);
   await restart$g('Preview.terminate');
-  await invoke$p('Preview.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null);
-  await invoke$p('Preview.loadContent', state.uid, savedState);
-  const diffResult = await invoke$p('Preview.diff2', state.uid);
-  const commands = await invoke$p('Preview.render2', state.uid, diffResult);
+  await invoke$q('Preview.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null);
+  await invoke$q('Preview.loadContent', state.uid, savedState);
+  const diffResult = await invoke$q('Preview.diff2', state.uid);
+  const commands = await invoke$q('Preview.render2', state.uid, diffResult);
   state.isHotReloading = false;
   return {
     ...state,
@@ -16374,7 +16412,7 @@ const hotReload$f = async state => {
 };
 const Commands$w = {};
 const getCommands$i = async () => {
-  const commands = await invoke$p('Preview.getCommandIds');
+  const commands = await invoke$q('Preview.getCommandIds');
   for (const command of commands) {
     Commands$w[command] = wrapPreviewCommand(command);
   }
@@ -16418,7 +16456,7 @@ const ViewletPreview_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$B('GetTerminalSpawnOptions.getTerminalSpawnOptions');
+  return invoke$C('GetTerminalSpawnOptions.getTerminalSpawnOptions');
 };
 
 // TODO implement a functional terminal component, maybe using offscreencanvas
@@ -16447,16 +16485,16 @@ const loadContent$z = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$16();
   const canvasCursorId = create$16();
-  await invoke$q('Terminal.create', canvasTextId, canvasCursorId, uid, state$o.workspacePath, command, args);
+  await invoke$r('Terminal.create', canvasTextId, canvasCursorId, uid, state$o.workspacePath, command, args);
   const terminal = {
     handleBlur() {
-      return invoke$q('Terminal.handleBlur', uid);
+      return invoke$r('Terminal.handleBlur', uid);
     },
     handleKeyDown(key) {
-      return invoke$q('Terminal.handleKeyDown', uid, key);
+      return invoke$r('Terminal.handleKeyDown', uid, key);
     },
     handleMouseDown() {
-      return invoke$q('Terminal.handleMouseDown', uid);
+      return invoke$r('Terminal.handleMouseDown', uid);
     },
     resize() {
       // TODO
@@ -16533,7 +16571,7 @@ const resizeEffect$2 = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear$2 = async state => {
-  await invoke$E(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$F(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 const Commands$v = {
@@ -16593,8 +16631,8 @@ const create$A = (id, uri, x, y, width, height) => {
   };
 };
 const getTests = async () => {
-  const root = await invoke$B('Platform.getRoot');
-  const testPath = await invoke$B('Platform.getTestPath');
+  const root = await invoke$C('Platform.getRoot');
+  const testPath = await invoke$C('Platform.getTestPath');
   const absolutePath = `${root}/${testPath}/src`;
   const dirents = await readDirWithFileTypes$9(absolutePath);
   const filteredDirents = dirents.slice(1);
@@ -17377,7 +17415,7 @@ const Commands$t = {
   ...wrapEditorCommands(ids),
   // TODO
   async showOverlayMessage(state, editor, ...args) {
-    await invoke$E(...args);
+    await invoke$F(...args);
     return state;
   },
   async hotReload(state, editor, ...args) {
@@ -17654,7 +17692,7 @@ const launchExplorerWorker = async () => {
     name: 'Explorer Worker'
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Explorer.initialize');
+  await invoke$E(ipc, 'Explorer.initialize');
   return ipc;
 };
 
@@ -17904,7 +17942,7 @@ const launchExtensionDetailViewWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.extensionDetailViewWorkerPath', extensionDetailViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'ExtensionDetail.initialize');
+  await invoke$E(ipc, 'ExtensionDetail.initialize');
   return ipc;
 };
 
@@ -18076,7 +18114,7 @@ const launchExtensionSearchViewWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$D(ipc, 'SearchExtensions.initialize');
+    await invoke$E(ipc, 'SearchExtensions.initialize');
   } catch {
     // ignore
   }
@@ -18453,7 +18491,7 @@ const launchReferencesWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.referencesWorkerPath', referencesWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'References.initialize');
+  await invoke$E(ipc, 'References.initialize');
   return ipc;
 };
 
@@ -19112,7 +19150,7 @@ const ViewletKeyBindings_ipc = {
   saveState: saveState$a
 };
 
-const commit = 'c0b16fe';
+const commit = '9d77d9c';
 
 const getDefaultTitleBarHeight = () => {
   switch (getPlatform$1()) {
@@ -19638,6 +19676,23 @@ const getPoints = (source, sideBarLocation = Right) => {
 const getInitialBackendUrl = () => {
   return get$e('layout.backendUrl') || getBackendUrl$1();
 };
+const getDefaultAuthState = () => {
+  return {
+    authAccessToken: '',
+    authErrorMessage: '',
+    userName: '',
+    userState: 'loggedOut',
+    userSubscriptionPlan: '',
+    userUsedTokens: 0
+  };
+};
+const toAuthState = state => {
+  return {
+    accessToken: state.authAccessToken,
+    signInState: state.userState,
+    userName: state.userName
+  };
+};
 const create$m = id => {
   number(id);
   return {
@@ -19675,6 +19730,7 @@ const create$m = id => {
     activityBarLeft: 0,
     activityBarTop: 0,
     activityBarWidth: 0,
+    ...getDefaultAuthState(),
     mainHeight: 0,
     mainLeft: 0,
     mainTop: 0,
@@ -20575,7 +20631,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$E('Viewlet.sendMultiple', commands);
+    await invoke$F('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -20834,6 +20890,34 @@ const getAssetDir = state => {
 const getBackendUrl = state => {
   return state.backendUrl;
 };
+const getAuthState = state => {
+  return toAuthState(state);
+};
+const mergeAuthState = (state, authState) => {
+  return {
+    ...state,
+    authAccessToken: typeof authState?.authAccessToken === 'string' ? authState.authAccessToken : state.authAccessToken,
+    authErrorMessage: typeof authState?.authErrorMessage === 'string' ? authState.authErrorMessage : state.authErrorMessage,
+    userName: typeof authState?.userName === 'string' ? authState.userName : state.userName,
+    userState: typeof authState?.userState === 'string' ? authState.userState : state.userState,
+    userSubscriptionPlan: typeof authState?.userSubscriptionPlan === 'string' ? authState.userSubscriptionPlan : state.userSubscriptionPlan,
+    userUsedTokens: typeof authState?.userUsedTokens === 'number' ? authState.userUsedTokens : state.userUsedTokens
+  };
+};
+const signIn = async state => {
+  const authState = await signIn$1(state.backendUrl, state.platform);
+  return {
+    newState: mergeAuthState(state, authState),
+    commands: []
+  };
+};
+const signOut = async state => {
+  const authState = await signOut$1(state.backendUrl);
+  return {
+    newState: mergeAuthState(state, authState),
+    commands: []
+  };
+};
 const setUpdateState = async (state, updateState) => {
   if (state.updateState === updateState.state && state.updateProgress === updateState.progress) {
     return {
@@ -20937,6 +21021,7 @@ const Commands$k = {
   getCommit: getCommit,
   getPlatform: getPlatform,
   getAssetDir: getAssetDir,
+  getAuthState: getAuthState,
   getBackendUrl: getBackendUrl,
   getBadgeCounts: getBadgeCounts,
   getHref: getHref,
@@ -20980,6 +21065,8 @@ const CommandsWithSideEffects = {
   openSecondarySideBarViewlet: openSecondarySideBarView,
   openPanelViewlet: openPanelView,
   setUpdateState: setUpdateState,
+  signIn: signIn,
+  signOut: signOut,
   showActivityBar: showActivityBar,
   showE2eTests: showE2eTests,
   showMain: showMain,
@@ -21899,6 +21986,7 @@ const ViewletLayout_ipc = {
   getActiveSideBarView,
   getAllQuickPickMenuEntries,
   getAssetDir,
+  getAuthState,
   getBackendUrl,
   getBadgeCounts,
   getCommit,
@@ -21965,6 +22053,8 @@ const ViewletLayout_ipc = {
   showSideBar,
   showStatusBar,
   showTitleBar,
+  signIn,
+  signOut,
   toggleActivityBar,
   toggleMain,
   togglePanel,
@@ -22611,7 +22701,7 @@ const create$k = (id, uri, x, y, width, height) => {
 };
 const loadContent$k = state => {
   const update = async () => {
-    await invoke$E(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$F(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -22675,7 +22765,7 @@ const launchOutputViewWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.outputViewWorkerPath', outputViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Output.initialize');
+  await invoke$E(ipc, 'Output.initialize');
   return ipc;
 };
 
@@ -22968,7 +23058,7 @@ const launchProblemsWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.problemsWorkerPath', problemsViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Problems.initialize');
+  await invoke$E(ipc, 'Problems.initialize');
   return ipc;
 };
 
@@ -23219,10 +23309,10 @@ const loadContent$f = async state => {
   } = state;
   const listItemHeight = 22;
   const renderAllItems = true;
-  await invoke$y('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$o.workspacePath, assetDir);
-  await invoke$y('QuickPick.loadContent', state.uid);
-  const diffResult = await invoke$y('QuickPick.diff2', state.uid);
-  const commands = await invoke$y('QuickPick.render2', state.uid, diffResult);
+  await invoke$z('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$o.workspacePath, assetDir);
+  await invoke$z('QuickPick.loadContent', state.uid);
+  const diffResult = await invoke$z('QuickPick.diff2', state.uid);
+  const commands = await invoke$z('QuickPick.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -23234,12 +23324,12 @@ const dispose$c = state => {
 
 const wrapQuickPickCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$y(`QuickPick.${key}`, state.uid, ...args);
-    const diffResult = await invoke$y('QuickPick.diff2', state.uid);
+    await invoke$z(`QuickPick.${key}`, state.uid, ...args);
+    const diffResult = await invoke$z('QuickPick.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$y('QuickPick.render2', state.uid, diffResult);
+    const commands = await invoke$z('QuickPick.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -23250,7 +23340,7 @@ const wrapQuickPickCommand = key => {
 
 const Commands$d = {};
 const getCommands$8 = async () => {
-  const commands = await invoke$y('QuickPick.getCommandIds');
+  const commands = await invoke$z('QuickPick.getCommandIds');
   for (const command of commands) {
     Commands$d[command] = wrapQuickPickCommand(command);
   }
@@ -23264,7 +23354,7 @@ const Css$f = [];
 const Variables$3 = ['QuickPickBackground', 'ListForeground', 'ListHoverBackground', 'ListHoverForeground', 'ListActiveSelectionBackground'];
 
 const getKeyBindings$6 = () => {
-  return invoke$y('QuickPick.getKeyBindings');
+  return invoke$z('QuickPick.getKeyBindings');
 };
 
 const hasFunctionalRender$e = true;
@@ -23279,7 +23369,7 @@ const renderItems$6 = {
 };
 const render$e = [renderItems$6];
 const renderEventListeners$7 = async () => {
-  const listeners = await invoke$y('QuickPick.renderEventListeners');
+  const listeners = await invoke$z('QuickPick.renderEventListeners');
   return listeners;
 };
 
@@ -23471,11 +23561,11 @@ const create$d = (id, uri, x, y, width, height, args, parentUid) => {
 };
 const loadContent$d = async (state, savedState) => {
   const isTest$1 = isTest();
-  await invoke$v('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$v('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
-  const diffResult = await invoke$v('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$v('RunAndDebug.render2', state.uid, diffResult);
-  const actionsDom = await invoke$v('RunAndDebug.renderActions', state.uid);
+  await invoke$w('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$w('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
+  const diffResult = await invoke$w('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$w('RunAndDebug.render2', state.uid, diffResult);
+  const actionsDom = await invoke$w('RunAndDebug.renderActions', state.uid);
   const debugId = isTest$1 ? 'test-debug' : 'node-debug'; // TODO
   return {
     ...state,
@@ -23496,17 +23586,17 @@ const hotReload$5 = 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$v('RunAndDebug.saveState', state.uid);
+  const savedState = await invoke$w('RunAndDebug.saveState', state.uid);
   await restart$h('RunAndDebug.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$v('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
-  await invoke$v('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
-  await invoke$v('RunAndDebug.loadContentLater', state.uid);
-  const diffResult = await invoke$v('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$v('RunAndDebug.render2', state.uid, diffResult);
+  await invoke$w('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$w('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
+  await invoke$w('RunAndDebug.loadContentLater', state.uid);
+  const diffResult = await invoke$w('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$w('RunAndDebug.render2', state.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -23561,19 +23651,19 @@ const resize$b = (state, dimensions) => {
   };
 };
 const saveState$3 = async state => {
-  const savedState = await invoke$v('RunAndDebug.saveState', state.uid);
+  const savedState = await invoke$w('RunAndDebug.saveState', state.uid);
   return savedState;
 };
 
 const wrapRunAndDebugCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$v(`RunAndDebug.${key}`, state.uid, ...args);
-    const diffResult = await invoke$v('RunAndDebug.diff2', state.uid);
+    await invoke$w(`RunAndDebug.${key}`, state.uid, ...args);
+    const diffResult = await invoke$w('RunAndDebug.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$v('RunAndDebug.render2', state.uid, diffResult);
-    const actionsDom = await invoke$v('RunAndDebug.renderActions', state.uid);
+    const commands = await invoke$w('RunAndDebug.render2', state.uid, diffResult);
+    const actionsDom = await invoke$w('RunAndDebug.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -23590,7 +23680,7 @@ const wrapRunAndDebugCommand = key => {
 
 const Commands$b = {};
 const getCommands$6 = async () => {
-  const commands = await invoke$v('RunAndDebug.getCommandIds');
+  const commands = await invoke$w('RunAndDebug.getCommandIds');
   for (const command of commands) {
     Commands$b[command] = wrapRunAndDebugCommand(command);
   }
@@ -23604,13 +23694,13 @@ const Variables$2 = ['TitleBarForeground', 'DebugSectionHeaderBackground', 'Side
 const Events$2 = {};
 
 const getKeyBindings$5 = () => {
-  return invoke$v('RunAndDebug.getKeyBindings');
+  return invoke$w('RunAndDebug.getKeyBindings');
 };
 
 const menus$5 = [];
 const getMenus$4 = async () => {
   try {
-    const modules = await invoke$v('RunAndDebug.getMenuEntries');
+    const modules = await invoke$w('RunAndDebug.getMenuEntries');
     const adjusted = modules.map(module => {
       return {
         ...module,
@@ -23637,7 +23727,7 @@ const renderItems$5 = {
 };
 const render$d = [renderItems$5];
 const renderEventListeners$6 = async () => {
-  const listeners = await invoke$v('RunAndDebug.renderEventListeners');
+  const listeners = await invoke$w('RunAndDebug.renderEventListeners');
   return listeners;
 };
 
@@ -23683,18 +23773,18 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async options => {
-  const sources = await invoke$B('DesktopCapturer.getSources', options);
+  const sources = await invoke$C('DesktopCapturer.getSources', options);
   return sources;
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$E('ScreenCapture.start', captureId, options);
+  await invoke$F('ScreenCapture.start', captureId, options);
 };
 const dispose$9 = async captureId => {
   number(captureId);
-  await invoke$E('ScreenCapture.dispose', captureId);
+  await invoke$F('ScreenCapture.dispose', captureId);
 };
 
 const createScreenCaptureStream = async captureId => {
@@ -23963,7 +24053,7 @@ const launchSettingsWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.settingsWorkerPath', settingsWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Initialize.initialize');
+  await invoke$E(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -24283,7 +24373,7 @@ const handleSideBarViewletChange = async (state, moduleId) => {
     const events = commands[eventsIndex][2];
     actionsUid = create$16();
     commands.push(['Viewlet.createFunctionalRoot', moduleId, actionsUid, true], ['Viewlet.registerEventListeners', actionsUid, events], ['Viewlet.setDom2', actionsUid, actionsDom], ['Viewlet.setUid', actionsUid, childUid]);
-    await invoke$E('Viewlet.sendMultiple', commands);
+    await invoke$F('Viewlet.sendMultiple', commands);
   }
 
   // TODO race condition (check if disposed after created)
@@ -24519,7 +24609,7 @@ const handleSecondarySideBarViewletChange = async (state, moduleId) => {
     uid: childUid,
     shouldRenderEvents: false
   }, false, true);
-  await invoke$E('Viewlet.sendMultiple', commands);
+  await invoke$F('Viewlet.sendMultiple', commands);
   await savePromise;
   return {
     ...state,
@@ -24659,7 +24749,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'Initialize.initialize');
+  await invoke$E(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -24686,7 +24776,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$B('ElectronWindow.getZoom', windowId);
+  const zoomLevel = await invoke$C('ElectronWindow.getZoom', windowId);
   return zoomLevel;
 };
 
@@ -25746,7 +25836,7 @@ const launchStatusBarWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.statusBarWorkerPath', statusBarWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$D(ipc, 'StatusBar.initialize');
+  await invoke$E(ipc, 'StatusBar.initialize');
   return ipc;
 };
 
@@ -26004,16 +26094,16 @@ const loadContent$3 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$16();
   const canvasCursorId = create$16();
-  await invoke$q('Terminal.create', canvasTextId, canvasCursorId, uid, state$o.workspacePath, command, args);
+  await invoke$r('Terminal.create', canvasTextId, canvasCursorId, uid, state$o.workspacePath, command, args);
   const terminal = {
     handleBlur() {
-      return invoke$q('Terminal.handleBlur', uid);
+      return invoke$r('Terminal.handleBlur', uid);
     },
     handleKeyDown(key) {
-      return invoke$q('Terminal.handleKeyDown', uid, key);
+      return invoke$r('Terminal.handleKeyDown', uid, key);
     },
     handleMouseDown() {
-      return invoke$q('Terminal.handleMouseDown', uid);
+      return invoke$r('Terminal.handleMouseDown', uid);
     },
     resize() {
       // TODO
@@ -26090,7 +26180,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$E(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$F(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 /**
@@ -26254,7 +26344,7 @@ const addTerminal = async state => {
   await createViewlet(state, childUid);
   if (oldChildUid !== -1) {
     const disposeCommands = disposeFunctional(oldChildUid);
-    await invoke$E('Viewlet.sendMultiple', disposeCommands);
+    await invoke$F('Viewlet.sendMultiple', disposeCommands);
   }
   return {
     ...state,
@@ -26279,7 +26369,7 @@ const focusIndex = async (state, index) => {
   await createViewlet(state, childUid);
   if (oldChildUid !== -1) {
     const disposeCommands = disposeFunctional(oldChildUid);
-    await invoke$E('Viewlet.sendMultiple', disposeCommands);
+    await invoke$F('Viewlet.sendMultiple', disposeCommands);
   }
   return {
     ...state,
@@ -26630,7 +26720,7 @@ const getRealUri = pathOrUri => {
   if (protocol) {
     return pathOrUri;
   }
-  return invoke$B('FileSystem.getRealUri', pathOrUri);
+  return invoke$C('FileSystem.getRealUri', pathOrUri);
 };
 
 const create = (id, uri, x, y, width, height) => {
@@ -26976,7 +27066,7 @@ const getItem = (items, label) => {
 const openContextMenu = async (x, y, id, ...args) => {
   const entries = await getMenuEntries$3(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$B('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$C('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -26990,7 +27080,7 @@ const openContextMenu = async (x, y, id, ...args) => {
 const openContextMenu2 = async (x, y, uid, menuId, ...args) => {
   const entries = await getMenuEntries2(uid, menuId, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$B('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$C('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -27040,7 +27130,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$B('ElectronWindowProcessExplorer.open');
+    await invoke$C('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, 'Failed to open process explorer');
   }