@lvce-editor/static-server 0.70.0 → 0.70.2

package/static/{377d2ba → 1b632a9}/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 '/377d2ba';
+    return '/1b632a9';
   }
 };
-const assetDir = getAssetDir();
+const assetDir = getAssetDir$1();
 
 const NotFound = 404;
 
@@ -432,7 +432,7 @@ 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$e = (ipc, method, ...params) => {
@@ -1091,8 +1091,8 @@ 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$d = (method, ...params) => {
   return invokeAndTransfer$e(state$D.ipc, method, ...params);
@@ -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,7 +1137,7 @@ 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);
@@ -1252,7 +1252,7 @@ const launchErrorWorker = async () => {
 };
 
 const {
-  invoke: invoke$u,
+  invoke: invoke$v,
   invokeAndTransfer: invokeAndTransfer$c
 } = getOrCreateWorker(launchErrorWorker);
 
@@ -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$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 {
-    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$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 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,17 +1599,17 @@ 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$b = async (method, ...params) => {
   const {
     ipc
-  } = state$x;
+  } = 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;
+const getConfiguredWorkerUrl$1 = (preferenceKey, fallback) => {
+  let configuredWorkerUrl = get$e(preferenceKey) || '';
+  if (configuredWorkerUrl) {
+    const configuredUrlWithSlash = configuredWorkerUrl.startsWith('/') ? configuredWorkerUrl : '/' + configuredWorkerUrl;
+    configuredWorkerUrl = '/remote' + configuredUrlWithSlash;
   }
-  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 '';
-  }
-  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$a
-} = 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,55 +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$t(/* Platform.getDisabledExtensionsJsonPath */'Platform.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`;
@@ -2403,7 +2039,7 @@ const getTestPathWeb = () => {
 
 // @ts-ignore
 const getTestPath = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
     case Remote:
       return getTestPathRemote();
@@ -2412,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 => {
@@ -2440,19 +2076,6 @@ const getTestFilePath = async (platform, href) => {
   return jsPath;
 };
 
-const getConfiguredWorkerUrl$1 = (preferenceKey, fallback) => {
-  let configuredWorkerUrl = get$e(preferenceKey) || '';
-  if (configuredWorkerUrl) {
-    const configuredUrlWithSlash = configuredWorkerUrl.startsWith('/') ? configuredWorkerUrl : '/' + configuredWorkerUrl;
-    configuredWorkerUrl = '/remote' + configuredUrlWithSlash;
-  }
-  configuredWorkerUrl = configuredWorkerUrl || fallback;
-  {
-    configuredWorkerUrl = fallback;
-  }
-  return configuredWorkerUrl;
-};
-
 const testWorkerUrl = `${assetDir}/packages/test-worker/dist/testWorkerMain.js`;
 
 const launchTestWorker = async () => {
@@ -2463,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) => {
@@ -2493,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
@@ -2530,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) => {
@@ -2555,7 +2178,7 @@ const error = (...args) => {
   console.error(...args);
 };
 
-const state$r = {
+const state$t = {
   keyBindingSets: Object.create(null),
   /**
    * @type {Uint32Array}
@@ -2567,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;
     }
@@ -2590,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;
@@ -2644,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();
 };
@@ -2656,7 +2279,7 @@ const setFocus = (focusKey, additionalFocusKey) => {
  * @param {number} key
  */
 const setAdditionalFocus = key => {
-  set$c(key, true);
+  set$d(key, true);
   update();
 };
 
@@ -2679,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();
 };
 
@@ -2724,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);
@@ -2768,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) => {
@@ -2789,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);
@@ -2797,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;
@@ -2847,125 +2470,524 @@ const serializeInstances = async instances => {
       const storageKey = value.factory.StorageKey || value.moduleId;
       serialized[storageKey] = serializedInstance;
     }
-  }
-  return serialized;
+  }
+  return serialized;
+};
+
+// TODO instances should be keyed by numeric id
+// to allow having multiple instances of the same
+// type. for example multiple editors
+
+const state$r = {
+  instances: Object.create(null)};
+const set$b = (key, value) => {
+  // TODO separate factories from state
+  object(value);
+  object(value.factory);
+  object(value.state);
+  object(value.renderedState);
+  state$r.instances[key] = value;
+};
+const getByUid = uid => {
+  for (const value of Object.values(state$r.instances)) {
+    if (value.renderedState.uid === uid) {
+      return value;
+    }
+  }
+  return undefined;
+};
+const getInstance = key => {
+  const fast = state$r.instances[key];
+  if (fast) {
+    return fast;
+  }
+  if (key === 'Editor') {
+    key = 'EditorText';
+  }
+  if (key === 'EditorText') {
+    key = 'Editor';
+  }
+  if (key === 'EditorCompletion') {
+    key = 'Editor';
+  }
+  for (const value of Object.values(state$r.instances)) {
+    if (value.moduleId === key) {
+      return value;
+    }
+  }
+  return undefined;
+};
+const hasInstance = key => {
+  return key in state$r.instances;
+};
+const remove$8 = key => {
+  delete state$r.instances[key];
+};
+const getAllInstances = () => {
+  return state$r.instances;
+};
+const getValues = () => {
+  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');
+  }
+  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;
+  }
+  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$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 {
+    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();
+    }
+  };
 };
 
-// TODO instances should be keyed by numeric id
-// to allow having multiple instances of the same
-// type. for example multiple editors
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$_,
+  wrap: wrap$7
+};
 
 const state$p = {
-  instances: Object.create(null)};
-const set$a = (key, value) => {
-  // TODO separate factories from state
-  object(value);
-  object(value.factory);
-  object(value.state);
-  object(value.renderedState);
-  state$p.instances[key] = value;
-};
-const getByUid = uid => {
-  for (const value of Object.values(state$p.instances)) {
-    if (value.renderedState.uid === uid) {
-      return value;
-    }
-  }
-  return undefined;
-};
-const getInstance = key => {
-  const fast = state$p.instances[key];
-  if (fast) {
-    return fast;
-  }
-  if (key === 'Editor') {
-    key = 'EditorText';
-  }
-  if (key === 'EditorText') {
-    key = 'Editor';
-  }
-  if (key === 'EditorCompletion') {
-    key = 'Editor';
-  }
-  for (const value of Object.values(state$p.instances)) {
-    if (value.moduleId === key) {
-      return value;
-    }
-  }
-  return undefined;
-};
-const hasInstance = key => {
-  return key in state$p.instances;
-};
-const remove$8 = key => {
-  delete state$p.instances[key];
+  shouldLaunchMultipleWorkers: false
 };
-const getAllInstances = () => {
-  return state$p.instances;
+const setConfig = shouldLaunchMultipleWorkers => {
+  state$p.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
 };
-const getValues = () => {
-  return Object.values(state$p.instances);
+const getConfig = () => {
+  return state$p.shouldLaunchMultipleWorkers;
 };
-const getState$1 = key => {
-  const instance = getInstance(key);
-  if (!instance) {
-    throw new Error(`instance not found ${key}`);
-  }
-  return instance.state;
+
+const objects = Object.create(null);
+const transferToRendererProcess = async (objectId, transferable) => {
+  await invokeAndTransfer$d('Transferrable.transfer', transferable, objectId);
 };
-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 transfer = (objectId, transferable) => {
+  number(objectId);
+  object(transferable);
+  objects[objectId] = transferable;
 };
-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;
+const acquire = objectId => {
+  number(objectId);
+  const value = objects[objectId];
+  if (!value) {
+    throw new Error(`transferrable object not found`);
   }
-  instance.renderedState = newState;
-  instance.state = newState;
-};
-const setFocusedInstance = (state, instance) => {
-  state.focusedIndex = instance;
-};
-
-const getStateToSave = async () => {
-  const instances = getAllInstances();
-  const savedInstances = await serializeInstances(instances);
-  return {
-    instances: savedInstances,
-    mainEditors: [],
-    workspace: {
-      path: state$w.workspacePath,
-      homeDir: state$w.homeDir,
-      pathSeparator: state$w.pathSeparator,
-      uri: state$w.workspaceUri
-    }
-  };
+  delete objects[objectId];
+  return value;
 };
 
-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 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 saveBuiltinState = async () => {
-  const stateToSave = await getStateToSave();
-  await Promise.all([setJson$3('workspace', stateToSave.workspace), setJsonObjects(stateToSave.instances), setJson$2('workspace', stateToSave.workspace)]);
-};
+const {
+  invoke: invoke$s,
+  invokeAndTransfer: invokeAndTransfer$9
+} = getOrCreateWorker(launchExtensionHostWorker);
 
 const ActivityBar$2 = 'ActivityBar';
 const ExtensionStateStorage$1 = 'ExtensionStateStorage';
@@ -3039,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);
@@ -3072,7 +3094,7 @@ const launchFileSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$w(ipc, 'QuickPick.initialize');
+    await invoke$x(ipc, 'QuickPick.initialize');
   } catch {
     // ignore
   }
@@ -3272,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) {
@@ -3288,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);
   }
@@ -3314,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
@@ -3520,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);
   }
@@ -3547,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);
     }
@@ -3575,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);
@@ -3669,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);
@@ -3723,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
@@ -3731,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,
@@ -3784,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],
@@ -3805,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) {
@@ -3827,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) {
@@ -3839,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]);
@@ -3891,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 => {
@@ -3941,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);
 };
 
 /**
@@ -3984,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);
     }
@@ -4165,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 = () => {
@@ -4208,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 {
@@ -4220,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}`);
@@ -4278,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
@@ -4318,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) {
@@ -4367,7 +4389,7 @@ const launchIconThemeWorker = async () => {
 
 const {
   invoke: invoke$q,
-  invokeAndTransfer: invokeAndTransfer$9
+  invokeAndTransfer: invokeAndTransfer$8
 } = getOrCreateWorker(launchIconThemeWorker);
 
 const getFileIcon$1 = file => {
@@ -4386,11 +4408,11 @@ const getIcons = iconRequests => {
   return invoke$q('IconTheme.getIcons', iconRequests);
 };
 
-const setIconTheme = async iconThemeId => {
+const setIconTheme = async (iconThemeId, platform, assetDir) => {
   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', assetDir, platform);
+    await invoke$q('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, platform, useCache);
     await handleIconThemeChange$1();
   } catch (error) {
     if (isTest()) ; else {
@@ -4398,14 +4420,14 @@ const setIconTheme = async iconThemeId => {
     }
   }
 };
-const hydrate$4 = async () => {
+const hydrate$4 = async (platform, assetDir) => {
   // TODO do this all in worker
   const iconThemeId = get$e('icon-theme') || 'vscode-icons';
-  await setIconTheme(iconThemeId);
+  await setIconTheme(iconThemeId, platform, assetDir);
 };
 
 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
@@ -4554,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;
   }
@@ -4565,16 +4587,16 @@ const getLanguageConfiguration$2 = async languageId => {
   warn('get language configuration not yet supported on web');
 };
 
-const getLanguages = async () => {
+const getLanguages = async (platform, assetDir) => {
   try {
-    return invoke$s('Languages.getLanguages');
+    return invoke$t('Extensions.getLanguages', platform, assetDir);
   } 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:
@@ -4704,11 +4726,11 @@ const getTokenizeFunctionPath = languageId => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
   return getTokenizeFunctionPath$1(languageId);
 };
-const hydrate$3 = async () => {
+const hydrate$3 = async (platform, assetDir) => {
   setHydrating(true);
   // TODO handle error
   // TODO main parts should have nothing todo with shared process -> only sub components
-  const languages = await getLanguages();
+  const languages = await getLanguages(platform, assetDir);
   // TODO avoid side effect here, but how?
   // possible icon theme worker can ask for languages to be loaded, that way the dependency is reversed
   await invoke$q('IconTheme.addLanguages', languages);
@@ -4864,7 +4886,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;
@@ -5233,10 +5255,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);
@@ -5500,7 +5522,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');
@@ -5680,7 +5702,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}`);
   }
@@ -5713,17 +5735,17 @@ const actions = [async () => {
   mark(DidLoadStatusBar);
 }, async () => {
   await execute$3('Layout.loadPreviewIfVisible');
-}, async () => {
+}, async (platform, assetDir) => {
   mark$1(Eleven);
   mark(WillLoadIconTheme);
   // TODO check preferences if icon theme is enabled
-  await hydrate$4();
+  await hydrate$4(platform, assetDir);
   mark(DidLoadIconTheme);
-}, async () => {
+}, async platform => {
   mark$1(Twelve);
   mark$1(Thirteen);
   mark$1(Fourteen);
-  if (getPlatform() === Electron$1 && get$e('window.titleBarStyle') === 'native') {
+  if (platform === Electron$1 && get$e('window.titleBarStyle') === 'native') {
     await execute$3('ElectronApplicationMenu.hydrate');
   } else {
     mark(WillLoadTitleBar);
@@ -5733,7 +5755,7 @@ const actions = [async () => {
 }];
 
 // TODO lazyload parts one by one (Main, SideBar, ActivityBar, TitleBar, StatusBar)
-const startup = async () => {
+const startup = async (platform, assetDir) => {
   onunhandledrejection = handleUnhandledRejection;
   // @ts-ignore
   onerror = handleUnhandledError;
@@ -5743,7 +5765,7 @@ const startup = async () => {
   mark$1(Zero);
   mark(WillStartupWorkbench);
   await listen$1();
-  if (getPlatform() !== Web$1) {
+  if (platform !== Web$1) {
     await launchSharedProcess();
   }
   mark$1(One);
@@ -5768,12 +5790,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);
@@ -5798,17 +5820,17 @@ 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);
-  await hydrate$3();
+  await hydrate$3(platform, assetDir);
   mark(DidLoadLanguages);
   mark$1(Five);
-  await Promise.all(actions.map(action => action()));
+  await Promise.all(actions.map(action => action(platform, assetDir)));
   mark$1(Fifteen);
   if (isTest()) {
-    await executeCurrentTest(getPlatform(), initData);
+    await executeCurrentTest(platform, initData);
     return;
   }
   mark(WillLoadSaveState);
@@ -5822,9 +5844,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);
@@ -5836,7 +5858,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 = platform === Electron$1; // TODO also check if auto update is supported on this platform, e.g. windows
   if (autoUpdate && autoUpdate !== 'none' && supportsAutoUpdate) {
     try {
       await execute$3('AutoUpdater.checkForUpdates', autoUpdate);
@@ -5848,7 +5870,7 @@ const startup = async () => {
 };
 
 const main = async () => {
-  await startup();
+  await startup(getPlatform$1(), assetDir);
 };
 main();
 
@@ -5908,7 +5930,7 @@ const getPort = async ipcId => {
     ipcId
   });
   // TODO avoid side effect?
-  set$d(webContentsId);
+  set$e(webContentsId);
   return port2;
 };
 const create$X = async options => {
@@ -6345,7 +6367,7 @@ const IpcParentWithWebSocket = {
 };
 
 const getModule$4 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
     case Remote:
       return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
@@ -6386,7 +6408,7 @@ const sendMessagePortToElectron = async (port, initialCommand, 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; });
@@ -6511,7 +6533,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';
@@ -6655,7 +6676,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
@@ -6695,15 +6716,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 => {
+const actuallyActivateByEvent = async (event, assetDir, platform) => {
   // TODO should not query extensions multiple times
-  const extensions = await invoke$s('Extensions.getExtensions');
+  const extensions = await invoke$t('Extensions.getAllExtensions', assetDir, platform);
   const {
     resolved,
     rejected
@@ -6727,7 +6749,7 @@ const actuallyActivateByEvent = async event => {
 };
 
 // TODO add tests for this
-const activateByEvent = async event => {
+const activateByEvent = async (event, assetDir, platform) => {
   string(event);
   if (event === 'none') {
     const all = await Promise.all(Object.values(state$g.cachedActivationEvents));
@@ -6735,7 +6757,7 @@ const activateByEvent = async event => {
     return [flatAll[0]];
   }
   if (!(event in state$g.cachedActivationEvents)) {
-    state$g.cachedActivationEvents[event] = actuallyActivateByEvent(event);
+    state$g.cachedActivationEvents[event] = actuallyActivateByEvent(event, assetDir, platform);
   }
   return state$g.cachedActivationEvents[event];
 };
@@ -6746,9 +6768,11 @@ const executeProviders = async ({
   params,
   noProviderFoundMessage = 'No provider found',
   noProviderFoundResult,
-  combineResults
+  combineResults,
+  assetDir,
+  platform
 }) => {
-  await activateByEvent(event);
+  await activateByEvent(event, assetDir, platform);
   const result = await invoke$s(method, ...params);
   return result;
 };
@@ -6756,9 +6780,11 @@ const executeProvider = async ({
   event,
   method,
   params,
-  noProviderFoundMessage
+  noProviderFoundMessage,
+  assetDir = '',
+  platform = getPlatform$1()
 }) => {
-  await activateByEvent(event);
+  await activateByEvent(event, assetDir, platform);
   const result = invoke$s(method, ...params);
   return result;
 };
@@ -7355,13 +7381,13 @@ 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;
 };
 
 const {
   invoke: invoke$p,
-  invokeAndTransfer: invokeAndTransfer$8} = getOrCreateWorker(launchFileSystemWorker);
+  invokeAndTransfer: invokeAndTransfer$7} = getOrCreateWorker(launchFileSystemWorker);
 
 // TODO move all of this to an extension
 
@@ -7505,7 +7531,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');
@@ -7664,7 +7690,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) => {
@@ -7898,7 +7924,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;
 };
 
@@ -8004,7 +8030,7 @@ const showAboutDefault = async () => {
   await openWidget(About);
 };
 const getFn = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return showAboutElectron;
     default:
@@ -8107,7 +8133,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';
@@ -8174,7 +8200,7 @@ const GetActiveEditor_ipc = {
 };
 
 const getSelectionText = () => {
-  return invoke$v('Css.getSelectionText');
+  return invoke$w('Css.getSelectionText');
 };
 
 const name$28 = 'Document';
@@ -8192,7 +8218,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';
@@ -8268,14 +8294,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';
@@ -8373,7 +8399,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 => {
@@ -8422,7 +8448,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;
   }
@@ -8450,7 +8476,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;
@@ -8520,7 +8546,7 @@ const Callback_ipc = {
 };
 
 const minimize = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.minimize');
     default:
@@ -8528,7 +8554,7 @@ const minimize = () => {
   }
 };
 const maximize = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.maximize');
     default:
@@ -8536,7 +8562,7 @@ const maximize = () => {
   }
 };
 const unmaximize = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.unmaximize');
     default:
@@ -8544,7 +8570,7 @@ const unmaximize = () => {
   }
 };
 const close$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.close');
     default:
@@ -8552,7 +8578,7 @@ const close$2 = () => {
   }
 };
 const exit$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('Exit.exit');
     default:
@@ -8560,7 +8586,7 @@ const exit$2 = () => {
   }
 };
 const openNew = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.openNew');
     default:
@@ -8568,7 +8594,7 @@ const openNew = () => {
   }
 };
 const zoomIn = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.zoomIn');
     default:
@@ -8576,7 +8602,7 @@ const zoomIn = () => {
   }
 };
 const zoomOut = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.zoomOut');
     default:
@@ -8584,7 +8610,7 @@ const zoomOut = () => {
   }
 };
 const zoomReset = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.zoomReset');
     default:
@@ -8617,7 +8643,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;
 };
 
@@ -8650,14 +8676,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');
   }
@@ -8684,12 +8710,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
@@ -8707,7 +8733,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
@@ -8719,7 +8745,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$t('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$u('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Error$2 = 'error';
@@ -8747,7 +8773,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;
 };
 
@@ -8787,14 +8813,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()
@@ -8816,7 +8842,7 @@ const prompt$1 = async (message, {
 };
 const showErrorMessage = ({
   message,
-  platform = getPlatform(),
+  platform = getPlatform$1(),
   confirmMessage = ok(),
   title = ''
 }) => {
@@ -8841,21 +8867,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 => {
@@ -8863,7 +8889,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}`);
   }
@@ -8872,7 +8898,7 @@ const openNativeFolderElectron = async absolutePath => {
   await showItemInFolder(absolutePath);
 };
 const openNativeFolder = async absolutePath => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return openNativeFolderWeb();
     case Remote:
@@ -8883,7 +8909,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({
@@ -8891,7 +8917,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();
@@ -8915,7 +8941,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; });
@@ -8982,26 +9008,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 () => {
@@ -9021,10 +9047,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 = () => {
@@ -9040,21 +9066,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) => {
@@ -9270,7 +9296,7 @@ const formatBytes = bytes => {
 };
 
 const getModule$1 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return Promise.resolve().then(function () { return ProcessExplorerElectron; });
     case Remote:
@@ -9292,10 +9318,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);
@@ -9306,7 +9332,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();
@@ -9321,12 +9347,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({
@@ -9384,13 +9410,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
@@ -9439,19 +9465,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 reloadIconTheme = async (platform, assetDir) => {
+  await hydrate$4(platform, assetDir);
 };
 const reloadColorTheme = async () => {
-  await hydrate$8();
+  await hydrate$a();
 };
 const showColorThemeCss = async () => {
   // @ts-ignore
@@ -9523,7 +9549,7 @@ const Developer_ipc = {
 };
 
 const load$1 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return Promise.resolve().then(function () { return OpenFolderWeb; });
     case Remote:
@@ -9555,7 +9581,7 @@ const openFileElectron = async () => {
   await openUri$1(file);
 };
 const openFile$2 = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return openFileWeb();
     case Remote:
@@ -9594,7 +9620,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) {
@@ -9633,12 +9659,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 = '';
@@ -9732,7 +9758,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 = {
@@ -9951,7 +9977,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(),
@@ -10002,17 +10028,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(),
@@ -10299,7 +10325,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);
@@ -10362,7 +10388,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$t('ElectronClipBoard.writeText', text);
+  return invoke$u('ElectronClipBoard.writeText', text);
 };
 
 const name$1N = 'ElectronClipBoard';
@@ -10391,7 +10417,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,
@@ -10421,7 +10447,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$t('Exit.exit');
+  return invoke$u('Exit.exit');
 };
 
 const name$1J = 'Exit';
@@ -10561,7 +10587,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
@@ -10572,11 +10598,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
@@ -10589,7 +10615,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 => {
@@ -10680,15 +10706,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
@@ -10887,7 +10913,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));
@@ -10899,7 +10925,7 @@ const name$1x = 'KeyBindingsInitial';
 
 // prettier-ignore
 const Commands$1z = {
-  getKeyBindings: getKeyBindings$k
+  getKeyBindings: getKeyBindings$l
 };
 
 const KeyBindingsInitial_ipc = {
@@ -11188,22 +11214,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;
@@ -11314,7 +11340,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
@@ -11323,7 +11349,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');
@@ -11339,7 +11365,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';
@@ -11358,7 +11384,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}`);
   }
@@ -11367,7 +11393,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:
@@ -11435,7 +11461,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';
@@ -11450,7 +11476,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$t('RebuildNodePty.rebuildNodePty');
+  await invoke$u('RebuildNodePty.rebuildNodePty');
 };
 
 const name$1l = 'RebuildNodePty';
@@ -11586,19 +11612,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';
@@ -11667,10 +11693,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
 };
@@ -11683,7 +11709,7 @@ const Workspace_ipc = {
 
 const name$18 = 'WindowTitle';
 const Commands$19 = {
-  set: set$f
+  set: set$a
 };
 
 const WindowTitle_ipc = {
@@ -11693,10 +11719,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';
@@ -11834,10 +11860,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) => {
@@ -11869,7 +11895,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,
@@ -11881,19 +11907,19 @@ const launchTerminalWorker = async () => {
 
 const {
   invoke: invoke$j,
-  invokeAndTransfer: invokeAndTransfer$7
+  invokeAndTransfer: invokeAndTransfer$6
 } = getOrCreateWorker(launchTerminalWorker);
 
 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;
 };
 const createForTerminal = async (canvasId, callbackId) => {
   const canvas = await create$O(canvasId);
-  await invokeAndTransfer$7('OffscreenCanvas.handleResult', callbackId, canvas);
+  await invokeAndTransfer$6('OffscreenCanvas.handleResult', callbackId, canvas);
 };
 
 const name$11 = 'OffscreenCanvas';
@@ -11975,7 +12001,9 @@ const execute = ({
   method,
   combineResults,
   noProviderFoundMessage,
-  noProviderFoundResult = undefined
+  noProviderFoundResult = undefined,
+  assetDir,
+  platform
 }) => {
   return executeProviders({
     event: `${event}:${editor.languageId}`,
@@ -11983,7 +12011,9 @@ const execute = ({
     params: [editor.uid, ...args],
     noProviderFoundMessage,
     combineResults: combineResults,
-    noProviderFoundResult
+    noProviderFoundResult,
+    assetDir,
+    platform
   });
 };
 
@@ -12233,33 +12263,16 @@ 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;
 };
 
 const {
   invoke: invoke$i,
-  invokeAndTransfer: invokeAndTransfer$6
+  invokeAndTransfer: invokeAndTransfer$5
 } = getOrCreateWorker(launchEditorWorker);
 const actualInvoke = invoke$i;
 
-const extensionManagementWorkerUrl = `${assetDir}/packages/extension-management-worker/dist/extensionManagementWorkerMain.js`;
-
-const launchExtensionManagementWorker = async () => {
-  const name = 'Extension Management Worker';
-  const ipc = await create$10({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name,
-    url: getConfiguredWorkerUrl$1('develop.extensionManagementWorkerPath', extensionManagementWorkerUrl)
-  });
-  handleIpc(ipc);
-  await invoke$w(ipc, 'Extensions.initialize', getPlatform());
-  return ipc;
-};
-
-const {
-  invokeAndTransfer: invokeAndTransfer$5} = getOrCreateWorker(launchExtensionManagementWorker);
-
 const markdownWorkerUrl = `${assetDir}/packages/markdown-worker/dist/markdownWorkerMain.js`;
 
 const launchMarkdownWorker = async () => {
@@ -12288,7 +12301,7 @@ const launchIframeWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.iframeWorkerPath', iframeWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Iframes.initialize', getPlatform());
+  await invoke$x(ipc, 'Iframes.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -12306,7 +12319,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;
 };
 
@@ -12336,7 +12349,7 @@ const {
 const sendMessagePortToExtensionHostWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$a(initialCommand, port, rpcId);
+  await invokeAndTransfer$9(initialCommand, port, rpcId);
 };
 const sendMessagePortToSharedProcess = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12351,7 +12364,7 @@ const sendMessagePortToErrorWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$6(initialCommand, port, rpcId);
+  await invokeAndTransfer$5(initialCommand, port, rpcId);
 };
 const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12366,12 +12379,12 @@ const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToFileSystemWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$8(initialCommand, port, rpcId);
+  await invokeAndTransfer$7(initialCommand, port, rpcId);
 };
 const sendMessagePortToIconThemeWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$9(initialCommand, port, rpcId);
+  await invokeAndTransfer$8(initialCommand, port, rpcId);
 };
 const sendMessagePortToTextMeasurementWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12386,7 +12399,7 @@ const sendMessagePortToSourceControlWorker = async (port, initialCommand, rpcId)
 const sendMessagePortToExtensionManagementWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$5(initialCommand, port, rpcId);
+  await invokeAndTransfer$a(initialCommand, port, rpcId);
 };
 const sendMessagePortToIframeWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -12485,7 +12498,7 @@ const Transferrable_ipc = {
 };
 
 const getWebViewsNode = async () => {
-  const webViews = await invoke$t('ExtensionHost.getWebViews');
+  const webViews = await invoke$u('ExtensionHost.getWebViews');
   return webViews;
 };
 
@@ -12497,7 +12510,7 @@ const getWebViewsWeb = async () => {
 };
 
 const getWebViewsDefault = async () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Web$1:
       return getWebViewsWeb();
     case Test$1:
@@ -12534,7 +12547,7 @@ const create3 = async (uri, id) => {
   await invoke$s('WebView.create3', {
     id,
     uri,
-    platform: getPlatform(),
+    platform: getPlatform$1(),
     isGitpod: isGitpod,
     assetDir: assetDir,
     webViewScheme: WebView,
@@ -12545,23 +12558,23 @@ const getSecret = key => {
   return get$e(key);
 };
 const registerInterceptor = async (id, port) => {
-  await invokeAndTransfer$a('WebView.registerInterceptor', id, port);
+  await invokeAndTransfer$9('WebView.registerInterceptor', id, port);
 };
 const unregisterInterceptor = async id => {
   await invoke$s('WebView.unregisterInterceptor', 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$d(...args);
   },
   extensionHostWorkerInvokeAndTransfer(...args) {
-    return invokeAndTransfer$a(...args);
+    return invokeAndTransfer$9(...args);
   },
   extensionHostWorkerInvoke(...args) {
     return invoke$s(...args);
@@ -12623,7 +12636,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';
@@ -12640,14 +12653,16 @@ const SearchProcess_ipc = {
 const combineResults$1 = results => {
   return results[0];
 };
-const executeTextSearchProvider = async (scheme, query) => {
+const executeTextSearchProvider = async (scheme, query, assetDir, platform) => {
   const result = await executeProviders({
     event: `onTextSearch:${scheme}`,
     method: TextSearchExecuteTextSearchProvider,
     params: [scheme, query],
     noProviderFoundMessage: 'no text search providers found',
     noProviderFoundResult: [],
-    combineResults: combineResults$1
+    combineResults: combineResults$1,
+    assetDir,
+    platform
   });
   return result;
 };
@@ -12721,14 +12736,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 => {
@@ -12736,7 +12751,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;
@@ -12749,7 +12764,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;
@@ -12758,10 +12773,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 => {
@@ -12776,7 +12791,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;
 };
 
@@ -12819,10 +12834,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';
@@ -12887,7 +12902,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');
 };
 
@@ -12957,7 +12972,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,
@@ -13122,7 +13137,7 @@ const Backquote = 89;
 const Backslash = 91;
 const Plus = 132;
 
-const getKeyBindings$i = () => {
+const getKeyBindings$j = () => {
   return [{
     key: DownArrow,
     command: 'ActivityBar.focusNext',
@@ -13279,7 +13294,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,
@@ -13522,7 +13537,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
@@ -13572,7 +13587,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,
@@ -13638,7 +13653,7 @@ const Commands$z = {};
 
 const Css$z = ["/css/parts/ViewletAbout.css", "/css/parts/ViewletDialog.css"];
 
-const getKeyBindings$h = () => {
+const getKeyBindings$i = () => {
   return [];
 };
 
@@ -13670,7 +13685,7 @@ const ViewletConfirm_ipc = {
   Commands: Commands$z,
   Css: Css$z,
   create: create$I,
-  getKeyBindings: getKeyBindings$h,
+  getKeyBindings: getKeyBindings$i,
   handleClickCancel,
   handleClickClose: handleClickClose$1,
   handleClickOk,
@@ -13757,7 +13772,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',
@@ -13942,7 +13957,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,
@@ -15093,7 +15108,7 @@ const Commands$u = {
 
 const Css$t = ["/css/parts/E2eTest.css"];
 
-const getKeyBindings$f = () => {
+const getKeyBindings$g = () => {
   return [];
 };
 
@@ -15188,7 +15203,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,
@@ -15220,8 +15235,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);
@@ -15317,7 +15332,7 @@ const Commands$t = {
 
 const Css$s = ["/css/parts/E2eTests.css"];
 
-const getKeyBindings$e = () => {
+const getKeyBindings$f = () => {
   return [];
 };
 
@@ -15446,7 +15461,7 @@ const ViewletE2eTests_ipc = {
   Css: Css$s,
   create: create$z,
   executeTest,
-  getKeyBindings: getKeyBindings$e,
+  getKeyBindings: getKeyBindings$f,
   handleClickAt,
   handleContextMenu: handleContextMenu$2,
   handleLoad,
@@ -15693,8 +15708,8 @@ const executeSemanticTokenProvider = editor => {
   });
 };
 
-const load = async language => {
-  await activateByEvent(`onLanguage:${language}`);
+const load = async (language, assetDir, platform) => {
+  await activateByEvent(`onLanguage:${language}`, assetDir, platform);
 };
 
 const getFontUrl = relativePath => {
@@ -15749,7 +15764,9 @@ const create$x = (id, uri, x, y, width, height) => {
     rowHeight: 20,
     languageId,
     width,
-    moduleId: EditorText
+    moduleId: EditorText,
+    platform: getPlatform$1(),
+    assetDir: assetDir
   };
 };
 const getSavedSelections = savedState => {
@@ -15785,7 +15802,9 @@ const loadContent$w = async (state, savedState, context) => {
     x,
     y,
     width,
-    height
+    height,
+    platform,
+    assetDir
   } = state;
   const rowHeight = getRowHeight();
   const fontSize = getFontSize();
@@ -15822,35 +15841,37 @@ const loadContent$w = async (state, savedState, context) => {
   const lineToReveal = context?.rowIndex || 0;
   const columnToReveal = context?.columnIndex || 0;
   await actualInvoke('Editor.create', {
-    id,
+    assetDir,
+    columnToReveal,
+    completionTriggerCharacters,
     content,
-    savedDeltaY,
-    rowHeight,
+    diagnosticsEnabled: diagnosticsEnabled$1,
+    fontFamily,
     fontSize,
-    hoverEnabled,
-    letterSpacing,
-    tabSize,
-    links,
-    lineNumbers,
+    fontWeight,
     formatOnSave,
+    height,
+    hoverEnabled,
+    id,
     isAutoClosingBracketsEnabled: isAutoClosingBracketsEnabled$1,
-    isAutoClosingTagsEnabled: isAutoClosingTagsEnabled$1,
     isAutoClosingQuotesEnabled: isAutoClosingQuotesEnabled$1,
+    isAutoClosingTagsEnabled: isAutoClosingTagsEnabled$1,
+    isMonospaceFont,
     isQuickSuggestionsEnabled: isQuickSuggestionsEnabled$1,
-    completionTriggerCharacters,
-    savedSelections,
     languageId,
-    x,
-    y,
-    width,
-    height,
-    isMonospaceFont,
-    fontFamily,
-    fontWeight,
-    uri,
-    diagnosticsEnabled: diagnosticsEnabled$1,
+    letterSpacing,
+    lineNumbers,
     lineToReveal,
-    columnToReveal
+    links,
+    platform,
+    rowHeight,
+    savedDeltaY,
+    savedSelections,
+    tabSize,
+    uri,
+    width,
+    x,
+    y
   });
   // TODO send render commands directly from editor worker
   // to renderer process
@@ -15985,7 +16006,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) {
@@ -16002,7 +16023,7 @@ const CommandsWithSideEffectsLazy$1 = {
   }
 };
 
-const getKeyBindings$d = uid => {
+const getKeyBindings$e = uid => {
   // @ts-ignore
   return actualInvoke('Editor.getKeyBindings', uid);
 };
@@ -16069,7 +16090,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,
@@ -16262,7 +16283,7 @@ const launchExplorerWorker = async () => {
     name: 'Explorer Worker'
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Explorer.initialize');
+  await invoke$x(ipc, 'Explorer.initialize');
   return ipc;
 };
 
@@ -16289,7 +16310,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) => {
@@ -16382,7 +16403,7 @@ const getCommands$e = async () => {
 
 const Css$p = [];
 
-const getKeyBindings$c = () => {
+const getKeyBindings$d = () => {
   return invoke$c('Explorer.getKeyBindings');
 };
 
@@ -16482,7 +16503,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,
@@ -16511,7 +16532,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;
 };
 
@@ -16542,7 +16563,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);
@@ -16561,7 +16582,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);
@@ -16605,6 +16626,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 {
@@ -16649,6 +16678,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,
@@ -16666,7 +16696,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,
@@ -16674,7 +16704,7 @@ const launchExtensionSearchViewWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$w(ipc, 'SearchExtensions.initialize');
+    await invoke$x(ipc, 'SearchExtensions.initialize');
   } catch {
     // ignore
   }
@@ -16701,7 +16731,7 @@ const create$r = (id, uri, x, y, width, height) => {
     height,
     x,
     y,
-    platform: getPlatform(),
+    platform: getPlatform$1(),
     assetDir: assetDir
   };
 };
@@ -17051,7 +17081,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;
 };
 
@@ -17231,7 +17261,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
   });
@@ -17709,7 +17739,7 @@ const ViewletKeyBindings_ipc = {
 };
 
 const getDefaultTitleBarHeight = () => {
-  switch (getPlatform()) {
+  switch (getPlatform$1()) {
     case Electron$1:
       return 29;
     default:
@@ -17836,7 +17866,7 @@ const Preview$1 = {
   kReady: 'previewVisible'
 };
 
-const commit = '377d2ba';
+const commit = '1b632a9';
 
 // TODO instead of reordering commands, have two command arrays
 // one for normal commands
@@ -18048,7 +18078,9 @@ const create$l = id => {
     sideBarView: '',
     updateState: 'none',
     updateProgress: 0,
-    commit: commit
+    commit: commit,
+    platform: platform,
+    assetDir
   };
 };
 const saveState$b = state => {
@@ -18083,7 +18115,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') {
@@ -18613,7 +18645,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
@@ -18859,6 +18891,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 {
@@ -18905,6 +18943,8 @@ const Commands$j = {
   getAllQuickPickMenuEntries: getAllQuickPickMenuEntries,
   getActiveSideBarView: getActiveSideBarView,
   getCommit: getCommit,
+  getPlatform: getPlatform,
+  getAssetDir: getAssetDir,
   getBadgeCounts: getBadgeCounts
 };
 const CommandsWithSideEffects$1 = {
@@ -19679,10 +19719,12 @@ const ViewletLayout_ipc = {
   create: create$l,
   getActiveSideBarView,
   getAllQuickPickMenuEntries,
+  getAssetDir,
   getBadgeCounts,
   getCommit,
   getInitialPlaceholderCommands,
   getKeyBindings: getKeyBindings$8,
+  getPlatform,
   getPoints,
   getQuickPickMenuEntries: getQuickPickMenuEntries$1,
   handleBadgeCountChange,
@@ -20783,7 +20825,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,
@@ -20872,7 +20914,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;
@@ -20897,7 +20939,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;
 };
@@ -21857,7 +21899,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,
@@ -21921,7 +21963,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;
 };
 
@@ -21940,7 +21982,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) => {
@@ -22205,7 +22247,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;
     }
@@ -22367,7 +22409,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;
 };
 
@@ -22647,7 +22689,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);
@@ -22745,7 +22787,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
@@ -23111,22 +23153,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']
     });
@@ -23211,7 +23253,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
   }
@@ -23238,7 +23280,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);
@@ -23412,7 +23454,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;
 };
 
@@ -23685,7 +23727,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)
@@ -23838,7 +23880,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$w(ipc, 'Initialize.initialize');
+  await invoke$x(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -23865,7 +23907,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;
 };
 
@@ -24041,7 +24083,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);
@@ -24077,7 +24119,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;
@@ -24642,7 +24684,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);
@@ -24751,7 +24793,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);
@@ -24917,7 +24959,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;
 };
 
@@ -24938,7 +24980,7 @@ const create$5 = (id, uri, x, y, width, height) => {
 };
 const loadContent$5 = async state => {
   const savedState = {};
-  await invoke$1('StatusBar.create', state.uid, '', state.x, state.y, state.width, state.height, null);
+  await invoke$1('StatusBar.create', state.uid, '', state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
   await invoke$1('StatusBar.loadContent', state.uid, savedState);
   const diffResult = await invoke$1('StatusBar.diff2', state.uid);
   const commands = await invoke$1('StatusBar.render2', state.uid, diffResult);
@@ -25148,7 +25190,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
@@ -25177,7 +25219,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);
@@ -25266,7 +25308,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 => {
@@ -25414,7 +25456,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,
@@ -25455,7 +25497,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
@@ -25611,7 +25653,7 @@ const create$1 = (id, uri, x, y, width, height) => {
     titleBarButtonsEnabled: true,
     titleBarButtonsWidth: 46 * 3,
     titleBarTitleEnabled: true,
-    platform: getPlatform(),
+    platform: getPlatform$1(),
     assetDir: assetDir
   };
 };
@@ -25738,7 +25780,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) => {
@@ -25780,7 +25822,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;
 };
 
@@ -25894,7 +25936,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
@@ -25903,14 +25945,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);
   }
 };
@@ -25938,7 +25980,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);
@@ -26043,7 +26085,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;
   }
@@ -26089,7 +26131,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');
   }