@lvce-editor/static-server 0.69.5 → 0.70.1

package/static/{5bdc1ac → 6e66e1c}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -99,19 +99,19 @@ const Test$1 = 4;
 /**
  * @returns {number}
  */
-const getPlatform = () => {
+const getPlatform$1 = () => {
   return platform;
 };
 const platform = Remote;
 
-const getAssetDir = () => {
+const getAssetDir$1 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/5bdc1ac';
+    return '/6e66e1c';
   }
 };
-const assetDir = getAssetDir();
+const assetDir = getAssetDir$1();
 
 const NotFound = 404;
 
@@ -432,10 +432,10 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const invoke$w = (ipc, method, ...params) => {
+const invoke$x = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$d = (ipc, method, ...params) => {
+const invokeAndTransfer$e = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -1091,11 +1091,11 @@ const listen$1 = async () => {
   handleIpc(ipc);
   state$D.ipc = ipc;
 };
-const invoke$v = (method, ...params) => {
-  return invoke$w(state$D.ipc, method, ...params);
+const invoke$w = (method, ...params) => {
+  return invoke$x(state$D.ipc, method, ...params);
 };
-const invokeAndTransfer$c = (method, ...params) => {
-  return invokeAndTransfer$d(state$D.ipc, method, ...params);
+const invokeAndTransfer$d = (method, ...params) => {
+  return invokeAndTransfer$e(state$D.ipc, method, ...params);
 };
 
 const actuallyLoadCssStyleSheet = async css => {
@@ -1113,7 +1113,7 @@ const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
 };
 const addCssStyleSheet = (id, css) => {
-  return invoke$v('Css.addCssStyleSheet', id, css);
+  return invoke$w('Css.addCssStyleSheet', id, css);
 };
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
   const css = await getCss(preferences);
@@ -1137,11 +1137,11 @@ const getOrCreateWorker = fn => {
   return {
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invoke$w(ipc, method, ...params);
+      return invoke$x(ipc, method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invokeAndTransfer$d(ipc, method, ...params);
+      return invokeAndTransfer$e(ipc, method, ...params);
     },
     async dispose() {
       const promise = workers.get(fn);
@@ -1252,8 +1252,8 @@ const launchErrorWorker = async () => {
 };
 
 const {
-  invoke: invoke$u,
-  invokeAndTransfer: invokeAndTransfer$b
+  invoke: invoke$v,
+  invokeAndTransfer: invokeAndTransfer$c
 } = getOrCreateWorker(launchErrorWorker);
 
 const serializeError = error => {
@@ -1274,14 +1274,14 @@ const serializeError = error => {
 const prepare = async error => {
   try {
     const serialized = serializeError(error);
-    const prepared = await invoke$u('Errors.prepare', serialized);
+    const prepared = await invoke$v('Errors.prepare', serialized);
     return prepared;
   } catch {
     return error;
   }
 };
 const print = async (error, prefix = '') => {
-  await invoke$u('Errors.print', error, prefix);
+  await invoke$v('Errors.print', error, prefix);
 };
 const getMessage$3 = error => {
   if (error && error.type && error.message) {
@@ -1322,214 +1322,7 @@ const showErrorDialog = async error => {
   }
 };
 
-const extensionHostWorkerUrl = `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/extension-host-worker/dist/extensionHostWorkerMain.js`;
-
-// TODO global event bus is probably a bad idea
-// cons:
-// 1. it is not typesafe
-// 2. dependencies are unclear
-//
-// pros
-// 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
-
-// TODO use normal event target
-const state$B = {
-  listenerMap: Object.create(null)
-};
-const emitEvent = async (event, ...args) => {
-  const listeners = state$B.listenerMap[event] || [];
-  for (const listener of listeners) {
-    await listener(...args);
-  }
-};
-const addListener = (event, fn, options = {}) => {
-  state$B.listenerMap[event] ||= [];
-  if (state$B.listenerMap[event].includes(fn)) {
-    return;
-  }
-  if (options.prepend) {
-    state$B.listenerMap[event].unshift(fn);
-  } else {
-    state$B.listenerMap[event].push(fn);
-  }
-};
-
-const state$A = {
-  id: 0
-};
-const create$$ = () => {
-  return ++state$A.id;
-};
-
-const ModuleWorkerWithMessagePort = 4;
-const Electron = 5;
-
-const getPortTuple = initialPort => {
-  if (initialPort) {
-    return {
-      port1: undefined,
-      port2: initialPort
-    };
-  }
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-
-const transferrables = [];
-if (typeof OffscreenCanvas !== 'undefined') {
-  transferrables.push(OffscreenCanvas);
-}
-if (typeof MessagePort !== 'undefined') {
-  transferrables.push(MessagePort);
-}
-
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (value instanceof fn) {
-      return true;
-    }
-  }
-  return false;
-};
-
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-
-const create$_ = async ({
-  url,
-  name,
-  port,
-  id
-}) => {
-  // TODO no need to create port if worker
-  // has been prelaunched in renderer process
-  const {
-    port1,
-    port2
-  } = getPortTuple(port);
-  await invokeAndTransfer$c('IpcParent.create', {
-    method: ModuleWorkerWithMessagePort,
-    url,
-    name,
-    raw: true,
-    port: port2,
-    id
-  });
-  return port1;
-};
-
-// TODO why are some events not instance of message event?
-
-const getData$1 = event => {
-  if (event instanceof MessageEvent) {
-    return event.data;
-  }
-  return event;
-};
-const wrap$7 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      const wrappedListener = event => {
-        const data = getData$1(event);
-        const syntheticEvent = {
-          data,
-          target: this
-        };
-        listener(syntheticEvent);
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message) {
-      const transfer = getTransferrables(message);
-      this.port.postMessage(message, transfer);
-    },
-    dispose() {
-      this.port.postMessage({
-        jsonrpc: '2.0',
-        method: 'Exit.exit',
-        params: []
-      });
-      this.port.close();
-    }
-  };
-};
-
-const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
-  __proto__: null,
-  create: create$_,
-  wrap: wrap$7
-};
-
-const state$z = {
-  shouldLaunchMultipleWorkers: false
-};
-const setConfig = shouldLaunchMultipleWorkers => {
-  state$z.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
-};
-const getConfig = () => {
-  return state$z.shouldLaunchMultipleWorkers;
-};
-
-const objects = Object.create(null);
-const transferToRendererProcess = async (objectId, transferable) => {
-  await invokeAndTransfer$c('Transferrable.transfer', transferable, objectId);
-};
-const transfer = (objectId, transferable) => {
-  number(objectId);
-  object(transferable);
-  objects[objectId] = transferable;
-};
-const acquire = objectId => {
-  number(objectId);
-  const value = objects[objectId];
-  if (!value) {
-    throw new Error(`transferrable object not found`);
-  }
-  delete objects[objectId];
-  return value;
-};
+const extensionManagementWorkerUrl = `${assetDir}/packages/extension-management-worker/dist/extensionManagementWorkerMain.js`;
 
 const Utf8 = 'utf8';
 
@@ -1739,13 +1532,41 @@ const canBeRestored$6 = async uri => {
   return fileSystem.canBeRestored;
 };
 
-const Slash = Slash$1;
+// TODO global event bus is probably a bad idea
+// cons:
+// 1. it is not typesafe
+// 2. dependencies are unclear
+//
+// pros
+// 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
-const state$y = {
+// TODO use normal event target
+const state$B = {
+  listenerMap: Object.create(null)
+};
+const emitEvent = async (event, ...args) => {
+  const listeners = state$B.listenerMap[event] || [];
+  for (const listener of listeners) {
+    await listener(...args);
+  }
+};
+const addListener = (event, fn, options = {}) => {
+  state$B.listenerMap[event] ||= [];
+  if (state$B.listenerMap[event].includes(fn)) {
+    return;
+  }
+  if (options.prepend) {
+    state$B.listenerMap[event].unshift(fn);
+  } else {
+    state$B.listenerMap[event].push(fn);
+  }
+};
+
+const state$A = {
   isTest: false
 };
 const isTest = () => {
-  return state$y.isTest;
+  return state$A.isTest;
 };
 
 const stringify = value => {
@@ -1770,7 +1591,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$3(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$x = {
+const state$z = {
   /**
    * @type {any}
    */
@@ -1778,18 +1599,18 @@ const state$x = {
 };
 
 /* istanbul ignore file */
-const invoke$t = async (method, ...params) => {
+const invoke$u = async (method, ...params) => {
   const {
     ipc
-  } = state$x;
-  const result = await invoke$w(ipc, method, ...params);
+  } = state$z;
+  const result = await invoke$x(ipc, method, ...params);
   return result;
 };
-const invokeAndTransfer$a = async (method, ...params) => {
+const invokeAndTransfer$b = async (method, ...params) => {
   const {
     ipc
-  } = state$x;
-  const result = await invokeAndTransfer$d(ipc, method, ...params);
+  } = state$z;
+  const result = await invokeAndTransfer$e(ipc, method, ...params);
   return result;
 };
 
@@ -1815,7 +1636,7 @@ const openKeyBindingsJson = async () => {
 // TODO command for opening workspace settings
 
 const getPreferencesJson = async () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     const cachedPreferences = await execute$3(/* LocalStorage.getJson */'LocalStorage.getJson', /* key */'settings');
     if (cachedPreferences) {
       return cachedPreferences;
@@ -1823,7 +1644,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$3(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$t(PreferencesGetAll);
+  return invoke$u(PreferencesGetAll);
 };
 const getPreferences = async () => {
   // TODO cache preferences, but they should not be stale
@@ -1851,7 +1672,7 @@ const getAll$2 = () => {
 };
 const set$g = async (key, value) => {
   set$h(key, value);
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     const preferences = {
       ...getAll$3(),
       [key]: value
@@ -1875,230 +1696,34 @@ const update$1 = async settings => {
   await emitEvent('preferences.changed');
 };
 
-const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$t(/* Workspace.resolveRoot */WorkspaceResolveRoot);
-  return resolvedRoot;
-};
-const isValid$1 = resolvedRoot => {
-  return resolvedRoot && typeof resolvedRoot.path === 'string' && typeof resolvedRoot.uri === 'string' && typeof resolvedRoot.homeDir === 'string' && typeof resolvedRoot.pathSeparator === 'string';
-};
-const getResolveRootFromSessionStorage = async () => {
-  const resolvedRoot = await execute$3(/* SessionStorage.getJson */'SessionStorage.getJson', /* key */'workspace');
-  if (!isValid$1(resolvedRoot)) {
-    return undefined;
-  }
-  return resolvedRoot;
-};
-const getResolvedRootFromRendererProcess = async href => {
-  const url = new URL(href);
-  if (href.includes('tests/')) {
-    state$y.isTest = true;
-    return {
-      path: href,
-      homeDir: '',
-      pathSeparator: Slash,
-      source: 'test'
-    };
-  }
-  if (url.pathname.startsWith('/github')) {
-    const path = `github://${url.pathname.slice('/github'.length + 1)}`;
-    return {
-      path,
-      homeDir: '',
-      pathSeparator: Slash,
-      source: 'renderer-process'
-    };
-  }
-  if (getPlatform() === Web$1) {
-    const defaultWorkspace = get$e('workspace.defaultWorkspace');
-    const resolvedRoot = {
-      path: defaultWorkspace,
-      homeDir: '',
-      pathSeparator: Slash,
-      source: 'renderer-process'
-    };
-    return resolvedRoot;
-  }
-  const resolvedRootFromSessionStorage = await getResolveRootFromSessionStorage();
-  if (resolvedRootFromSessionStorage) {
-    return resolvedRootFromSessionStorage;
-  }
-  return undefined;
-};
-const getResolvedRootRemote = async href => {
-  const resolvedRootFromRendererProcess = await getResolvedRootFromRendererProcess(href);
-  if (resolvedRootFromRendererProcess) {
-    return resolvedRootFromRendererProcess;
-  }
-  return getResolvedRootFromSharedProcess();
-};
-const getResolvedRoot = async href => {
-  switch (getPlatform()) {
-    case Web$1:
-      return getResolvedRootFromRendererProcess(href);
-    default:
-      return getResolvedRootRemote(href);
-  }
-};
-
-const getHref = () => {
-  return invoke$v(/* Location.getHref */'Location.getHref');
-};
-const setPathName = pathName => {
-  return invoke$v(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
-};
-const hydrate$a = () => {
-  return invoke$v(/* Location.hydrate */'Location.hydrate');
-};
-const getHost = () => {
-  return location.host;
-};
-
-const set$f = title => {
-  return invoke$v('WindowTitle.set', title);
-};
-
-const state$w = {
-  workspacePath: '',
-  homeDir: '',
-  pathSeparator: '',
-  workspaceUri: '',
-  source: ''};
-
-/**
- * @param {string|undefined} path
- */
-const setPath = async path => {
-  string(path);
-  // TODO not in electron
-  const pathSeparator = await getPathSeparator$9(path);
-  // @ts-ignore
-  state$w.workspacePath = path;
-  // @ts-ignore
-  state$w.workspaceUri = path;
-  state$w.pathSeparator = pathSeparator;
-  await onWorkspaceChange();
-};
-const setUri = async uri => {
-  const path = uri.slice('file://'.length);
-  state$w.workspacePath = path;
-  state$w.workspaceUri = uri;
-  await onWorkspaceChange();
-};
-const getPath = () => {
-  return state$w.workspacePath;
-};
-const getUri$1 = () => {
-  return state$w.workspaceUri;
-};
-const close$4 = () => {
-  return setPath('');
-};
-const getTitle$1 = workspacePath => {
-  if (!workspacePath) {
-    return '';
-  }
-  const pathSeparator = state$w.pathSeparator;
-  return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
-};
-const getPathName = workspacePath => {
-  if (!workspacePath) {
-    return '';
-  }
-  if (workspacePath.startsWith('github://')) {
-    return '/github/' + workspacePath.slice('github://'.length);
-  }
-  return '';
-};
-const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$w.workspacePath);
-  await set$f(title);
-  if (getPlatform() === Web$1 || getPlatform() === Remote) {
-    const pathName = getPathName(state$w.workspacePath);
-    await setPathName(pathName);
-  }
-  await emitEvent('workspace.change', state$w.workspacePath);
-};
-const hydrate$9 = async ({
-  href
-}) => {
-  if (state$w.workspacePath) {
-    return;
-  }
-  const resolvedRoot = await getResolvedRoot(href);
-  if (state$w.workspacePath) {
-    return;
-  }
-  // TODO why is this if statement here?
-  if (state$w.homeDir !== resolvedRoot.homeDir) {
-    state$w.homeDir = resolvedRoot.homeDir;
-  }
-  if (!canBeRestored$6(resolvedRoot.path)) {
-    return;
-  }
-  // TODO how to check that path from renderer process is valid?
-  // TODO also need to check whether it is a folder or file
-  state$w.workspacePath = resolvedRoot.path;
-  state$w.homeDir = resolvedRoot.homeDir;
-  state$w.pathSeparator = resolvedRoot.pathSeparator;
-  state$w.workspaceUri = resolvedRoot.uri;
-  state$w.source = resolvedRoot.source;
-  if (state$w.workspaceUri && state$w.workspaceUri.startsWith('/')) {
-    state$w.workspaceUri = `file://${state$w.workspaceUri}`;
-  }
-  await onWorkspaceChange();
-};
-const getWorkspaceUri = () => {
-  return state$w.workspaceUri;
-};
-const getHomeDir = () => {
-  return state$w.homeDir;
-};
-
-// TODO this should be in FileSystem module
-const pathBaseName = path => {
-  if (!path) {
-    return '';
+const getConfiguredWorkerUrl$1 = (preferenceKey, fallback) => {
+  let configuredWorkerUrl = get$e(preferenceKey) || '';
+  if (configuredWorkerUrl) {
+    const configuredUrlWithSlash = configuredWorkerUrl.startsWith('/') ? configuredWorkerUrl : '/' + configuredWorkerUrl;
+    configuredWorkerUrl = '/remote' + configuredUrlWithSlash;
   }
-  return path.slice(path.lastIndexOf('/') + 1);
-};
-
-// TODO this should be in FileSystem module
-const pathDirName = path => {
-  const pathSeparator = state$w.pathSeparator || '/';
-  const index = path.lastIndexOf(pathSeparator);
-  if (index === -1) {
-    return EmptyString;
+  configuredWorkerUrl = configuredWorkerUrl || fallback;
+  {
+    configuredWorkerUrl = fallback;
   }
-  return path.slice(0, index);
+  return configuredWorkerUrl;
 };
 
-const launchExtensionHostWorker = async () => {
-  const name = getPlatform() === Electron$1 ? 'Extension Host (Electron)' : 'Extension Host';
-  const id = create$$();
-  let ipc = await create$10({
+const launchExtensionManagementWorker = async () => {
+  const name = 'Extension Management Worker';
+  const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: extensionHostWorkerUrl,
-    id
+    url: getConfiguredWorkerUrl$1('develop.extensionManagementWorkerPath', extensionManagementWorkerUrl)
   });
-  if (getConfig()) {
-    // TODO should renderer process send port to renderer worker or vice versa?
-    const port = acquire(id);
-    ipc = wrap$7(port);
-  }
   handleIpc(ipc);
-  await invoke$w(ipc, 'Workspace.setWorkspacePath', state$w.workspacePath);
-  addListener('workspace.change', async () => {
-    await invoke$w(ipc, 'Workspace.setWorkspacePath', state$w.workspacePath);
-  });
+  await invoke$x(ipc, 'Extensions.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invoke: invoke$s,
-  invokeAndTransfer: invokeAndTransfer$9
-} = getOrCreateWorker(launchExtensionHostWorker);
+  invoke: invoke$t,
+  invokeAndTransfer: invokeAndTransfer$a} = getOrCreateWorker(launchExtensionManagementWorker);
 
 // TODO make storage configurable via settings as localstorage or indexeddb
 // also allow disabling caching via settings
@@ -2125,15 +1750,19 @@ const getColorThemeCssCached = async (colorThemeId, getData) => {
   return newData;
 };
 
-const getColorThemeJson = colorThemeId => {
-  return invoke$s('ColorTheme.getColorThemeJson', colorThemeId);
+const getColorThemeJson = (colorThemeId, platform, assetDir) => {
+  string(colorThemeId);
+  number(platform);
+  string(assetDir);
+  return invoke$t('Extensions.getColorThemeJson', colorThemeId, platform, assetDir);
 };
 
 const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
-  return invoke$s('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
+  return invoke$t('Extensions.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
 };
 const getColorThemeCssNew = async colorThemeId => {
-  const colorThemeJson = await getColorThemeJson(colorThemeId);
+  const platform = getPlatform$1();
+  const colorThemeJson = await getColorThemeJson(colorThemeId, platform, assetDir);
   const colorThemeCss = await getColorThemeCssFromJson(colorThemeId, colorThemeJson);
   return colorThemeCss;
 };
@@ -2146,13 +1775,13 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$v(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$w(/* 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
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
 
-const state$v = {
+const state$y = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2163,17 +1792,17 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$v.colorTheme = colorThemeId;
+    state$y.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     if (!colorThemeCss) {
       return new Error(`Color theme is empty`);
     }
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
-    if (getPlatform() === Web$1) {
+    if (getPlatform$1() === Web$1) {
       const themeColor = getMetaThemeColor(colorThemeId) || '';
       await setThemeColor(themeColor);
     }
-    if (getPlatform() !== Web$1 && get$e('development.watchColorTheme')) {
+    if (getPlatform$1() !== Web$1 && get$e('development.watchColorTheme')) {
       watch$1(colorThemeId);
     }
     return undefined;
@@ -2191,11 +1820,11 @@ const setColorTheme = async colorThemeId => {
   return undefined;
 };
 const watch$1 = async id => {
-  if (state$v.watchedTheme === id) {
+  if (state$y.watchedTheme === id) {
     return;
   }
-  state$v.watchedTheme = id;
-  await invoke$t('ExtensionHost.watchColorTheme', id);
+  state$y.watchedTheme = id;
+  await invoke$u('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get$e('workbench.colorTheme');
@@ -2208,7 +1837,7 @@ const reload$4 = async () => {
 
 // TODO test this, and also the error case
 // TODO have icon theme, color theme together (maybe)
-const hydrate$8 = async () => {
+const hydrate$a = async () => {
   const preferredColorTheme = getPreferredColorTheme();
   const colorThemeId = preferredColorTheme || FALLBACK_COLOR_THEME_ID;
   try {
@@ -2222,7 +1851,14 @@ const hydrate$8 = async () => {
   }
 };
 
-const state$u = {
+const state$x = {
+  id: 0
+};
+const create$$ = () => {
+  return ++state$x.id;
+};
+
+const state$w = {
   ipc: undefined
 };
 
@@ -2231,10 +1867,10 @@ const state$u = {
  * @returns {any}
  */
 const get$d = () => {
-  return state$u.ipc;
+  return state$w.ipc;
 };
-const set$e = ipc => {
-  state$u.ipc = ipc;
+const set$f = ipc => {
+  state$w.ipc = ipc;
 };
 
 const map$3 = Object.create(null);
@@ -2247,7 +1883,7 @@ const handleEvent = async (id, event) => {
       if (!ipc) {
         return;
       }
-      await invoke$w(ipc, alternate.callBackCommandId, event);
+      await invoke$x(ipc, alternate.callBackCommandId, event);
       return;
     }
     console.warn(`target not found ${id}`);
@@ -2265,37 +1901,37 @@ const watchFile = async (rpcId, callBackCommandId, uri) => {
     callBackCommandId
   };
   // TODO use filesystem worker / file watcher worker
-  await invoke$t('FileWatcher.watchFile2', id, uri);
+  await invoke$u('FileWatcher.watchFile2', id, uri);
   return map$3[id];
 };
 
-const state$t = {
+const state$v = {
   id: 0
 };
-const set$d = value => {
-  state$t.id = value;
+const set$e = value => {
+  state$v.id = value;
 };
 const get$c = () => {
-  return state$t.id;
+  return state$v.id;
 };
 
 // TODO cache window id
 
 const getWindowId = async () => {
   const webContentsId = get$c();
-  const windowId = await invoke$t('GetWindowId.getWindowId', webContentsId);
+  const windowId = await invoke$u('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
 
 const forward$2 = key => async (...args) => {
   const windowId = await getWindowId();
-  return invoke$t(key, windowId, ...args);
+  return invoke$u(key, windowId, ...args);
 };
 const reload$3 = forward$2('ElectronWindow.reload');
 const minimize$1 = forward$2('ElectronWindow.minimize');
 const unmaximize$1 = forward$2('ElectronWindow.unmaximize');
 const maximize$1 = forward$2('ElectronWindow.maximize');
-const close$3 = forward$2('ElectronWindow.close');
+const close$4 = forward$2('ElectronWindow.close');
 const openNew$1 = forward$2('ElectronWindow.openNew');
 const toggleDevtools = forward$2('ElectronWindow.toggleDevtools');
 const zoomIn$1 = forward$2('ElectronWindow.zoomIn');
@@ -2308,11 +1944,11 @@ const reloadElectron = () => {
 };
 
 const reloadWeb = () => {
-  return invoke$v('Window.reload');
+  return invoke$w('Window.reload');
 };
 
 const getFn$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
     case Remote:
       return reloadWeb;
@@ -2327,7 +1963,7 @@ const reload$2 = () => {
   return fn();
 };
 
-const hydrate$7 = async () => {
+const hydrate$9 = async () => {
   {
     return;
   }
@@ -2347,52 +1983,55 @@ const getUrlBaseName = href => {
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$t(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+  return invoke$u(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+};
+const getDisabledExtensionsJsonPath = () => {
+  return invoke$u(/* Platform.getDisabledExtensionsJsonPath */'Platform.getDisabledExtensionsJsonPath');
 };
 const getCachedExtensionsPath = () => {
-  return invoke$t(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
+  return invoke$u(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
 };
 const getLogsDir = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return 'memfs://output';
   }
-  return invoke$t(/* Platform.getLogsDir */'Platform.getLogsDir');
+  return invoke$u(/* Platform.getLogsDir */'Platform.getLogsDir');
 };
 const getDownloadDir = () => {
-  return invoke$t(/* Platform.getDownloadDir */'Platform.getDownloadDir');
+  return invoke$u(/* Platform.getDownloadDir */'Platform.getDownloadDir');
 };
 const getUserSettingsPath = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return 'settings';
   }
-  return invoke$t(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
+  return invoke$u(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
 };
 const getUserKeyBindingsPath = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return 'settings';
   }
-  return invoke$t(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
+  return invoke$u(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
 };
 const getRecentlyOpenedPath = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return 'recently-opened';
   }
-  return invoke$t(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
+  return invoke$u(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
 };
 const getConfigPath = () => {
-  return invoke$t(/* Platform.getConfigDir */'Platform.getConfigDir');
+  return invoke$u(/* Platform.getConfigDir */'Platform.getConfigDir');
 };
 const getCachePath = () => {
-  return invoke$t(/* Platform.getCacheDir */'Platform.getCacheDir');
+  return invoke$u(/* Platform.getCacheDir */'Platform.getCacheDir');
 };
 const getCacheUri = () => {
-  return invoke$t(/* Platform.getCacheDir */'Platform.getCacheUri');
+  return invoke$u(/* Platform.getCacheDir */'Platform.getCacheUri');
 };
 const getCacheName = () => {
   return 'lvce-runtime';
 };
 const getTestPathRemote = () => {
-  return invoke$t(/* Platform.getTestPath */'Platform.getTestPath');
+  return invoke$u(/* Platform.getTestPath */'Platform.getTestPath');
 };
 const getTestPathWeb = () => {
   return `${assetDir}/packages/extension-host-worker-tests`;
@@ -2400,7 +2039,7 @@ const getTestPathWeb = () => {
 
 // @ts-ignore
 const getTestPath = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
     case Remote:
       return getTestPathRemote();
@@ -2409,10 +2048,10 @@ const getTestPath = () => {
   }
 };
 const getTmpDir = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     throw new Error('not implemented in web');
   }
-  return invoke$t(/* Platform.getTmpDir */'Platform.getTmpDir');
+  return invoke$u(/* Platform.getTmpDir */'Platform.getTmpDir');
 };
 
 const existsTest = async url => {
@@ -2428,26 +2067,13 @@ const getTestFilePath = async (platform, href) => {
   const jsPath = `${testPath}/src/${jsFileName}`;
   const tsPath = `${testPath}/src/${tsFileName}`;
   if (platform === Web$1) {
-    return jsPath;
-  }
-  const existsTsPath = await existsTest(tsPath);
-  if (existsTsPath) {
-    return tsPath;
-  }
-  return jsPath;
-};
-
-const getConfiguredWorkerUrl$1 = (preferenceKey, fallback) => {
-  let configuredWorkerUrl = get$e(preferenceKey) || '';
-  if (configuredWorkerUrl) {
-    const configuredUrlWithSlash = configuredWorkerUrl.startsWith('/') ? configuredWorkerUrl : '/' + configuredWorkerUrl;
-    configuredWorkerUrl = '/remote' + configuredUrlWithSlash;
+    return jsPath;
   }
-  configuredWorkerUrl = configuredWorkerUrl || fallback;
-  {
-    configuredWorkerUrl = fallback;
+  const existsTsPath = await existsTest(tsPath);
+  if (existsTsPath) {
+    return tsPath;
   }
-  return configuredWorkerUrl;
+  return jsPath;
 };
 
 const testWorkerUrl = `${assetDir}/packages/test-worker/dist/testWorkerMain.js`;
@@ -2460,13 +2086,13 @@ const launchTestWorker = async () => {
     name: 'Test Worker'
   });
   handleIpc(ipc);
-  set$e(ipc);
+  set$f(ipc);
   return ipc;
 };
 
 const execute$2 = async href => {
   const ipc = await launchTestWorker();
-  await invoke$w(ipc, 'Test.execute', href, getPlatform(), assetDir);
+  await invoke$x(ipc, 'Test.execute', href, getPlatform$1(), assetDir);
 };
 
 const executeCurrentTest = async (platform, initData) => {
@@ -2490,7 +2116,7 @@ const map$2 = {
 
 // TODO if necessary support more browser detection
 const getBrowser = () => {
-  if (getPlatform() === Electron$1) {
+  if (getPlatform$1() === Electron$1) {
     return 'electron';
   }
   // @ts-ignore
@@ -2527,22 +2153,22 @@ const contexts = Object.create(null);
 const get$b = key => {
   return contexts[key];
 };
-const set$c = (key, value) => {
+const set$d = (key, value) => {
   contexts[key] = value;
 };
 const remove$9 = key => {
   delete contexts[key];
 };
 
-const state$s = {
+const state$u = {
   // TODO use numeric focus key
   currentFocus: ''
 };
 const get$a = () => {
-  return state$s.currentFocus;
+  return state$u.currentFocus;
 };
-const set$b = value => {
-  state$s.currentFocus = value;
+const set$c = value => {
+  state$u.currentFocus = value;
 };
 
 const warn = (...args) => {
@@ -2552,7 +2178,7 @@ const error = (...args) => {
   console.error(...args);
 };
 
-const state$r = {
+const state$t = {
   keyBindingSets: Object.create(null),
   /**
    * @type {Uint32Array}
@@ -2564,7 +2190,7 @@ const state$r = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$r.matchingKeyBindings) {
+  for (const keyBinding of state$t.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -2587,26 +2213,26 @@ const getAvailableKeyBindings = keyBindings => {
   return new Uint32Array(keyBindings.map(getKey$1));
 };
 const update = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$r.keyBindingSets);
+  const matchingKeyBindings = getMatchingKeyBindings(state$t.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$v('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$r.matchingKeyBindings = matchingKeyBindings;
-  state$r.keyBindingIdentifiers = keyBindingIdentifiers;
+  invoke$w('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  state$t.matchingKeyBindings = matchingKeyBindings;
+  state$t.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$r.keyBindingSets) {
+  if (id in state$t.keyBindingSets) {
     warn(`cannot add keybindings multiple times: ${id}`);
     return;
   }
-  state$r.keyBindingSets[id] = keyBindings;
+  state$t.keyBindingSets[id] = keyBindings;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets
-  } = state$r;
+  } = state$t;
   if (!(id in keyBindingSets)) {
     warn(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -2641,10 +2267,10 @@ const setFocus = (focusKey, additionalFocusKey) => {
   if (get$a()) {
     remove$9(get$a());
   }
-  set$b(focusKey);
-  set$c(get$a(), true);
+  set$c(focusKey);
+  set$d(get$a(), true);
   if (additionalFocusKey) {
-    set$c(additionalFocusKey, true);
+    set$d(additionalFocusKey, true);
   }
   update();
 };
@@ -2653,7 +2279,7 @@ const setFocus = (focusKey, additionalFocusKey) => {
  * @param {number} key
  */
 const setAdditionalFocus = key => {
-  set$c(key, true);
+  set$d(key, true);
   update();
 };
 
@@ -2676,12 +2302,12 @@ const getBrowserContextString = browser => {
       return Empty;
   }
 };
-const hydrate$6 = async () => {
+const hydrate$8 = async () => {
   // TODO is this the right place for browser context ?
   // maybe in env file / env service
   const browser = getBrowser();
   const key = getBrowserContextString(browser);
-  set$c(key, true);
+  set$d(key, true);
   update();
 };
 
@@ -2721,14 +2347,14 @@ class CancelationError extends Error {
   }
 }
 
-const state$q = {
+const state$s = {
   idMap: Object.create(null)
 };
 const register = (id, module) => {
-  state$q.idMap[id] = module;
+  state$s.idMap[id] = module;
 };
 const get$9 = id => {
-  return state$q.idMap[id];
+  return state$s.idMap[id];
 };
 
 const registry = Object.create(null);
@@ -2765,13 +2391,13 @@ const serializeObjects = objects => {
 };
 
 const clear$5 = async storageType => {
-  await invoke$v(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$w(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$v('WebStorage.getAll', storageType);
+  return invoke$w('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$v(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$w(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$6 = async (storageType, key) => {
@@ -2786,7 +2412,7 @@ const getJson$6 = async (storageType, key) => {
   }
 };
 const setText$1 = async (storageType, key, value) => {
-  await invoke$v(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$w(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$5 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -2794,7 +2420,7 @@ const setJson$5 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = serializeObjects(objects);
-  await invoke$v('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$w('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -2852,18 +2478,18 @@ const serializeInstances = async instances => {
 // to allow having multiple instances of the same
 // type. for example multiple editors
 
-const state$p = {
+const state$r = {
   instances: Object.create(null)};
-const set$a = (key, value) => {
+const set$b = (key, value) => {
   // TODO separate factories from state
   object(value);
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$p.instances[key] = value;
+  state$r.instances[key] = value;
 };
 const getByUid = uid => {
-  for (const value of Object.values(state$p.instances)) {
+  for (const value of Object.values(state$r.instances)) {
     if (value.renderedState.uid === uid) {
       return value;
     }
@@ -2871,7 +2497,7 @@ const getByUid = uid => {
   return undefined;
 };
 const getInstance = key => {
-  const fast = state$p.instances[key];
+  const fast = state$r.instances[key];
   if (fast) {
     return fast;
   }
@@ -2884,7 +2510,7 @@ const getInstance = key => {
   if (key === 'EditorCompletion') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$p.instances)) {
+  for (const value of Object.values(state$r.instances)) {
     if (value.moduleId === key) {
       return value;
     }
@@ -2892,78 +2518,477 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$p.instances;
+  return key in state$r.instances;
 };
 const remove$8 = key => {
-  delete state$p.instances[key];
+  delete state$r.instances[key];
 };
 const getAllInstances = () => {
-  return state$p.instances;
+  return state$r.instances;
 };
 const getValues = () => {
-  return Object.values(state$p.instances);
+  return Object.values(state$r.instances);
 };
 const getState$1 = key => {
   const instance = getInstance(key);
   if (!instance) {
     throw new Error(`instance not found ${key}`);
   }
-  return instance.state;
-};
-const setState$1 = (key, newState) => {
-  if (typeof key !== 'string' && typeof key !== 'number') {
-    throw new TypeError('key must be defined');
+  return instance.state;
+};
+const setState$1 = (key, newState) => {
+  if (typeof key !== 'string' && typeof key !== 'number') {
+    throw new TypeError('key must be defined');
+  }
+  object(newState);
+  const instance = getInstance(key);
+  instance.state = newState;
+};
+const setRenderedState = (key, newState) => {
+  if (typeof key !== 'string' && typeof key !== 'number') {
+    throw new TypeError('key must be defined');
+  }
+  object(newState);
+  const instance = getInstance(key);
+  if (!instance) {
+    return;
+  }
+  instance.renderedState = newState;
+  instance.state = newState;
+};
+const setFocusedInstance = (state, instance) => {
+  state.focusedIndex = instance;
+};
+
+const Slash = Slash$1;
+
+const getResolvedRootFromSharedProcess = async () => {
+  const resolvedRoot = await invoke$u(/* Workspace.resolveRoot */WorkspaceResolveRoot);
+  return resolvedRoot;
+};
+const isValid$1 = resolvedRoot => {
+  return resolvedRoot && typeof resolvedRoot.path === 'string' && typeof resolvedRoot.uri === 'string' && typeof resolvedRoot.homeDir === 'string' && typeof resolvedRoot.pathSeparator === 'string';
+};
+const getResolveRootFromSessionStorage = async () => {
+  const resolvedRoot = await execute$3(/* SessionStorage.getJson */'SessionStorage.getJson', /* key */'workspace');
+  if (!isValid$1(resolvedRoot)) {
+    return undefined;
+  }
+  return resolvedRoot;
+};
+const getResolvedRootFromRendererProcess = async href => {
+  const url = new URL(href);
+  if (href.includes('tests/')) {
+    state$A.isTest = true;
+    return {
+      path: href,
+      homeDir: '',
+      pathSeparator: Slash,
+      source: 'test'
+    };
+  }
+  if (url.pathname.startsWith('/github')) {
+    const path = `github://${url.pathname.slice('/github'.length + 1)}`;
+    return {
+      path,
+      homeDir: '',
+      pathSeparator: Slash,
+      source: 'renderer-process'
+    };
+  }
+  if (getPlatform$1() === Web$1) {
+    const defaultWorkspace = get$e('workspace.defaultWorkspace');
+    const resolvedRoot = {
+      path: defaultWorkspace,
+      homeDir: '',
+      pathSeparator: Slash,
+      source: 'renderer-process'
+    };
+    return resolvedRoot;
+  }
+  const resolvedRootFromSessionStorage = await getResolveRootFromSessionStorage();
+  if (resolvedRootFromSessionStorage) {
+    return resolvedRootFromSessionStorage;
+  }
+  return undefined;
+};
+const getResolvedRootRemote = async href => {
+  const resolvedRootFromRendererProcess = await getResolvedRootFromRendererProcess(href);
+  if (resolvedRootFromRendererProcess) {
+    return resolvedRootFromRendererProcess;
+  }
+  return getResolvedRootFromSharedProcess();
+};
+const getResolvedRoot = async href => {
+  switch (getPlatform$1()) {
+    case Web$1:
+      return getResolvedRootFromRendererProcess(href);
+    default:
+      return getResolvedRootRemote(href);
+  }
+};
+
+const getHref = () => {
+  return invoke$w(/* Location.getHref */'Location.getHref');
+};
+const setPathName = pathName => {
+  return invoke$w(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+};
+const hydrate$7 = () => {
+  return invoke$w(/* Location.hydrate */'Location.hydrate');
+};
+const getHost = () => {
+  return location.host;
+};
+
+const set$a = title => {
+  return invoke$w('WindowTitle.set', title);
+};
+
+const state$q = {
+  workspacePath: '',
+  homeDir: '',
+  pathSeparator: '',
+  workspaceUri: '',
+  source: ''};
+
+/**
+ * @param {string|undefined} path
+ */
+const setPath = async path => {
+  string(path);
+  // TODO not in electron
+  const pathSeparator = await getPathSeparator$9(path);
+  // @ts-ignore
+  state$q.workspacePath = path;
+  // @ts-ignore
+  state$q.workspaceUri = path;
+  state$q.pathSeparator = pathSeparator;
+  await onWorkspaceChange();
+};
+const setUri = async uri => {
+  const path = uri.slice('file://'.length);
+  state$q.workspacePath = path;
+  state$q.workspaceUri = uri;
+  await onWorkspaceChange();
+};
+const getPath = () => {
+  return state$q.workspacePath;
+};
+const getUri$1 = () => {
+  return state$q.workspaceUri;
+};
+const close$3 = () => {
+  return setPath('');
+};
+const getTitle$1 = workspacePath => {
+  if (!workspacePath) {
+    return '';
+  }
+  const pathSeparator = state$q.pathSeparator;
+  return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
+};
+const getPathName = workspacePath => {
+  if (!workspacePath) {
+    return '';
+  }
+  if (workspacePath.startsWith('github://')) {
+    return '/github/' + workspacePath.slice('github://'.length);
+  }
+  return '';
+};
+const onWorkspaceChange = async () => {
+  const title = getTitle$1(state$q.workspacePath);
+  await set$a(title);
+  if (getPlatform$1() === Web$1 || getPlatform$1() === Remote) {
+    const pathName = getPathName(state$q.workspacePath);
+    await setPathName(pathName);
+  }
+  await emitEvent('workspace.change', state$q.workspacePath);
+};
+const hydrate$6 = async ({
+  href
+}) => {
+  if (state$q.workspacePath) {
+    return;
+  }
+  const resolvedRoot = await getResolvedRoot(href);
+  if (state$q.workspacePath) {
+    return;
+  }
+  // TODO why is this if statement here?
+  if (state$q.homeDir !== resolvedRoot.homeDir) {
+    state$q.homeDir = resolvedRoot.homeDir;
+  }
+  if (!canBeRestored$6(resolvedRoot.path)) {
+    return;
+  }
+  // TODO how to check that path from renderer process is valid?
+  // TODO also need to check whether it is a folder or file
+  state$q.workspacePath = resolvedRoot.path;
+  state$q.homeDir = resolvedRoot.homeDir;
+  state$q.pathSeparator = resolvedRoot.pathSeparator;
+  state$q.workspaceUri = resolvedRoot.uri;
+  state$q.source = resolvedRoot.source;
+  if (state$q.workspaceUri && state$q.workspaceUri.startsWith('/')) {
+    state$q.workspaceUri = `file://${state$q.workspaceUri}`;
+  }
+  await onWorkspaceChange();
+};
+const getWorkspaceUri = () => {
+  return state$q.workspaceUri;
+};
+const getHomeDir = () => {
+  return state$q.homeDir;
+};
+
+// TODO this should be in FileSystem module
+const pathBaseName = path => {
+  if (!path) {
+    return '';
+  }
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+
+// TODO this should be in FileSystem module
+const pathDirName = path => {
+  const pathSeparator = state$q.pathSeparator || '/';
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return EmptyString;
+  }
+  return path.slice(0, index);
+};
+
+const getStateToSave = async () => {
+  const instances = getAllInstances();
+  const savedInstances = await serializeInstances(instances);
+  return {
+    instances: savedInstances,
+    mainEditors: [],
+    workspace: {
+      path: state$q.workspacePath,
+      homeDir: state$q.homeDir,
+      pathSeparator: state$q.pathSeparator,
+      uri: state$q.workspaceUri
+    }
+  };
+};
+
+const clear$3 = () => {
+  return clear$5(SessionStorage);
+};
+const getJson$3 = key => {
+  return getJson$6(SessionStorage, key);
+};
+const setJson$2 = (key, value) => {
+  return setJson$5(SessionStorage, key, value);
+};
+
+const saveBuiltinState = async () => {
+  const stateToSave = await getStateToSave();
+  await Promise.all([setJson$3('workspace', stateToSave.workspace), setJsonObjects(stateToSave.instances), setJson$2('workspace', stateToSave.workspace)]);
+};
+
+const extensionHostWorkerUrl = `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/extension-host-worker/dist/extensionHostWorkerMain.js`;
+
+const ModuleWorkerWithMessagePort = 4;
+const Electron = 5;
+
+const getPortTuple = initialPort => {
+  if (initialPort) {
+    return {
+      port1: undefined,
+      port2: initialPort
+    };
+  }
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
   }
-  object(newState);
-  const instance = getInstance(key);
-  instance.state = newState;
-};
-const setRenderedState = (key, newState) => {
-  if (typeof key !== 'string' && typeof key !== 'number') {
-    throw new TypeError('key must be defined');
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
   }
-  object(newState);
-  const instance = getInstance(key);
-  if (!instance) {
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
     return;
   }
-  instance.renderedState = newState;
-  instance.state = newState;
 };
-const setFocusedInstance = (state, instance) => {
-  state.focusedIndex = instance;
+
+const transferrables = [];
+if (typeof OffscreenCanvas !== 'undefined') {
+  transferrables.push(OffscreenCanvas);
+}
+if (typeof MessagePort !== 'undefined') {
+  transferrables.push(MessagePort);
+}
+
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (value instanceof fn) {
+      return true;
+    }
+  }
+  return false;
 };
 
-const getStateToSave = async () => {
-  const instances = getAllInstances();
-  const savedInstances = await serializeInstances(instances);
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+
+const create$_ = async ({
+  url,
+  name,
+  port,
+  id
+}) => {
+  // TODO no need to create port if worker
+  // has been prelaunched in renderer process
+  const {
+    port1,
+    port2
+  } = getPortTuple(port);
+  await invokeAndTransfer$d('IpcParent.create', {
+    method: ModuleWorkerWithMessagePort,
+    url,
+    name,
+    raw: true,
+    port: port2,
+    id
+  });
+  return port1;
+};
+
+// TODO why are some events not instance of message event?
+
+const getData$1 = event => {
+  if (event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event;
+};
+const wrap$7 = port => {
   return {
-    instances: savedInstances,
-    mainEditors: [],
-    workspace: {
-      path: state$w.workspacePath,
-      homeDir: state$w.homeDir,
-      pathSeparator: state$w.pathSeparator,
-      uri: state$w.workspaceUri
+    port,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      const wrappedListener = event => {
+        const data = getData$1(event);
+        const syntheticEvent = {
+          data,
+          target: this
+        };
+        listener(syntheticEvent);
+      };
+      this.port.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message) {
+      const transfer = getTransferrables(message);
+      this.port.postMessage(message, transfer);
+    },
+    dispose() {
+      this.port.postMessage({
+        jsonrpc: '2.0',
+        method: 'Exit.exit',
+        params: []
+      });
+      this.port.close();
     }
   };
 };
 
-const clear$3 = () => {
-  return clear$5(SessionStorage);
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$_,
+  wrap: wrap$7
 };
-const getJson$3 = key => {
-  return getJson$6(SessionStorage, key);
+
+const state$p = {
+  shouldLaunchMultipleWorkers: false
 };
-const setJson$2 = (key, value) => {
-  return setJson$5(SessionStorage, key, value);
+const setConfig = shouldLaunchMultipleWorkers => {
+  state$p.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+};
+const getConfig = () => {
+  return state$p.shouldLaunchMultipleWorkers;
 };
 
-const saveBuiltinState = async () => {
-  const stateToSave = await getStateToSave();
-  await Promise.all([setJson$3('workspace', stateToSave.workspace), setJsonObjects(stateToSave.instances), setJson$2('workspace', stateToSave.workspace)]);
+const objects = Object.create(null);
+const transferToRendererProcess = async (objectId, transferable) => {
+  await invokeAndTransfer$d('Transferrable.transfer', transferable, objectId);
+};
+const transfer = (objectId, transferable) => {
+  number(objectId);
+  object(transferable);
+  objects[objectId] = transferable;
+};
+const acquire = objectId => {
+  number(objectId);
+  const value = objects[objectId];
+  if (!value) {
+    throw new Error(`transferrable object not found`);
+  }
+  delete objects[objectId];
+  return value;
+};
+
+const launchExtensionHostWorker = async () => {
+  const name = getPlatform$1() === Electron$1 ? 'Extension Host (Electron)' : 'Extension Host';
+  const id = create$$();
+  let ipc = await create$10({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: extensionHostWorkerUrl,
+    id
+  });
+  if (getConfig()) {
+    // TODO should renderer process send port to renderer worker or vice versa?
+    const port = acquire(id);
+    ipc = wrap$7(port);
+  }
+  handleIpc(ipc);
+  await invoke$x(ipc, 'Workspace.setWorkspacePath', state$q.workspacePath);
+  addListener('workspace.change', async () => {
+    await invoke$x(ipc, 'Workspace.setWorkspacePath', state$q.workspacePath);
+  });
+  return ipc;
 };
 
+const {
+  invoke: invoke$s,
+  invokeAndTransfer: invokeAndTransfer$9
+} = getOrCreateWorker(launchExtensionHostWorker);
+
 const ActivityBar$2 = 'ActivityBar';
 const ExtensionStateStorage$1 = 'ExtensionStateStorage';
 
@@ -3036,7 +3061,7 @@ const hydrate$5 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$v('Window.onVisibilityChange');
+  await invoke$w('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$4(viewletId);
@@ -3069,7 +3094,7 @@ const launchFileSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$w(ipc, 'QuickPick.initialize');
+    await invoke$x(ipc, 'QuickPick.initialize');
   } catch {
     // ignore
   }
@@ -3269,7 +3294,7 @@ const runFn = async (instance, id, key, fn, args) => {
   if (instance.factory && instance.factory.hasFunctionalRender) {
     const oldState = instance.state;
     const newState = await fn(oldState, ...args);
-    if (key === 'getAllQuickPickMenuEntries' || key === 'getBadgeCounts' || key === 'getActiveSideBarView' || key === 'getCommit') {
+    if (key === 'getAllQuickPickMenuEntries' || key === 'getBadgeCounts' || key === 'getActiveSideBarView' || key === 'getCommit' || key === 'getAssetDir' || key === 'getPlatform') {
       return newState;
     }
     if (!newState) {
@@ -3285,7 +3310,7 @@ const runFn = async (instance, id, key, fn, args) => {
     const commands = render$F(instance.factory, oldState, newState, newState.uid || id);
     updateDynamicFocusContext(commands);
     setRenderedState(id, newState);
-    await invoke$v(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3311,7 +3336,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
     return;
   }
   updateDynamicFocusContext(commands);
-  await invoke$v(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -3517,7 +3542,7 @@ const maybeRegisterEvents = module => {
       const commands = render$F(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
       instance.state = newState;
       instance.renderedState = newState;
-      await invoke$v(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     };
     addListener('workspace.change', handleUpdate);
   }
@@ -3544,7 +3569,7 @@ const maybeRegisterEvents = module => {
         const commands = render$F(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$v(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -3572,7 +3597,7 @@ const maybeRegisterMenuEntries = async module => {
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
   if (!module.hasFunctionalEvents) {
-    await invoke$v(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
+    await invoke$w(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
   }
   await loadModule$1(id, module);
   await maybeRegisterWrappedCommands(id, module);
@@ -3666,7 +3691,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.renderEventListeners) {
       // TODO reuse event listeners between components
       const eventListeners = await module.renderEventListeners();
-      await invoke$v('Viewlet.registerEventListeners', viewletUid, eventListeners);
+      await invoke$w('Viewlet.registerEventListeners', viewletUid, eventListeners);
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
       await module.show(newState);
@@ -3720,7 +3745,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$v(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$w(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -3728,7 +3753,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     // TODO race condition: viewlet state may have been updated again in the mean time
     state = ViewletState.RendererProcessViewletLoaded;
-    set$a(viewletUid, {
+    set$b(viewletUid, {
       state: newState,
       renderedState: viewletState,
       factory: module,
@@ -3781,7 +3806,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       commands.push(...extraCommands);
       updateDynamicFocusContext(commands);
-      await invoke$v(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else if (!module.hasFunctionalEvents && shouldRender) {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -3802,7 +3827,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$v(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$w(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -3824,10 +3849,10 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$v(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$w(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$v(kLoadModule, Error$4);
+      await invoke$w(kLoadModule, Error$4);
       commands.push([kCreate, Error$4, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -3836,7 +3861,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$v(kLoadModule, module.customErrorRenderer);
+        await invoke$w(kLoadModule, module.customErrorRenderer);
         commands.push([kCreate, module.customErrorRenderer, viewletUid]);
         commands.push(['Viewlet.setDom2', viewletUid, dom]);
         commands.push([kAppend, parentUid, viewletUid]);
@@ -3888,7 +3913,7 @@ const load$3 = async moduleId => {
 };
 
 const disposeBrowserViewQuickPick = () => {
-  return invoke$t('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
+  return invoke$u('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
 const handleKeyBinding$1 = async identifier => {
@@ -3938,7 +3963,7 @@ const focus$5 = async id => {
     commands.push(...render$F(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$v('Viewlet.sendMultiple', commands);
+  await invoke$w('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -3981,7 +4006,7 @@ const dispose$r = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$v(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$w(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -4162,7 +4187,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$v(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$w(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -4205,7 +4230,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$v('Viewlet.executeCommands', commands);
+  await invoke$w('Viewlet.executeCommands', commands);
 };
 const closeWidget = async id => {
   try {
@@ -4217,7 +4242,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$v(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$w(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4275,7 +4300,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$v(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$w(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 
 // @ts-ignore
@@ -4315,7 +4340,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$v('Viewlet.sendMultiple', commands);
+    await invoke$w('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4386,8 +4411,8 @@ const getIcons = iconRequests => {
 const setIconTheme = async iconThemeId => {
   try {
     const useCache = get$e('icon-theme.cache') ?? true;
-    const extensions = await invoke$s('Extensions.getExtensions');
-    await invoke$q('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, getPlatform(), useCache);
+    const extensions = await invoke$t('Extensions.getAllExtensions');
+    await invoke$q('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, getPlatform$1(), useCache);
     await handleIconThemeChange$1();
   } catch (error) {
     if (isTest()) ; else {
@@ -4402,7 +4427,7 @@ const hydrate$4 = async () => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$v('InitData.getInitData');
+  const rendererProcessInitData = await invoke$w('InitData.getInitData');
   // TODO get the following items
   // - location.href
   // - workspace
@@ -4551,7 +4576,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$t(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  const languageConfiguration = await invoke$u(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
   if (languageConfiguration) {
     return languageConfiguration;
   }
@@ -4564,14 +4589,15 @@ const getLanguageConfiguration$2 = async languageId => {
 
 const getLanguages = async () => {
   try {
-    return invoke$s('Languages.getLanguages');
+    const platform = getPlatform$1();
+    return invoke$t('Extensions.getLanguages', platform);
   } catch (error) {
     throw new VError(error, 'Failed to load languages');
   }
 };
 const getLanguageConfiguration$1 = async languageId => {
   string(languageId);
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return getLanguageConfiguration$2();
     default:
@@ -4861,7 +4887,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$x.ipc = ipc;
+  state$z.ipc = ipc;
 };
 
 const Zero = 0;
@@ -5230,10 +5256,10 @@ const addToRecentlyOpenedWeb = async path => {
   await setRecentlyOpened(newRecentlyOpened);
 };
 const addToRecentlyOpenedRemote = async path => {
-  await invoke$t(RecentlyOpenedAddPath, path);
+  await invoke$u(RecentlyOpenedAddPath, path);
 };
 const addToRecentlyOpened = async path => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
     case Remote:
       return addToRecentlyOpenedRemote(path);
@@ -5497,7 +5523,7 @@ const wrapIpc = (ipc, name, getData) => {
 };
 const startRecording$1 = () => {
   state$D.ipc = wrapIpc(state$D.ipc, 'renderer-process', event => event.data);
-  state$x.ipc = wrapIpc(state$x.ipc, 'shared-process', event => event);
+  state$z.ipc = wrapIpc(state$z.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$3(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -5677,7 +5703,7 @@ const watchFilesForHotReload = async platform => {
     if (config.length === 0) {
       return;
     }
-    await invoke$t('ExtensionHost.watchForHotReload', config);
+    await invoke$u('ExtensionHost.watchForHotReload', config);
   } catch (error) {
     console.warn(`Failed to watch ${error}`);
   }
@@ -5720,7 +5746,7 @@ const actions = [async () => {
   mark$1(Twelve);
   mark$1(Thirteen);
   mark$1(Fourteen);
-  if (getPlatform() === Electron$1 && get$e('window.titleBarStyle') === 'native') {
+  if (getPlatform$1() === Electron$1 && get$e('window.titleBarStyle') === 'native') {
     await execute$3('ElectronApplicationMenu.hydrate');
   } else {
     mark(WillLoadTitleBar);
@@ -5740,7 +5766,7 @@ const startup = async () => {
   mark$1(Zero);
   mark(WillStartupWorkbench);
   await listen$1();
-  if (getPlatform() !== Web$1) {
+  if (getPlatform$1() !== Web$1) {
     await launchSharedProcess();
   }
   mark$1(One);
@@ -5765,12 +5791,12 @@ const startup = async () => {
   }
   mark$1(Twelve);
   mark(WillOpenWorkspace);
-  await hydrate$9(initData.Location);
+  await hydrate$6(initData.Location);
   mark(DidOpenWorkspace);
-  await hydrate$6();
+  await hydrate$8();
   mark$1(Three);
   mark(WillLoadColorTheme);
-  await hydrate$8();
+  await hydrate$a();
   mark(DidLoadColorTheme);
   mark$1(Four);
   mark(WillShowLayout);
@@ -5795,7 +5821,7 @@ const startup = async () => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$v('Viewlet.executeCommands', commands);
+  await invoke$w('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
@@ -5805,7 +5831,7 @@ const startup = async () => {
   await Promise.all(actions.map(action => action()));
   mark$1(Fifteen);
   if (isTest()) {
-    await executeCurrentTest(getPlatform(), initData);
+    await executeCurrentTest(getPlatform$1(), initData);
     return;
   }
   mark(WillLoadSaveState);
@@ -5819,9 +5845,9 @@ const startup = async () => {
   // TODO tree shake out service worker in electron build
 
   mark(WillLoadLocation);
-  await hydrate$a();
+  await hydrate$7();
   mark(DidLoadLocation);
-  const watcherPromises = Promise.all([hydrate$7(), watchFilesForHotReload()]);
+  const watcherPromises = Promise.all([hydrate$9(), watchFilesForHotReload()]);
   measure(OpenWorkspace, WillOpenWorkspace, DidOpenWorkspace);
   measure(LoadMain, WillLoadMain, DidLoadMain);
   measure(LoadSideBar, WillLoadSideBar, DidLoadSideBar);
@@ -5833,7 +5859,7 @@ const startup = async () => {
   measure(LoadColorTheme, WillLoadColorTheme, DidLoadColorTheme);
   measure(LoadIconTheme, WillLoadIconTheme, DidLoadIconTheme);
   const autoUpdate = get$e('application.updateMode');
-  const supportsAutoUpdate = getPlatform() === Electron$1; // TODO also check if auto update is supported on this platform, e.g. windows
+  const supportsAutoUpdate = getPlatform$1() === Electron$1; // TODO also check if auto update is supported on this platform, e.g. windows
   if (autoUpdate && autoUpdate !== 'none' && supportsAutoUpdate) {
     try {
       await execute$3('AutoUpdater.checkForUpdates', autoUpdate);
@@ -5899,13 +5925,13 @@ const getPort = async ipcId => {
     port2
   } = getPortTuple();
   // TODO call sendMessagePortToElectron function
-  const webContentsId = await invokeAndTransfer$c('IpcParent.create', {
+  const webContentsId = await invokeAndTransfer$d('IpcParent.create', {
     method: Electron,
     port: port1,
     ipcId
   });
   // TODO avoid side effect?
-  set$d(webContentsId);
+  set$e(webContentsId);
   return port2;
 };
 const create$X = async options => {
@@ -6342,7 +6368,7 @@ const IpcParentWithWebSocket = {
 };
 
 const getModule$4 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
     case Remote:
       return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
@@ -6379,11 +6405,11 @@ const IpcParentWithNode = {
 const sendMessagePortToElectron = async (port, initialCommand, ipcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$a(initialCommand, port, ipcId);
+  await invokeAndTransfer$b(initialCommand, port, ipcId);
 };
 
 const create$Q = async options => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
     case Remote:
       const module = await Promise.resolve().then(function () { return IpcParentWithWebSocket; });
@@ -6508,7 +6534,6 @@ const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceComplet
 const ClosingTagExecuteClosingTagProvider = 'ExtensionHostClosingTag.executeClosingTagProvider';
 const CommandExecute = 'ExtensionHostCommand.executeCommand';
 const DefinitionExecuteDefinitionProvider = 'ExtensionHostDefinition.executeDefinitionProvider';
-const ExtensionActivate = 'ExtensionHostExtension.activate';
 const FileSystemCreateFolder = 'ExtensionHostFileSystem.createFolder';
 const FileSystemGetPathSeparator = 'ExtensionHostFileSystem.getPathSeparator';
 const FileSystemMkdir = 'ExtensionHostFileSystem.mkdir';
@@ -6652,7 +6677,7 @@ const handleRejectedExtensions = async extensions => {
   }
 };
 const getExtensions$1 = async () => {
-  return invoke$s('Extensions.getExtensions');
+  return invoke$t('Extensions.getAllExtensions');
 };
 const addNodeExtension = async path => {
   // TODO add support for dynamically loading node extensions
@@ -6692,15 +6717,16 @@ const state$g = {
   activatedExtensions: Object.create(null)
 };
 const actuallyActivateExtension = async (extension, event) => {
+  const platform = getPlatform$1();
   if (!(extension.id in state$g.activatedExtensions)) {
-    const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin, getPlatform());
-    state$g.activatedExtensions[extension.id] = invoke$s(ExtensionActivate, extension, absolutePath, event);
+    const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin, getPlatform$1());
+    state$g.activatedExtensions[extension.id] = invoke$t('Extensions.activate3', extension, absolutePath, event, platform);
   }
   return state$g.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async event => {
   // TODO should not query extensions multiple times
-  const extensions = await invoke$s('Extensions.getExtensions');
+  const extensions = await invoke$t('Extensions.getAllExtensions');
   const {
     resolved,
     rejected
@@ -7352,7 +7378,7 @@ const launchFileSystemWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.fileSystemWorkerPath', fileSystemWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Initialize.initialize', getPlatform());
+  await invoke$x(ipc, 'Initialize.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -7502,7 +7528,7 @@ const getBlob$3 = async (path, type) => {
   return blob;
 };
 const getPathSeparator$2 = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return Slash;
   }
   return invoke$p('FileSystem.getPathSeparator');
@@ -7661,7 +7687,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$v('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$w('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -7895,7 +7921,7 @@ const launchDebugWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.debugWorkerPath', debugWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Initialize.initialize');
+  await invoke$x(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -8001,7 +8027,7 @@ const showAboutDefault = async () => {
   await openWidget(About);
 };
 const getFn = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return showAboutElectron;
     default:
@@ -8104,7 +8130,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$v(/* Audio.play */3211, /* src */src);
+  await invoke$w(/* Audio.play */3211, /* src */src);
 };
 
 const name$2b = 'Audio';
@@ -8171,7 +8197,7 @@ const GetActiveEditor_ipc = {
 };
 
 const getSelectionText = () => {
-  return invoke$v('Css.getSelectionText');
+  return invoke$w('Css.getSelectionText');
 };
 
 const name$28 = 'Document';
@@ -8189,7 +8215,7 @@ const exec = (command, args, options) => {
   string(command);
   array(args);
   object(options);
-  return invoke$t('Exec.exec', command, args, options);
+  return invoke$u('Exec.exec', command, args, options);
 };
 
 const name$27 = 'Exec';
@@ -8254,7 +8280,8 @@ const Commands$28 = {
   getLogsDir: getLogsDir,
   getTmpDir: getTmpDir,
   getCachePath: getCachePath,
-  getCacheUri: getCacheUri
+  getCacheUri: getCacheUri,
+  getDisabledExtensionsJsonPath: getDisabledExtensionsJsonPath
 };
 
 const PlatformPaths_ipc = {
@@ -8264,14 +8291,14 @@ const PlatformPaths_ipc = {
 };
 
 const getFileHandles = ids => {
-  return invoke$v('FileHandles.get', ids);
+  return invoke$w('FileHandles.get', ids);
 };
 const addFileHandle = fileHandle => {
-  return invoke$v('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$w('FileSystemHandle.addFileHandle', fileHandle);
 };
 
 const getFilePathElectron = async file => {
-  return invoke$v('GetFilePathElectron.getFilePathElectron', file);
+  return invoke$w('GetFilePathElectron.getFilePathElectron', file);
 };
 
 const name$24 = 'FileSystemHandle';
@@ -8369,7 +8396,7 @@ const applyLegacyBulkReplacement = async (files, ranges, replacement) => {
     await invoke$s('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
     return;
   }
-  await invoke$t('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$u('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const applyFileReplacement = async edit => {
@@ -8418,7 +8445,7 @@ const getResponse = async key => {
   if (typeof caches === 'undefined') {
     return undefined;
   }
-  if (getPlatform() === Electron$1 && key.startsWith(Slash$1)) {
+  if (getPlatform$1() === Electron$1 && key.startsWith(Slash$1)) {
     // workaround for custom protocol not working with cache storage
     key = 'https://example.com' + key;
   }
@@ -8446,7 +8473,7 @@ const setResponse = async (key, value, contentType) => {
     return;
   }
   // TODO cache the cache (maybe)
-  if (getPlatform() === Remote &&
+  if (getPlatform$1() === Remote &&
   // workaround for custom protocol not working with cache storage
   key.startsWith(Slash$1)) {
     key = 'https://example.com' + key;
@@ -8516,7 +8543,7 @@ const Callback_ipc = {
 };
 
 const minimize = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.minimize');
     default:
@@ -8524,7 +8551,7 @@ const minimize = () => {
   }
 };
 const maximize = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.maximize');
     default:
@@ -8532,7 +8559,7 @@ const maximize = () => {
   }
 };
 const unmaximize = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.unmaximize');
     default:
@@ -8540,7 +8567,7 @@ const unmaximize = () => {
   }
 };
 const close$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.close');
     default:
@@ -8548,7 +8575,7 @@ const close$2 = () => {
   }
 };
 const exit$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('Exit.exit');
     default:
@@ -8556,7 +8583,7 @@ const exit$2 = () => {
   }
 };
 const openNew = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.openNew');
     default:
@@ -8564,7 +8591,7 @@ const openNew = () => {
   }
 };
 const zoomIn = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.zoomIn');
     default:
@@ -8572,7 +8599,7 @@ const zoomIn = () => {
   }
 };
 const zoomOut = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.zoomOut');
     default:
@@ -8580,7 +8607,7 @@ const zoomOut = () => {
   }
 };
 const zoomReset = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.zoomReset');
     default:
@@ -8613,7 +8640,7 @@ const launchClipBoardWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.clipBoardWorkerPath', clipBoardWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'ClipBoard.initialize', getPlatform());
+  await invoke$x(ipc, 'ClipBoard.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -8646,14 +8673,14 @@ const readNativeFiles = async () => {
 };
 const writeImage = async blob => {
   try {
-    return await invoke$v('ClipBoard.writeImage', blob);
+    return await invoke$w('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$v('ClipBoard.execCopy');
+    return await invoke$w('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
@@ -8680,12 +8707,12 @@ const ClipBoard_ipc = {
 };
 
 const getColorThemeNames = async () => {
-  return invoke$s('ColorTheme.getColorThemeNames');
+  return invoke$t('Extensions.getColorThemeNames');
 };
 
 const name$1Z = 'ColorTheme';
 const Commands$20 = {
-  hydrate: hydrate$8,
+  hydrate: hydrate$a,
   reload: reload$4,
   setColorTheme: setColorTheme,
   getColorThemeNames: getColorThemeNames
@@ -8703,7 +8730,7 @@ const getProductNameLong = () => {
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$t('ElectronDialog.showOpenDialog', title, properties);
+  return invoke$u('ElectronDialog.showOpenDialog', title, properties);
 };
 const showMessageBox = async options => {
   // TODO maybe request window id here instead of at caller
@@ -8715,7 +8742,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$t('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$u('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Error$2 = 'error';
@@ -8743,7 +8770,7 @@ const promptError = async (message, confirmMessage, title) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$v('ConfirmPrompt.prompt', message);
+  const result = await invoke$w('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -8783,14 +8810,14 @@ const ok = () => {
 let _mockId$1 = 0;
 const showMockConfirmPrompt = async (message, options) => {
   const ipc = get$d();
-  const result = await invoke$w(ipc, 'Test.executeMock', _mockId$1, message, options);
+  const result = await invoke$x(ipc, 'Test.executeMock', _mockId$1, message, options);
   return result;
 };
 const mock$1 = mockId => {
   _mockId$1 = mockId;
 };
 const prompt$1 = async (message, {
-  platform = getPlatform(),
+  platform = getPlatform$1(),
   confirmMessage = ok(),
   title = '',
   cancelMessage = cancel()
@@ -8812,7 +8839,7 @@ const prompt$1 = async (message, {
 };
 const showErrorMessage = ({
   message,
-  platform = getPlatform(),
+  platform = getPlatform$1(),
   confirmMessage = ok(),
   title = ''
 }) => {
@@ -8837,21 +8864,21 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = options => {
-  return invoke$t('ElectronContentTracing.startRecording', options);
+  return invoke$u('ElectronContentTracing.startRecording', options);
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$t('ElectronContentTracing.stopRecording');
+  return invoke$u('ElectronContentTracing.stopRecording');
 };
 
 const showItemInFolder = fullPath => {
-  return invoke$t('OpenExternal.showItemInFolder', fullPath);
+  return invoke$u('OpenExternal.showItemInFolder', fullPath);
 };
 const openExternal$2 = url => {
-  return invoke$t('OpenExternal.openExternal', url);
+  return invoke$u('OpenExternal.openExternal', url);
 };
 
 const openNativeFolderWeb = absolutePath => {
@@ -8859,7 +8886,7 @@ const openNativeFolderWeb = absolutePath => {
 };
 const openNativeFolderRemote = async absolutePath => {
   try {
-    await invoke$t(OpenNativeFolder, /* path */absolutePath);
+    await invoke$u(OpenNativeFolder, /* path */absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`);
   }
@@ -8868,7 +8895,7 @@ const openNativeFolderElectron = async absolutePath => {
   await showItemInFolder(absolutePath);
 };
 const openNativeFolder = async absolutePath => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return openNativeFolderWeb();
     case Remote:
@@ -8879,7 +8906,7 @@ const openNativeFolder = async absolutePath => {
 };
 
 const start = async () => {
-  if (getPlatform() !== Electron$1) {
+  if (getPlatform$1() !== Electron$1) {
     throw new Error('content tracing is only supported in electron');
   }
   await startRecording({
@@ -8887,7 +8914,7 @@ const start = async () => {
   });
 };
 const stop = async () => {
-  if (getPlatform() !== Electron$1) {
+  if (getPlatform$1() !== Electron$1) {
     throw new Error('content tracing is only supported in electron');
   }
   const path = await stopRecording();
@@ -8911,7 +8938,7 @@ const hasContextMenuNativePreference = () => {
   return value === 'native';
 };
 const getModule$2 = () => {
-  if (getPlatform() === Electron$1 && hasContextMenuNativePreference()) {
+  if (getPlatform$1() === Electron$1 && hasContextMenuNativePreference()) {
     return Promise.resolve().then(function () { return ContextMenuElectron; });
   }
   return Promise.resolve().then(function () { return ContextMenuBrowser; });
@@ -8978,26 +9005,26 @@ const Debug_ipc = {
 
 const attachDebugger = async pid => {
   number(pid);
-  await invoke$t('AttachDebugger.attachDebugger', pid);
+  await invoke$u('AttachDebugger.attachDebugger', pid);
 };
 
 const getPid = () => {
-  return invoke$t('Process.getPid');
+  return invoke$u('Process.getPid');
 };
 const getElectronVersion = () => {
-  return invoke$t('ElectronProcess.getElectronVersion');
+  return invoke$u('ElectronProcess.getElectronVersion');
 };
 const getNodeVersion = () => {
-  return invoke$t('Process.getNodeVersion');
+  return invoke$u('Process.getNodeVersion');
 };
 const getChromeVersion = () => {
-  return invoke$t('ElectronProcess.getChromeVersion');
+  return invoke$u('ElectronProcess.getChromeVersion');
 };
 const getV8Version = () => {
-  return invoke$t('Process.getV8Version');
+  return invoke$u('Process.getV8Version');
 };
 const getArch = () => {
-  return invoke$t('Process.getArch');
+  return invoke$u('Process.getArch');
 };
 
 const debugSharedProcess = async () => {
@@ -9017,10 +9044,10 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$t('Crash.crashSharedProcess');
+  return invoke$u('Crash.crashSharedProcess');
 };
 const crashMainProcess = () => {
-  return invoke$t('Crash.crashMainProcess');
+  return invoke$u('Crash.crashMainProcess');
 };
 
 const toggleDeveloperTools$1 = () => {
@@ -9036,21 +9063,21 @@ const openCacheFolder = async () => {
   await openNativeFolder(cacheFolder);
 };
 const openDataFolder = async () => {
-  const dataFolder = await invoke$t(/* Platform.getDataDir */'Platform.getDataDir');
+  const dataFolder = await invoke$u(/* Platform.getDataDir */'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 const openLogsFolder = async () => {
   // TODO only in electron or in remote when it is the same machine
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return;
   }
   const logsFolder = await getLogsDir();
-  await invoke$t('FileSystem.mkdir', /* path */logsFolder);
+  await invoke$u('FileSystem.mkdir', /* path */logsFolder);
   await openNativeFolder(logsFolder);
 };
 
 const getPerformanceEntries = () => {
-  return invoke$t('ElectronDeveloper.getPerformanceEntries');
+  return invoke$u('ElectronDeveloper.getPerformanceEntries');
 };
 
 const toMarkdownTable = (header, rows) => {
@@ -9266,7 +9293,7 @@ const formatBytes = bytes => {
 };
 
 const getModule$1 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return Promise.resolve().then(function () { return ProcessExplorerElectron; });
     case Remote:
@@ -9288,10 +9315,10 @@ const open$4 = async () => {
 // TODO no export, this is internal only
 
 const getNodeTiming = () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return undefined;
   }
-  return invoke$t(/* command */'Performance.getNodeStartupTiming');
+  return invoke$u(/* command */'Performance.getNodeStartupTiming');
 };
 const getMeasureEntries = () => {
   const measureEntries = getEntriesByType(Measure);
@@ -9302,7 +9329,7 @@ const getMeasureEntries = () => {
   };
 };
 const getElectronEntries = async () => {
-  if (getPlatform() === Web$1 || getPlatform() === Remote) {
+  if (getPlatform$1() === Web$1 || getPlatform$1() === Remote) {
     return undefined;
   }
   const result = await getPerformanceEntries();
@@ -9317,12 +9344,12 @@ const getStartupPerformanceContent = async () => {
   //   LifeCycle.once(LifeCycle.PHASE_FIFTEEN, resolve)
   // )
   let nodeStartupTiming;
-  if (getPlatform() !== Web$1) {
+  if (getPlatform$1() !== Web$1) {
     nodeStartupTiming = await getNodeTiming();
   }
   const measureEntries = getMeasureEntries();
   let electronEntries;
-  if (getPlatform() === Electron$1) {
+  if (getPlatform$1() === Electron$1) {
     electronEntries = await getElectronEntries();
   }
   const text = formatStartupPerformance({
@@ -9380,13 +9407,13 @@ const formatRendererProcessData = ({
   return toMarkdownTable(header, rows);
 };
 const getSharedProcessMemoryUsage = () => {
-  return invoke$t(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
+  return invoke$u(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$v('Performance.getMemory');
+  return invoke$w('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$v('Performance.measureUserAgentSpecificMemory');
+  return invoke$w('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -9435,19 +9462,19 @@ const showMemoryUsage = async () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$t(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
+  return invoke$u(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
 };
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$t(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
+  await invoke$u(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
 };
 const createSharedProcessProfile = async () => {
-  await invoke$t(/* Developer.createProfile */'Developer.createProfile');
+  await invoke$u(/* Developer.createProfile */'Developer.createProfile');
 };
 const reloadIconTheme = async () => {
   await hydrate$4();
 };
 const reloadColorTheme = async () => {
-  await hydrate$8();
+  await hydrate$a();
 };
 const showColorThemeCss = async () => {
   // @ts-ignore
@@ -9519,7 +9546,7 @@ const Developer_ipc = {
 };
 
 const load$1 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return Promise.resolve().then(function () { return OpenFolderWeb; });
     case Remote:
@@ -9551,7 +9578,7 @@ const openFileElectron = async () => {
   await openUri$1(file);
 };
 const openFile$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return openFileWeb();
     case Remote:
@@ -9590,7 +9617,7 @@ const showMessage = async (message, options) => {
     message,
     options
   };
-  if (getPlatform() === Electron$1) {
+  if (getPlatform$1() === Electron$1) {
     // @ts-ignore
     const index = await showMessageBox(/* message */message.message);
     if (index === -1) {
@@ -9629,12 +9656,12 @@ const revokeObjectUrl = url => {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$v(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$w(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$t(DownloadDownload, /* url */url, /* outFile */outFile);
+  await invoke$u(DownloadDownload, /* url */url, /* outFile */outFile);
 };
 const downloadJson = async (json, fileName) => {
   let url = '';
@@ -9728,7 +9755,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$v(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$w(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$1S = {
@@ -9947,7 +9974,7 @@ const getMenuEntries$e = () => {
     flags: None$9,
     command: 'Main.saveAll'
   }];
-  if (getPlatform() === Electron$1) {
+  if (getPlatform$1() === Electron$1) {
     entries.push(menuEntrySeparator, {
       id: 'exit',
       label: exit$1(),
@@ -9998,17 +10025,17 @@ const about = () => {
 };
 
 const isAutoUpdateSupported = () => {
-  if (getPlatform() !== Electron$1) {
+  if (getPlatform$1() !== Electron$1) {
     return false;
   }
-  return invoke$t('IsAutoUpdateSupported.isAutoUpdateSupported');
+  return invoke$u('IsAutoUpdateSupported.isAutoUpdateSupported');
 };
 
 const id$9 = Help$1;
 const getMenuEntries$c = async () => {
   const autoUpdateSupported = await isAutoUpdateSupported();
   const entries = [];
-  if (getPlatform() !== Web$1) {
+  if (getPlatform$1() !== Web$1) {
     entries.push({
       id: 'toggleDeveloperTools',
       label: toggleDeveloperTools(),
@@ -10295,7 +10322,7 @@ const state$c = {
 };
 const setItems = async items => {
   const windowId = await getWindowId();
-  return invoke$t('ElectronApplicationMenu.setItems', windowId, items);
+  return invoke$u('ElectronApplicationMenu.setItems', windowId, items);
 };
 const getEntryMap = async modules => {
   const map = Object.create(null);
@@ -10358,7 +10385,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$t('ElectronClipBoard.writeText', text);
+  return invoke$u('ElectronClipBoard.writeText', text);
 };
 
 const name$1N = 'ElectronClipBoard';
@@ -10387,7 +10414,7 @@ const ElectronContextMenu_ipc = {
 
 const name$1L = 'ElectronWindow';
 const Commands$1N = {
-  close: close$3,
+  close: close$4,
   maximize: maximize$1,
   minimize: minimize$1,
   openNew: openNew$1,
@@ -10417,7 +10444,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$t('Exit.exit');
+  return invoke$u('Exit.exit');
 };
 
 const name$1J = 'Exit';
@@ -10557,7 +10584,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$v('FilePicker.showDirectoryPicker', options);
+    return await invoke$w('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10568,11 +10595,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$v('FilePicker.showFilePicker', options);
+  return invoke$w('FilePicker.showFilePicker', options);
 };
 const doShowSaveFilePicker = async options => {
   try {
-    return await invoke$v('FilePicker.showSaveFilePicker', options);
+    return await invoke$w('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10585,7 +10612,7 @@ const doShowSaveFilePicker = async options => {
 let _mockId = 0;
 const doShowMockSaveFilePicker = async () => {
   const ipc = get$d();
-  const result = await invoke$w(ipc, 'Test.executeMock', _mockId);
+  const result = await invoke$x(ipc, 'Test.executeMock', _mockId);
   return result;
 };
 const showSaveFilePicker = async options => {
@@ -10676,15 +10703,15 @@ const show$8 = async (uri, top, left) => {
     if (version !== state$a.versionId) {
       return;
     }
-    await invoke$v(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$w(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$v(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$w(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
   }
 };
 const hide$4 = async () => {
   ++state$a.versionId;
-  await invoke$v(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$w(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -10883,7 +10910,7 @@ const maybeLoad = async id => {
     return {};
   }
 };
-const getKeyBindings$k = async () => {
+const getKeyBindings$l = async () => {
   const ids = Object.keys(ViewletModuleId);
   const modules = await Promise.all(ids.map(maybeLoad));
   const keyBindingsPromises = await Promise.all(modules.map(getViewletKeyBindings));
@@ -10895,7 +10922,7 @@ const name$1x = 'KeyBindingsInitial';
 
 // prettier-ignore
 const Commands$1z = {
-  getKeyBindings: getKeyBindings$k
+  getKeyBindings: getKeyBindings$l
 };
 
 const KeyBindingsInitial_ipc = {
@@ -11184,22 +11211,22 @@ const state$8 = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$v(/* ActivityBar.focus */717115);
+  await invoke$w(/* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$v(/* StatusBar.focus */8882);
+  await invoke$w(/* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$v(/* Panel.focus */6664);
+  await invoke$w(/* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$v(/* SideBar.focus */5554);
+  await invoke$w(/* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$v(/* TitleBar.focus */1331);
+  await invoke$w(/* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$v(/* Main.focus */2145);
+  await invoke$w(/* Main.focus */2145);
 };
 const focusPart = part => {
   state$8.focusedPart = part;
@@ -11310,7 +11337,7 @@ const create$P = async (type, text) => {
     type,
     text
   });
-  await invoke$v(/* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$w(/* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -11319,7 +11346,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$v(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$w(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$1 = index => {
   console.log('handle click');
@@ -11335,7 +11362,7 @@ const handleClick$1 = index => {
   });
 };
 const dispose$q = async id => {
-  await invoke$v(/* Notification.dispose */'Notification.dispose', /* id */id);
+  await invoke$w(/* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$1r = 'Notification';
@@ -11354,7 +11381,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async url => {
   try {
-    await invoke$v(/* Open.openUrl */'Open.openUrl', /* url */url);
+    await invoke$w(/* Open.openUrl */'Open.openUrl', /* url */url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -11363,7 +11390,7 @@ const openUrlElectron = async url => {
   await openNew$1(url);
 };
 const openUrl = async url => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return openUrlElectron(url);
     default:
@@ -11431,7 +11458,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$v('Prompt.prompt', message, defaultValue);
+  return invoke$w('Prompt.prompt', message, defaultValue);
 };
 
 const name$1m = 'Prompt';
@@ -11446,7 +11473,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$t('RebuildNodePty.rebuildNodePty');
+  await invoke$u('RebuildNodePty.rebuildNodePty');
 };
 
 const name$1l = 'RebuildNodePty';
@@ -11582,19 +11609,19 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$v('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$w('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$v('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$w('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$v('TestFrameWork.showOverlay', ...args);
+  return invoke$w('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$v('TestFrameWork.performAction', ...args);
+  return invoke$w('TestFrameWork.performAction', ...args);
 };
 const checkConditionError = (...args) => {
-  return invoke$v('TestFrameWork.checkConditionError', ...args);
+  return invoke$w('TestFrameWork.checkConditionError', ...args);
 };
 
 const name$1d = 'TestFrameWork';
@@ -11663,10 +11690,10 @@ const Window_ipc = {
 
 const name$19 = 'Workspace';
 const Commands$1a = {
-  close: close$4,
+  close: close$3,
   getPath: getPath,
   getUri: getUri$1,
-  hydrate: hydrate$9,
+  hydrate: hydrate$6,
   setPath: setPath,
   setUri: setUri
 };
@@ -11679,7 +11706,7 @@ const Workspace_ipc = {
 
 const name$18 = 'WindowTitle';
 const Commands$19 = {
-  set: set$f
+  set: set$a
 };
 
 const WindowTitle_ipc = {
@@ -11689,10 +11716,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$v('PointerCapture.mock');
+  return invoke$w('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$v('PointerCapture.unmock');
+  return invoke$w('PointerCapture.unmock');
 };
 
 const name$17 = 'PointerCapture';
@@ -11830,10 +11857,10 @@ const ExtensionHostDialog_ipc = {
 const set$4 = async (url, contentSecurityPolicy) => {
   string(url);
   string(contentSecurityPolicy);
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return;
   }
-  await invoke$t('ContentSecurityPolicy.set', url, contentSecurityPolicy);
+  await invoke$u('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
 const set$3 = async (url, contentSecurityPolicy) => {
@@ -11865,7 +11892,7 @@ const SendMessagePortToElectron_ipc = {
 const terminalWorkerUrl = `${assetDir}/packages/terminal-worker/dist/terminalWorkerMain.js`;
 
 const launchTerminalWorker = async () => {
-  const name = getPlatform() === Electron$1 ? 'Terminal Worker (Electron)' : 'Terminal Worker';
+  const name = getPlatform$1() === Electron$1 ? 'Terminal Worker (Electron)' : 'Terminal Worker';
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
@@ -11883,7 +11910,7 @@ const {
 const create$O = async canvasId => {
   number(canvasId);
   const id = create$$();
-  await invoke$v('OffscreenCanvas.create', canvasId, id);
+  await invoke$w('OffscreenCanvas.create', canvasId, id);
   const canvas = acquire(id);
   return canvas;
 };
@@ -12168,7 +12195,7 @@ const ExtensionHostClosingTagCompletion_ipc = {
 const sendMessagePortToRendererProcess$1 = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$c(initialCommand, port);
+  await invokeAndTransfer$d(initialCommand, port);
 };
 
 const name$R = 'SendMessagePortToRendererProcess';
@@ -12229,7 +12256,7 @@ const launchEditorWorker = async () => {
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
-  await invoke$w(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  await invoke$x(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
@@ -12239,39 +12266,41 @@ const {
 } = getOrCreateWorker(launchEditorWorker);
 const actualInvoke = invoke$i;
 
-const extensionManagementWorkerUrl = `${assetDir}/packages/extension-management-worker/dist/extensionManagementWorkerMain.js`;
+const markdownWorkerUrl = `${assetDir}/packages/markdown-worker/dist/markdownWorkerMain.js`;
 
-const launchExtensionManagementWorker = async () => {
-  const name = 'Extension Management Worker';
+const launchMarkdownWorker = async () => {
+  const name = 'Markdown Worker';
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.extensionManagementWorkerPath', extensionManagementWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.markdownWorkerPath', markdownWorkerUrl)
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$4} = getOrCreateWorker(launchExtensionManagementWorker);
+  invoke: invoke$h,
+  invokeAndTransfer: invokeAndTransfer$4
+} = getOrCreateWorker(launchMarkdownWorker);
 
-const markdownWorkerUrl = `${assetDir}/packages/markdown-worker/dist/markdownWorkerMain.js`;
+const iframeWorkerUrl = `${assetDir}/packages/iframe-worker/dist/iframeWorkerMain.js`;
 
-const launchMarkdownWorker = async () => {
-  const name = 'Markdown Worker';
+const launchIframeWorker = async () => {
+  const name = 'Iframe Worker';
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.markdownWorkerPath', markdownWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.iframeWorkerPath', iframeWorkerUrl)
   });
   handleIpc(ipc);
+  await invoke$x(ipc, 'Iframes.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invoke: invoke$h,
   invokeAndTransfer: invokeAndTransfer$3
-} = getOrCreateWorker(launchMarkdownWorker);
+} = getOrCreateWorker(launchIframeWorker);
 
 const sourceControlWorkerUrl = `${assetDir}/packages/source-control-worker/dist/sourceControlWorkerMain.js`;
 
@@ -12283,7 +12312,7 @@ const launchSourceControlWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.sourceControlWorkerPath', sourceControlWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Initialize.initialize');
+  await invoke$x(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -12318,12 +12347,12 @@ const sendMessagePortToExtensionHostWorker = async (port, initialCommand, rpcId)
 const sendMessagePortToSharedProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$a(initialCommand, port, rpcId);
+  await invokeAndTransfer$b(initialCommand, port, rpcId);
 };
 const sendMessagePortToErrorWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$b(initialCommand, port, rpcId);
+  await invokeAndTransfer$c(initialCommand, port, rpcId);
 };
 const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12333,12 +12362,12 @@ const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$c(initialCommand, port, rpcId);
+  await invokeAndTransfer$d(initialCommand, port, rpcId);
 };
 const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$3(initialCommand, port, rpcId);
+  await invokeAndTransfer$4(initialCommand, port, rpcId);
 };
 const sendMessagePortToFileSystemWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12363,7 +12392,12 @@ const sendMessagePortToSourceControlWorker = async (port, initialCommand, rpcId)
 const sendMessagePortToExtensionManagementWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$4(initialCommand, port, rpcId);
+  await invokeAndTransfer$a(initialCommand, port, rpcId);
+};
+const sendMessagePortToIframeWorker = async (port, initialCommand, rpcId) => {
+  object(port);
+  string(initialCommand);
+  await invokeAndTransfer$3(initialCommand, port, rpcId);
 };
 
 // TODO add only one function sendMessagePortToRpc(rpcId) which sends it to the matching rpc module
@@ -12380,7 +12414,8 @@ const Commands$Q = {
   sendMessagePortToSharedProcess: sendMessagePortToSharedProcess,
   sendMessagePortToSourceControlWorker: sendMessagePortToSourceControlWorker,
   sendMessagePortToTextMeasurementWorker: sendMessagePortToTextMeasurementWorker,
-  sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker
+  sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToIframeWorker: sendMessagePortToIframeWorker
 };
 
 const SendMessagePortToExtensionHostWorker_ipc = {
@@ -12456,7 +12491,7 @@ const Transferrable_ipc = {
 };
 
 const getWebViewsNode = async () => {
-  const webViews = await invoke$t('ExtensionHost.getWebViews');
+  const webViews = await invoke$u('ExtensionHost.getWebViews');
   return webViews;
 };
 
@@ -12468,7 +12503,7 @@ const getWebViewsWeb = async () => {
 };
 
 const getWebViewsDefault = async () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return getWebViewsWeb();
     case Test$1:
@@ -12489,7 +12524,7 @@ const isGitpod = getHost().endsWith('.gitpod.io');
 const WebView = 'lvce-oss-webview';
 
 const setPort = async (uid, port, origin, portType) => {
-  await invokeAndTransfer$c('WebView.setPort', uid, port, origin, portType);
+  await invokeAndTransfer$d('WebView.setPort', uid, port, origin, portType);
 };
 
 /**
@@ -12505,7 +12540,7 @@ const create3 = async (uri, id) => {
   await invoke$s('WebView.create3', {
     id,
     uri,
-    platform: getPlatform(),
+    platform: getPlatform$1(),
     isGitpod: isGitpod,
     assetDir: assetDir,
     webViewScheme: WebView,
@@ -12523,13 +12558,13 @@ const unregisterInterceptor = async id => {
 };
 const compat = {
   sharedProcessInvoke(...args) {
-    return invoke$t(...args);
+    return invoke$u(...args);
   },
   rendererProcessInvoke(...args) {
-    return invoke$v(...args);
+    return invoke$w(...args);
   },
   rendererProcessInvokeAndTransfer(...args) {
-    return invokeAndTransfer$c(...args);
+    return invokeAndTransfer$d(...args);
   },
   extensionHostWorkerInvokeAndTransfer(...args) {
     return invokeAndTransfer$9(...args);
@@ -12594,7 +12629,7 @@ const getOrCreate$1 = () => {
 };
 const invoke$f = async (method, ...params) => {
   const ipc = await getOrCreate$1();
-  return invoke$w(ipc, method, ...params);
+  return invoke$x(ipc, method, ...params);
 };
 
 const name$K = 'SearchProcess';
@@ -12692,14 +12727,14 @@ const handleExtensionStatusUpdate = async () => {
 };
 const invalidateExtensionsCache = async () => {
   try {
-    await invoke$s('Extensions.invalidateExtensionsCache');
+    await invoke$t('Extensions.invalidateExtensionsCache');
     await execute$3('Layout.handleExtensionsChanged');
   } catch {
     // ignore
   }
 };
 const uninstall = async id => {
-  await invoke$t(/* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
+  await invoke$u(/* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
   invalidateExtensionsCache();
 };
 const disable = async id => {
@@ -12707,7 +12742,7 @@ const disable = async id => {
     if (isTest()) {
       disabledIds = [...disabledIds, id];
     } else {
-      await invoke$t(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
+      await invoke$u(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -12720,7 +12755,7 @@ const enable = async id => {
     if (isTest()) {
       disabledIds = disabledIds.filter(existing => existing !== id);
     } else {
-      await invoke$t(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
+      await invoke$u(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
     }
     await invalidateExtensionsCache();
     return undefined;
@@ -12729,10 +12764,10 @@ const enable = async id => {
   }
 };
 const getAllExtensions = async () => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return [];
   }
-  return invoke$t(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+  return invoke$u(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
 };
 let disabledIds = [];
 const getExtension2 = async id => {
@@ -12747,7 +12782,7 @@ const getExtension2 = async id => {
   return extension;
 };
 const getExtensionsEtag = async () => {
-  const etag = await invoke$t('ExtensionManagement.getExtensionsEtag');
+  const etag = await invoke$u('ExtensionManagement.getExtensionsEtag');
   return etag;
 };
 
@@ -12790,10 +12825,10 @@ const Markdown_ipc = {
 };
 
 const measureTextHeight = (text, fontFamily, fontSize) => {
-  return invoke$v('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
+  return invoke$w('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
 };
 const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke$v('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+  return invoke$w('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
 };
 
 const name$D = 'MeasureTextHeight';
@@ -12858,7 +12893,7 @@ const getCommands$g = async () => {
 
 const Css$D = ["/css/parts/ViewletAbout.css", "/css/parts/ViewletDialog.css"];
 
-const getKeyBindings$j = () => {
+const getKeyBindings$k = () => {
   return invoke$n('About.getKeyBindings');
 };
 
@@ -12928,7 +12963,7 @@ const ViewletAbout_ipc = {
   Css: Css$D,
   create: create$N,
   getCommands: getCommands$g,
-  getKeyBindings: getKeyBindings$j,
+  getKeyBindings: getKeyBindings$k,
   hasFunctionalEvents: hasFunctionalEvents$g,
   hasFunctionalRender: hasFunctionalRender$B,
   hasFunctionalRootRender: hasFunctionalRootRender$q,
@@ -13093,7 +13128,7 @@ const Backquote = 89;
 const Backslash = 91;
 const Plus = 132;
 
-const getKeyBindings$i = () => {
+const getKeyBindings$j = () => {
   return [{
     key: DownArrow,
     command: 'ActivityBar.focusNext',
@@ -13250,7 +13285,7 @@ const ViewletActivityBar_ipc = {
   create: create$M,
   getCommands: getCommands$f,
   getDisplayName: getDisplayName$2,
-  getKeyBindings: getKeyBindings$i,
+  getKeyBindings: getKeyBindings$j,
   getMenus: getMenus$9,
   getQuickPickMenuEntries: getQuickPickMenuEntries$4,
   hasFunctionalEvents: hasFunctionalEvents$f,
@@ -13493,7 +13528,7 @@ const create$K = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$F = async state => {
-  const browserViewMap = await invoke$t('ElectronBrowserView.getAll');
+  const browserViewMap = await invoke$u('ElectronBrowserView.getAll');
   return {
     ...state,
     browserViewMap
@@ -13543,7 +13578,7 @@ const create$J = (id, uri, x, y, width, height) => {
 };
 const loadContent$E = state => {
   const update = async () => {
-    await invoke$v(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$w(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -13609,7 +13644,7 @@ const Commands$z = {};
 
 const Css$z = ["/css/parts/ViewletAbout.css", "/css/parts/ViewletDialog.css"];
 
-const getKeyBindings$h = () => {
+const getKeyBindings$i = () => {
   return [];
 };
 
@@ -13641,7 +13676,7 @@ const ViewletConfirm_ipc = {
   Commands: Commands$z,
   Css: Css$z,
   create: create$I,
-  getKeyBindings: getKeyBindings$h,
+  getKeyBindings: getKeyBindings$i,
   handleClickCancel,
   handleClickClose: handleClickClose$1,
   handleClickOk,
@@ -13728,7 +13763,7 @@ const Commands$y = {
 
 const Css$y = ["/css/parts/ViewletDebugConsole.css"];
 
-const getKeyBindings$g = () => {
+const getKeyBindings$h = () => {
   return [{
     key: Enter$1,
     command: 'Debug Console.evaluate',
@@ -13913,7 +13948,7 @@ const ViewletDebugConsole_ipc = {
   clear: clear$2,
   create: create$H,
   evaluate,
-  getKeyBindings: getKeyBindings$g,
+  getKeyBindings: getKeyBindings$h,
   getQuickPickMenuEntries: getQuickPickMenuEntries$3,
   handleFocus: handleFocus$1,
   handleInput: handleInput$2,
@@ -15064,7 +15099,7 @@ const Commands$u = {
 
 const Css$t = ["/css/parts/E2eTest.css"];
 
-const getKeyBindings$f = () => {
+const getKeyBindings$g = () => {
   return [];
 };
 
@@ -15159,7 +15194,7 @@ const ViewletE2eTest_ipc = {
   Css: Css$t,
   create: create$A,
   executeTest: executeTest$1,
-  getKeyBindings: getKeyBindings$f,
+  getKeyBindings: getKeyBindings$g,
   handleClickAt: handleClickAt$1,
   handleLoad: handleLoad$1,
   handleSashCornerPointerDown,
@@ -15191,8 +15226,8 @@ const create$z = (id, uri, x, y, width, height) => {
   };
 };
 const getTests = async () => {
-  const root = await invoke$t('Platform.getRoot');
-  const testPath = await invoke$t('Platform.getTestPath');
+  const root = await invoke$u('Platform.getRoot');
+  const testPath = await invoke$u('Platform.getTestPath');
   const absolutePath = `${root}/${testPath}/src`;
   const dirents = await readDirWithFileTypes$9(absolutePath);
   const filteredDirents = dirents.slice(1);
@@ -15288,7 +15323,7 @@ const Commands$t = {
 
 const Css$s = ["/css/parts/E2eTests.css"];
 
-const getKeyBindings$e = () => {
+const getKeyBindings$f = () => {
   return [];
 };
 
@@ -15417,7 +15452,7 @@ const ViewletE2eTests_ipc = {
   Css: Css$s,
   create: create$z,
   executeTest,
-  getKeyBindings: getKeyBindings$e,
+  getKeyBindings: getKeyBindings$f,
   handleClickAt,
   handleContextMenu: handleContextMenu$2,
   handleLoad,
@@ -15956,7 +15991,7 @@ const Commands$s = {
   ...wrapEditorCommands(ids),
   // TODO
   async showOverlayMessage(state, editor, ...args) {
-    await invoke$v(...args);
+    await invoke$w(...args);
     return state;
   },
   async hotReload(state, editor, ...args) {
@@ -15973,7 +16008,7 @@ const CommandsWithSideEffectsLazy$1 = {
   }
 };
 
-const getKeyBindings$d = uid => {
+const getKeyBindings$e = uid => {
   // @ts-ignore
   return actualInvoke('Editor.getKeyBindings', uid);
 };
@@ -16040,7 +16075,7 @@ const ViewletEditorText_ipc = {
   dispose: dispose$l,
   focus: focus$4,
   getDynamicCss,
-  getKeyBindings: getKeyBindings$d,
+  getKeyBindings: getKeyBindings$e,
   getMenus: getMenus$8,
   getQuickPickMenuEntries: getQuickPickMenuEntries$2,
   handleEditorChange: handleEditorChange$1,
@@ -16233,7 +16268,7 @@ const launchExplorerWorker = async () => {
     name: 'Explorer Worker'
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Explorer.initialize');
+  await invoke$x(ipc, 'Explorer.initialize');
   return ipc;
 };
 
@@ -16260,7 +16295,7 @@ const create$t = (id, uri, x, y, width, height, args, parentUid) => {
     y,
     width,
     height,
-    platform: getPlatform()
+    platform: getPlatform$1()
   };
 };
 const loadContent$t = async (state, savedState) => {
@@ -16353,7 +16388,7 @@ const getCommands$e = async () => {
 
 const Css$p = [];
 
-const getKeyBindings$c = () => {
+const getKeyBindings$d = () => {
   return invoke$c('Explorer.getKeyBindings');
 };
 
@@ -16453,7 +16488,7 @@ const ViewletExplorer_ipc = {
   dispose: dispose$j,
   getCommands: getCommands$e,
   getDisplayName: getDisplayName$1,
-  getKeyBindings: getKeyBindings$c,
+  getKeyBindings: getKeyBindings$d,
   getMouseActions,
   hasFunctionalEvents: hasFunctionalEvents$e,
   hasFunctionalRender: hasFunctionalRender$p,
@@ -16482,7 +16517,7 @@ const launchExtensionDetailViewWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.extensionDetailViewWorkerPath', extensionDetailViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'ExtensionDetail.initialize');
+  await invoke$x(ipc, 'ExtensionDetail.initialize');
   return ipc;
 };
 
@@ -16513,7 +16548,7 @@ const create$s = (id, uri, x, y, width, height) => {
 // TODO when there are multiple extension with the same id,
 // probably need to pass extension location from extensions viewlet
 const loadContent$s = async (state, savedState) => {
-  await invoke$b('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform(), assetDir);
+  await invoke$b('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
   const isTest$1 = isTest();
   await invoke$b('ExtensionDetail.loadContent2', state.uid, savedState, isTest$1);
   const diffResult = await invoke$b('ExtensionDetail.diff2', state.uid);
@@ -16532,7 +16567,7 @@ const hotReload$a = async state => {
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
   await restart$7('ExtensionDetail.terminate');
-  await invoke$b('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform(), assetDir);
+  await invoke$b('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
   await invoke$b('ExtensionDetail.loadContent2', state.uid, {});
   const diffResult = await invoke$b('ExtensionDetail.diff2', state.uid);
   const commands = await invoke$b('ExtensionDetail.render2', state.uid, diffResult);
@@ -16576,6 +16611,14 @@ const getCommands$d = async () => {
 
 const Css$o = ["/css/parts/AdditionalDetails.css", "/css/parts/BrowserScrollBar.css", "/css/parts/Category.css", "/css/parts/FeatureContent.css", "/css/parts/Features.css", "/css/parts/Markdown.css", "/css/parts/Message.css", "/css/parts/ScrollToTop.css", "/css/parts/ViewletExtensionDetail.css", "/css/parts/ViewletExtensionDetailHeader.css", "/css/parts/ViewletExtensionDetailTabs.css"];
 
+const getKeyBindings$c = async () => {
+  try {
+    return await invoke$b('ExtensionDetail.getKeyBindings');
+  } catch {
+    return [];
+  }
+};
+
 const menus$a = [];
 const getMenus$7 = async () => {
   try {
@@ -16620,6 +16663,7 @@ const ViewletExtensionDetail_ipc = {
   Css: Css$o,
   create: create$s,
   getCommands: getCommands$d,
+  getKeyBindings: getKeyBindings$c,
   getMenus: getMenus$7,
   hasFunctionalEvents: hasFunctionalEvents$d,
   hasFunctionalRender: hasFunctionalRender$o,
@@ -16637,7 +16681,7 @@ const ViewletExtensionDetail_ipc = {
 const extensionSearchViewWorkerUrl = `${assetDir}/packages/extension-search-view-worker/dist/extensionSearchViewWorkerMain.js`;
 
 const launchExtensionSearchViewWorker = async () => {
-  const name = getPlatform() === Electron$1 ? 'Extension Search View Worker (Electron)' : 'Extension Search View Worker';
+  const name = getPlatform$1() === Electron$1 ? 'Extension Search View Worker (Electron)' : 'Extension Search View Worker';
   const ipc = await create$10({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
@@ -16645,7 +16689,7 @@ const launchExtensionSearchViewWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$w(ipc, 'SearchExtensions.initialize');
+    await invoke$x(ipc, 'SearchExtensions.initialize');
   } catch {
     // ignore
   }
@@ -16672,7 +16716,7 @@ const create$r = (id, uri, x, y, width, height) => {
     height,
     x,
     y,
-    platform: getPlatform(),
+    platform: getPlatform$1(),
     assetDir: assetDir
   };
 };
@@ -17022,7 +17066,7 @@ const launchReferencesWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.referencesWorkerPath', referencesWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'References.initialize');
+  await invoke$x(ipc, 'References.initialize');
   return ipc;
 };
 
@@ -17202,7 +17246,7 @@ const loadContent$o = async (state, savedState) => {
   return loadContent$p(state, savedState);
 };
 const contentLoaded$5 = state => {
-  set$a('Locations', {
+  set$b('Locations', {
     factory: ViewletLocations,
     state
   });
@@ -17680,7 +17724,7 @@ const ViewletKeyBindings_ipc = {
 };
 
 const getDefaultTitleBarHeight = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return 29;
     default:
@@ -17807,7 +17851,7 @@ const Preview$1 = {
   kReady: 'previewVisible'
 };
 
-const commit = '5bdc1ac';
+const commit = '6e66e1c';
 
 // TODO instead of reordering commands, have two command arrays
 // one for normal commands
@@ -18019,7 +18063,9 @@ const create$l = id => {
     sideBarView: '',
     updateState: 'none',
     updateProgress: 0,
-    commit: commit
+    commit: commit,
+    platform: platform,
+    assetDir
   };
 };
 const saveState$b = state => {
@@ -18054,7 +18100,7 @@ const getSavedPoints = savedState => {
   return new Uint16Array(Total);
 };
 const isNativeTitleBarStyle = () => {
-  return getPlatform() === Electron$1 && get$e('window.titleBarStyle') === 'native';
+  return getPlatform$1() === Electron$1 && get$e('window.titleBarStyle') === 'native';
 };
 const getSavedSideBarView = savedState => {
   if (savedState && savedState.sideBarView && typeof savedState.sideBarView === 'string') {
@@ -18584,7 +18630,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$v('Viewlet.sendMultiple', commands);
+    await invoke$w('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -18830,6 +18876,12 @@ const callGlobalEvent = async (state, eventName, ...args) => {
 const getCommit = state => {
   return state.commit;
 };
+const getPlatform = state => {
+  return state.platform;
+};
+const getAssetDir = state => {
+  return state.assetDir;
+};
 const setUpdateState = async (state, updateState) => {
   if (state.updateState === updateState.state && state.updateProgress === updateState.progress) {
     return {
@@ -18876,6 +18928,8 @@ const Commands$j = {
   getAllQuickPickMenuEntries: getAllQuickPickMenuEntries,
   getActiveSideBarView: getActiveSideBarView,
   getCommit: getCommit,
+  getPlatform: getPlatform,
+  getAssetDir: getAssetDir,
   getBadgeCounts: getBadgeCounts
 };
 const CommandsWithSideEffects$1 = {
@@ -19650,10 +19704,12 @@ const ViewletLayout_ipc = {
   create: create$l,
   getActiveSideBarView,
   getAllQuickPickMenuEntries,
+  getAssetDir,
   getBadgeCounts,
   getCommit,
   getInitialPlaceholderCommands,
   getKeyBindings: getKeyBindings$8,
+  getPlatform,
   getPoints,
   getQuickPickMenuEntries: getQuickPickMenuEntries$1,
   handleBadgeCountChange,
@@ -20754,7 +20810,7 @@ const loadContent$k = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$v('Viewlet.loadModule', MainTabs);
+  await invoke$w('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -20843,7 +20899,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$v(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$w(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
   const y = state.y + state.tabHeight;
   const x = state.x;
   const width = state.width;
@@ -20868,7 +20924,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
     title,
     ...props
   });
-  await invoke$v('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$w('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state;
 };
@@ -21828,7 +21884,7 @@ const create$j = (id, uri, x, y, width, height) => {
 };
 const loadContent$j = state => {
   const update = async () => {
-    await invoke$v(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$w(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -21892,7 +21948,7 @@ const launchOutputViewWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.outputViewWorkerPath', outputViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Output.initialize');
+  await invoke$x(ipc, 'Output.initialize');
   return ipc;
 };
 
@@ -21911,7 +21967,7 @@ const create$h = (uid, uri, x, y, width, height, args, parentUid) => {
     options: [],
     disposed: false,
     text: '',
-    platform: getPlatform()
+    platform: getPlatform$1()
   };
 };
 const loadContent$h = async (state, savedState) => {
@@ -22176,7 +22232,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     const currentViewletUid = currentViewletState.uid;
     number(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    await invoke$v('Viewlet.sendMultiple', commands);
+    await invoke$w('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$4)) {
       state.currentViewletId = Error$4;
     }
@@ -22338,7 +22394,7 @@ const launchProblemsWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.problemsWorkerPath', problemsViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Problems.initialize');
+  await invoke$x(ipc, 'Problems.initialize');
   return ipc;
 };
 
@@ -22618,7 +22674,7 @@ const loadContent$e = async state => {
   } = state;
   const listItemHeight = 22;
   const renderAllItems = true;
-  await invoke$r('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, getPlatform(), args, renderAllItems, state$w.workspacePath);
+  await invoke$r('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, getPlatform$1(), args, renderAllItems, state$q.workspacePath);
   await invoke$r('QuickPick.loadContent', state.uid);
   const diffResult = await invoke$r('QuickPick.diff2', state.uid);
   const commands = await invoke$r('QuickPick.render2', state.uid, diffResult);
@@ -22716,7 +22772,7 @@ const loadContent$d = async (state, savedState) => {
 
 // TODO side effect is not good here, find a way to call ViewletLocations
 const contentLoaded$2 = state => {
-  set$a('Locations', {
+  set$b('Locations', {
     factory: ViewletLocations,
     state,
     renderedState: state
@@ -23082,22 +23138,22 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async options => {
-  const sources = await invoke$t('DesktopCapturer.getSources', options);
+  const sources = await invoke$u('DesktopCapturer.getSources', options);
   return sources;
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$v('ScreenCapture.start', captureId, options);
+  await invoke$w('ScreenCapture.start', captureId, options);
 };
 const dispose$8 = async captureId => {
   number(captureId);
-  await invoke$v('ScreenCapture.dispose', captureId);
+  await invoke$w('ScreenCapture.dispose', captureId);
 };
 
 const createScreenCaptureStream = async captureId => {
-  if (getPlatform() === Electron$1) {
+  if (getPlatform$1() === Electron$1) {
     const sources = await getSources({
       types: ['screen']
     });
@@ -23182,7 +23238,7 @@ const launchTextSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$w(ipc, 'TextSearch.initialize', getPlatform());
+    await invoke$x(ipc, 'TextSearch.initialize', getPlatform$1());
   } catch (error) {
     // ignore
   }
@@ -23209,7 +23265,7 @@ const doCreate = async state => {
   const itemHeight = 22;
   const value = '';
   const replacement = '';
-  await invoke$4('TextSearch.create', state.uid, state.x, state.y, state.width, state.height, state$w.workspacePath, assetDir, itemHeight, value, replacement, getPlatform());
+  await invoke$4('TextSearch.create', state.uid, state.x, state.y, state.width, state.height, state$q.workspacePath, assetDir, itemHeight, value, replacement, getPlatform$1());
 };
 const loadContent$a = async (state, savedState) => {
   await doCreate(state);
@@ -23383,7 +23439,7 @@ const launchSettingsWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.settingsWorkerPath', settingsWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Initialize.initialize');
+  await invoke$x(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -23656,7 +23712,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
       activityBar.state = newState;
       commands.push(...extraCommands);
     }
-    await invoke$v('Viewlet.sendMultiple', commands);
+    await invoke$w('Viewlet.sendMultiple', commands);
   }
 
   // // TODO race condition (check if disposed after created)
@@ -23809,7 +23865,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Initialize.initialize');
+  await invoke$x(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -23836,7 +23892,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$t('ElectronWindow.getZoom', windowId);
+  const zoomLevel = await invoke$u('ElectronWindow.getZoom', windowId);
   return zoomLevel;
 };
 
@@ -24012,7 +24068,7 @@ const backgroundLoadContent = async (state, savedState) => {
   const shortcuts = getShortCuts();
   // TODO since browser view is not visible at this point
   // it is not necessary to load keybindings for it
-  const keyBindings = await getKeyBindings$k();
+  const keyBindings = await getKeyBindings$l();
   const fallThroughKeyBindings = getFallThroughKeyBindings(keyBindings);
   const browserViewId = await createWebContentsView(0);
   await setFallthroughKeyBindings(fallThroughKeyBindings);
@@ -24048,7 +24104,7 @@ const loadContent$7 = async (state, savedState) => {
   const id = getId(idPart);
   const iframeSrc = getUrlFromSavedState(savedState);
   // TODO load keybindings in parallel with creating browserview
-  const keyBindings = await getKeyBindings$k();
+  const keyBindings = await getKeyBindings$l();
   const suggestionsEnabled = get$e('simpleBrowser.suggestions');
   const browserViewX = x;
   const browserViewY = y + headerHeight;
@@ -24613,7 +24669,7 @@ const create$6 = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$6 = async (state, savedState) => {
-  await invoke$g('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$w.workspacePath // TODO use workspace uri
+  await invoke$g('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$q.workspacePath // TODO use workspace uri
   );
   await invoke$g('SourceControl.loadContent', state.uid, savedState);
   const diffResult = await invoke$g('SourceControl.diff2', state.uid);
@@ -24722,7 +24778,7 @@ const hotReload$1 = async state => {
     ...state,
     items: []
   };
-  await invoke$g('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$w.workspacePath // TODO use workspace uri
+  await invoke$g('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$q.workspacePath // TODO use workspace uri
   );
   await invoke$g('SourceControl.loadContent', state.uid, savedState);
   const diffResult = await invoke$g('SourceControl.diff2', state.uid);
@@ -24888,7 +24944,7 @@ const launchStatusBarWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.statusBarWorkerPath', statusBarWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'StatusBar.initialize');
+  await invoke$x(ipc, 'StatusBar.initialize');
   return ipc;
 };
 
@@ -25119,7 +25175,7 @@ const ViewletStorage_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$t('GetTerminalSpawnOptions.getTerminalSpawnOptions');
+  return invoke$u('GetTerminalSpawnOptions.getTerminalSpawnOptions');
 };
 
 // TODO implement a functional terminal component, maybe using offscreencanvas
@@ -25148,7 +25204,7 @@ const loadContent$3 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$$();
   const canvasCursorId = create$$();
-  await invoke$j('Terminal.create', canvasTextId, canvasCursorId, uid, state$w.workspacePath, command, args);
+  await invoke$j('Terminal.create', canvasTextId, canvasCursorId, uid, state$q.workspacePath, command, args);
   const terminal = {
     handleBlur() {
       return invoke$j('Terminal.handleBlur', uid);
@@ -25237,7 +25293,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$v(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$w(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 const getActions = state => {
@@ -25385,7 +25441,7 @@ const addTerminal = async state => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$v('Viewlet.sendMultiple', commands);
+  await invoke$w('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -25426,7 +25482,7 @@ const focusIndex = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$v('Viewlet.sendMultiple', commands);
+  await invoke$w('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index
@@ -25582,7 +25638,7 @@ const create$1 = (id, uri, x, y, width, height) => {
     titleBarButtonsEnabled: true,
     titleBarButtonsWidth: 46 * 3,
     titleBarTitleEnabled: true,
-    platform: getPlatform(),
+    platform: getPlatform$1(),
     assetDir: assetDir
   };
 };
@@ -25709,7 +25765,7 @@ const getRealUri = pathOrUri => {
   if (protocol) {
     return pathOrUri;
   }
-  return invoke$t('FileSystem.getRealUri', pathOrUri);
+  return invoke$u('FileSystem.getRealUri', pathOrUri);
 };
 
 const create = (id, uri, x, y, width, height) => {
@@ -25751,7 +25807,7 @@ const resize = (state, dimensions) => {
   };
 };
 const dispose = async state => {
-  await invoke$v('WebView.dispose', state.uid);
+  await invoke$w('WebView.dispose', state.uid);
   return state;
 };
 
@@ -25865,7 +25921,7 @@ const readJsonNode = async (path, defaultContent) => {
 const readFileInternal = async (getPath, defaultContent = '') => {
   const path = await getPath();
   string(path);
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return readFileWeb(path, defaultContent);
   }
   // TODO handle enoent and other errors gracefully
@@ -25874,14 +25930,14 @@ const readFileInternal = async (getPath, defaultContent = '') => {
 const readJsonInternal = async (getPath, defaultContent = '') => {
   const path = await getPath();
   string(path);
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return readJsonWeb(path, defaultContent);
   }
   // TODO handle enoent and other errors gracefully
   return readJsonNode(path, defaultContent);
 };
 const writeFileWeb = async (path, content) => {
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     await execute$3(/* LocalStorage.setText */'LocalStorage.setText', /* key */path, /* value */content);
   }
 };
@@ -25909,7 +25965,7 @@ const writeFileNode = async (path, content) => {
 const writeFileInternal = async (getPath, content) => {
   const path = await getPath();
   string(path);
-  if (getPlatform() === Web$1) {
+  if (getPlatform$1() === Web$1) {
     return writeFileWeb(path, content);
   }
   return writeFileNode(path, content);
@@ -26014,7 +26070,7 @@ const getItem = (items, label) => {
 const openContextMenu = async (x, y, id, ...args) => {
   const entries = await getMenuEntries$7(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$t('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$u('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -26060,7 +26116,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$t('ElectronWindowProcessExplorer.open');
+    await invoke$u('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, 'Failed to open process explorer');
   }