@lvce-editor/static-server 0.70.11 → 0.70.12

package/static/{7177c9a → bc489d4}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -75,7 +75,7 @@ const fn = value => {
 const state$E = {
   pending: Object.create(null)
 };
-const get$i = id => {
+const get$j = id => {
   return state$E.pending[id];
 };
 const has$2 = id => {
@@ -108,7 +108,7 @@ const getAssetDir$1 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/7177c9a';
+    return '/bc489d4';
   }
 };
 const assetDir = getAssetDir$1();
@@ -121,7 +121,7 @@ const getText$3 = response => {
 const getJson$7 = response => {
   return response.json();
 };
-const create$11 = (value, options) => {
+const create$12 = (value, options) => {
   return new Response(value, options);
 };
 
@@ -129,7 +129,7 @@ const Dash = '-';
 const DiffSeparator = '<->';
 const Dot = '.';
 const EmptyString = '';
-const NewLine$1 = '\n';
+const NewLine$2 = '\n';
 const Slash$1 = '/';
 
 /**
@@ -138,8 +138,8 @@ const Slash$1 = '/';
  * @param {number|undefined} startIndex
  * @returns
  */
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
 };
 
 const normalizeLine = line => {
@@ -156,8 +156,8 @@ const mergeStacks = (parent, child) => {
   if (!child) {
     return parent;
   }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
+  const parentNewLineIndex = getNewLineIndex$2(parent);
+  const childNewLineIndex = getNewLineIndex$2(child);
   if (childNewLineIndex === -1) {
     return parent;
   }
@@ -226,70 +226,151 @@ const getCssId = path => {
 };
 
 // @ts-nocheck
-const Two = '2.0';
-const callbacks = Object.create(null);
-const set$i = (id, fn) => {
-  callbacks[id] = fn;
+const isMessagePort$1 = value => {
+  return value && value instanceof MessagePort;
 };
-const get$h = id => {
-  return callbacks[id];
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-const remove$b = id => {
-  delete callbacks[id];
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-let id$6 = 0;
-const create$3$1 = () => {
-  return ++id$6;
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
 };
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$i(id, resolve);
-  return {
-    id,
-    promise
-  };
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
+const transferrables$1 = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable$1 = value => {
+  for (const fn of transferrables$1) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue$1 = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue$1(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue$1(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const getTransferrables$1 = value => {
+  const transferrables = [];
+  walkValue$1(value, transferrables, isTransferrable$1);
+  return transferrables;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
   };
-  return {
-    message,
-    promise
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
   };
+  that.onClose(handleClose);
 };
-class JsonRpcError extends Error {
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables$1(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
+const Two$1 = '2.0';
+const callbacks$1 = Object.create(null);
+const get$i = id => {
+  return callbacks$1[id];
+};
+const remove$c = id => {
+  delete callbacks$1[id];
+};
+let JsonRpcError$1 = class JsonRpcError extends Error {
   constructor(message) {
     super(message);
     this.name = 'JsonRpcError';
   }
-}
-const NewLine = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
+};
+const NewLine$1 = '\n';
+const DomException$1 = 'DOMException';
+const ReferenceError$1$1 = 'ReferenceError';
+const SyntaxError$1$1 = 'SyntaxError';
+const TypeError$1$1 = 'TypeError';
+const getErrorConstructor$1 = (message, type) => {
   if (type) {
     switch (type) {
-      case DomException:
+      case DomException$1:
         return DOMException;
-      case TypeError$1:
+      case TypeError$1$1:
         return TypeError;
-      case SyntaxError$1:
+      case SyntaxError$1$1:
         return SyntaxError;
-      case ReferenceError$1:
+      case ReferenceError$1$1:
         return ReferenceError;
       default:
         return Error;
@@ -306,8 +387,8 @@ const getErrorConstructor = (message, type) => {
   }
   return Error;
 };
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
+const constructError$1 = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor$1(message, type);
   if (ErrorConstructor === DOMException && name) {
     return new ErrorConstructor(message, name);
   }
@@ -320,46 +401,48 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-const joinLines$1 = lines => {
-  return lines.join(NewLine);
+const joinLines$2 = lines => {
+  return lines.join(NewLine$1);
 };
-const splitLines$1 = lines => {
-  return lines.split(NewLine);
+const splitLines$2 = lines => {
+  return lines.split(NewLine$1);
 };
-const getCurrentStack = () => {
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(2));
+const getCurrentStack$1 = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines$2(splitLines$2(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, startIndex);
 };
-const getParentStack = error => {
+const getParentStack$1 = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
+    parentStack = error.message + NewLine$1 + parentStack;
   }
   return parentStack;
 };
-const MethodNotFound = -32601;
-const restoreJsonRpcError = error => {
-  const currentStack = getCurrentStack();
+const MethodNotFound$1 = -32601;
+const Custom = -32001;
+const restoreJsonRpcError$1 = error => {
+  const currentStack = getCurrentStack$1();
   if (error && error instanceof Error) {
     if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
+      error.stack = error.stack + NewLine$1 + currentStack;
     }
     return error;
   }
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
+  if (error && error.code && error.code === MethodNotFound$1) {
+    const restoredError = new JsonRpcError$1(error.message);
+    const parentStack = getParentStack$1(error);
+    restoredError.stack = parentStack + NewLine$1 + currentStack;
     return restoredError;
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
+    const restoredError = constructError$1(error.message, error.type, error.name);
     if (error.data) {
       if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$1 + error.data.stack + NewLine$1 + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
@@ -379,8 +462,8 @@ const restoreJsonRpcError = error => {
       if (error.stack) {
         const lowerStack = restoredError.stack || '';
         // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
+        const indexNewLine = getNewLineIndex$1(lowerStack);
+        const parentStack = getParentStack$1(error);
         // @ts-ignore
         restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
       }
@@ -396,47 +479,389 @@ const restoreJsonRpcError = error => {
   }
   return new Error(`JsonRpc Error: ${error}`);
 };
-const unwrapJsonRpcResult = responseMessage => {
+const unwrapJsonRpcResult$1 = responseMessage => {
   if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
+    const restoredError = restoreJsonRpcError$1(responseMessage.error);
     throw restoredError;
   }
   if ('result' in responseMessage) {
     return responseMessage.result;
   }
-  throw new JsonRpcError('unexpected response message');
+  throw new JsonRpcError$1('unexpected response message');
 };
-const warn$1 = (...args) => {
+const warn$2 = (...args) => {
   console.warn(...args);
 };
-const resolve = (id, response) => {
-  const fn = get$h(id);
+const resolve$1 = (id, response) => {
+  const fn = get$i(id);
   if (!fn) {
     console.log(response);
-    warn$1(`callback ${id} may already be disposed`);
+    warn$2(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove$b(id);
+  remove$c(id);
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+const E_COMMAND_NOT_FOUND$1 = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND$1) {
+    return {
+      code: MethodNotFound$1,
+      message: error.message,
+      data: error.stack
+    };
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: getStack(prettyError),
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$1 = (id, error) => {
+  return {
+    jsonrpc: Two$1,
+    id,
+    error
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$p$1 = (message, result) => {
+  return {
+    jsonrpc: Two$1,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$p$1(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two$1,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
+const getResponse$2 = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve$1;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
+  }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage$1 = async (...args) => {
+  const options = normalizeParams(args);
   const {
     message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse$2(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse$2(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError$1('unexpected message');
+};
+let CommandNotFoundError$1 = class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+};
+const commands = Object.create(null);
+const register$2 = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute$4 = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError$1(command);
+  }
+  return fn(...args);
+};
+const Two$2 = '2.0';
+const create$o$1 = (method, params) => {
+  return {
+    jsonrpc: Two$2,
+    method,
+    params
+  };
+};
+const create$n$1 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two$2,
+    method,
+    params
+  };
+  return message;
+};
+let id$7 = 0;
+const create$m$1 = () => {
+  return ++id$7;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise$1 = map => {
+  const id = create$m$1();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
     promise
-  } = create$2$1(method, params);
+  };
+};
+
+// @ts-ignore
+const invokeHelper$1 = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise$1(callbacks);
+  const message = create$n$1(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
     ipc.send(message);
   }
   const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
+  return unwrapJsonRpcResult$1(responseMessage);
 };
-const invoke$x = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper$1(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper$1(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$o$1(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
 };
-const invokeAndTransfer$e = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError$1 = () => {
+  // handled by renderer worker
+};
+const handleMessage$2 = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute$4;
+  return handleJsonRpcMessage$1(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+};
+const handleIpc$1 = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage$2);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage$2);
+  }
+};
+const listen$2 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$11 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$2(commandMap);
+  const ipc = await listen$2(IpcChildWithModuleWorker$1);
+  handleIpc$1(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient2 = {
+  __proto__: null,
+  create: create$11
+};
+
+const commandMapRef = {};
+
+// @ts-ignore
+const state$D = {
+  pendingMessages: [],
+  /**
+   * @type {any}
+   */
+  rpc: undefined
+};
+const getRpc = async () => {
+  // TODO replace this with a static commandmap
+
+  const rpc = await WebWorkerRpcClient2.create({
+    commandMap: commandMapRef
+  });
+  return rpc;
+};
+const listen$1 = async () => {
+  console.assert(state$D.pendingMessages.length === 0);
+  const rpc = await getRpc();
+  state$D.rpc = rpc;
+};
+const invoke$x = (method, ...params) => {
+  return state$D.rpc.invoke(method, ...params);
+};
+const invokeAndTransfer$e = (method, ...params) => {
+  return state$D.rpc.invokeAndTransfer(method, ...params);
+};
+
+const actuallyLoadCssStyleSheet = async css => {
+  const text = await getCss(css);
+  const id = getCssId(css);
+  await addCssStyleSheet(id, text);
+};
+const loadCssStyleSheet = id => {
+  if (!has$2(id)) {
+    set$j(id, actuallyLoadCssStyleSheet(id));
+  }
+  return get$j(id);
+};
+const loadCssStyleSheets = css => {
+  return Promise.all(css.map(loadCssStyleSheet));
+};
+const addCssStyleSheet = (id, css) => {
+  return invoke$x('Css.addCssStyleSheet', id, css);
+};
+const actuallyAddDynamicCss = async (id, getCss, preferences) => {
+  const css = await getCss(preferences);
+  await addCssStyleSheet(id, css);
+};
+const addDynamicCss = (id, getCss, preferences) => {
+  if (!has$2(id)) {
+    set$j(id, actuallyAddDynamicCss(id, getCss, preferences));
+  }
+  return get$j(id);
 };
 
 const ENOENT = 'ENOENT';
@@ -800,7 +1225,7 @@ const getModuleId$1 = commandId => {
   }
 };
 
-const state$D = {
+const state$C = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -823,29 +1248,29 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$D.load(moduleId);
+    const module = await state$C.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$D.pendingModules[moduleId]) {
-    state$D.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$C.pendingModules[moduleId]) {
+    state$C.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$D.pendingModules[moduleId];
+  return state$C.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId$1(command));
 const register$1 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$D.commands[commandId] = listener;
+  state$C.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$3 = (command, ...args) => {
-  if (command in state$D.commands) {
-    const fn = state$D.commands[command];
+  if (command in state$C.commands) {
+    const fn = state$C.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -854,7 +1279,7 @@ const execute$3 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$D.commands)) {
+    if (!(command in state$C.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -865,259 +1290,221 @@ const execute$3 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$D.load = load;
+  state$C.load = load;
 };
 
-const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
-  if (!message || typeof message === 'string') {
-    console.warn(`unexpected message from ${source}: ${message}`);
-    return;
-  }
-  if (message.id) {
-    if ('method' in message) {
-      try {
-        const result = await execute(message.method, ...message.params);
-        ipc.send({
-          jsonrpc: '2.0',
-          id: message.id,
-          result
-        });
-        return;
-      } catch (error) {
-        ipc.send({
-          jsonrpc: '2.0',
-          id: message.id,
-          error
-        });
-        return;
-      }
-    }
-    resolve(message.id, message);
-    return;
-  }
-  await execute(message.method, ...message.params);
+// @ts-nocheck
+const Two = '2.0';
+const callbacks = Object.create(null);
+const set$i = (id, fn) => {
+  callbacks[id] = fn;
 };
-
-const handleMessage$1 = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute$3, resolve, 'process');
+const get$h = id => {
+  return callbacks[id];
 };
-
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage$1);
-  } else {
-    // deprecated
-    ipc.onmessage = handleMessage$1;
-  }
+const remove$b = id => {
+  delete callbacks[id];
 };
-const unhandleIpc = ipc => {
-  if ('removeEventListener' in ipc) {
-    ipc.removeEventListener('message', handleMessage$1);
-  } else {
-    // deprecated
-    ipc.onmessage = null;
-  }
+let id$6 = 0;
+const create$3$1 = () => {
+  return ++id$6;
 };
-
-const MessagePort$2 = 1;
-const ModuleWorker$1 = 2;
-const ReferencePort$1 = 3;
-const Auto = () => {
-  if (globalThis.acceptPort) {
-    return MessagePort$2;
-  }
-  if (globalThis.acceptReferencePort) {
-    return ReferencePort$1;
-  }
-  return ModuleWorker$1;
+const registerPromise = () => {
+  const id = create$3$1();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$i(id, resolve);
+  return {
+    id,
+    promise
+  };
 };
-
-const getData$1$1 = event => {
-  return event.data;
+const create$2$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
 };
-const walkValue$1 = (value, transferrables2, isTransferrable2) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable2(value)) {
-    transferrables2.push(value);
-    return;
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
   }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue$1(item, transferrables2, isTransferrable2);
+}
+const NewLine = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
     }
-    return;
   }
-  if (typeof value === "object") {
-    for (const property of Object.values(value)) {
-      walkValue$1(property, transferrables2, isTransferrable2);
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
     }
-    return;
+    return error;
   }
+  return new ErrorConstructor(message);
 };
-const isMessagePort$1 = value => {
-  return value && value instanceof MessagePort;
-};
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === "MessagePortMain";
-};
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas;
-};
-const isInstanceOf = (value, constructorName) => {
-  var _a;
-  return ((_a = value == null ? void 0 : value.constructor) == null ? void 0 : _a.name) === constructorName;
-};
-const isSocket = value => {
-  return isInstanceOf(value, "Socket");
+const joinLines$1 = lines => {
+  return lines.join(NewLine);
 };
-const transferrables$1 = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable$1 = value => {
-  for (const fn of transferrables$1) {
-    if (fn(value)) {
-      return true;
-    }
-  }
-  return false;
+const splitLines$1 = lines => {
+  return lines.split(NewLine);
 };
-const getTransferrables$1 = value => {
-  const transferrables2 = [];
-  walkValue$1(value, transferrables2, isTransferrable$1);
-  return transferrables2;
+const getCurrentStack = () => {
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(2));
+  return currentStack;
 };
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent("message", {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event("close"));
-  };
-  that.onClose(handleClose);
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
-  }
-}
-const readyMessage = "ready";
-const listen$4 = () => {
-  if (typeof WorkerGlobalScope === "undefined") {
-    throw new TypeError("module is not in web worker scope");
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
   }
-  return globalThis;
-};
-const signal$3 = global => {
-  global.postMessage(readyMessage);
+  return parentStack;
 };
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$1$1(event);
+const MethodNotFound = -32601;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
+    return error;
   }
-  send(message) {
-    this._rawIpc.postMessage(message);
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine + currentStack;
+    return restoredError;
   }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables$1(message);
-    this._rawIpc.postMessage(message, transfer);
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
   }
-  dispose() {}
-  onClose(callback) {}
-  onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
   }
-}
-const wrap$6$1 = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6$1
+  return new Error(`JsonRpc Error: ${error}`);
 };
-
-const getModule$6 = method => {
-  switch (method) {
-    case ModuleWorker$1:
-      return IpcChildWithModuleWorker$1;
-    default:
-      throw new Error('unexpected ipc type');
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
   }
-};
-
-const listen$2 = async ({
-  method
-}) => {
-  const module = await getModule$6(method);
-  const rawIpc = await module.listen();
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc);
+  if ('result' in responseMessage) {
+    return responseMessage.result;
   }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-/* istanbul ignore file */
-const state$C = {
-  pendingMessages: [],
-  /**
-   * @type {any}
-   */
-  ipc: undefined
-};
-const getIpc = () => {
-  return listen$2({
-    method: Auto()
-  });
-};
-const listen$1 = async () => {
-  console.assert(state$C.pendingMessages.length === 0);
-  const ipc = await getIpc();
-  handleIpc(ipc);
-  state$C.ipc = ipc;
-};
-const invoke$w = (method, ...params) => {
-  return invoke$x(state$C.ipc, method, ...params);
-};
-const invokeAndTransfer$d = (method, ...params) => {
-  return invokeAndTransfer$e(state$C.ipc, method, ...params);
+  throw new JsonRpcError('unexpected response message');
 };
-
-const actuallyLoadCssStyleSheet = async css => {
-  const text = await getCss(css);
-  const id = getCssId(css);
-  await addCssStyleSheet(id, text);
+const warn$1 = (...args) => {
+  console.warn(...args);
 };
-const loadCssStyleSheet = id => {
-  if (!has$2(id)) {
-    set$j(id, actuallyLoadCssStyleSheet(id));
+const resolve = (id, response) => {
+  const fn = get$h(id);
+  if (!fn) {
+    console.log(response);
+    warn$1(`callback ${id} may already be disposed`);
+    return;
   }
-  return get$i(id);
-};
-const loadCssStyleSheets = css => {
-  return Promise.all(css.map(loadCssStyleSheet));
+  fn(response);
+  remove$b(id);
 };
-const addCssStyleSheet = (id, css) => {
-  return invoke$w('Css.addCssStyleSheet', id, css);
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const actuallyAddDynamicCss = async (id, getCss, preferences) => {
-  const css = await getCss(preferences);
-  await addCssStyleSheet(id, css);
+const invoke$w = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
 };
-const addDynamicCss = (id, getCss, preferences) => {
-  if (!has$2(id)) {
-    set$j(id, actuallyAddDynamicCss(id, getCss, preferences));
-  }
-  return get$i(id);
+const invokeAndTransfer$d = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
 
 const workers = new Map();
@@ -1131,11 +1518,11 @@ const getOrCreateWorker = fn => {
   return {
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invoke$x(ipc, method, ...params);
+      return invoke$w(ipc, method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invokeAndTransfer$e(ipc, method, ...params);
+      return invokeAndTransfer$d(ipc, method, ...params);
     },
     async dispose() {
       const promise = workers.get(fn);
@@ -1160,6 +1547,57 @@ const getOrCreateWorker = fn => {
 
 const errorWorkerUrl = `${assetDir}/packages/error-worker/dist/errorWorkerMain.js`;
 
+const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
+  if (!message || typeof message === 'string') {
+    console.warn(`unexpected message from ${source}: ${message}`);
+    return;
+  }
+  if (message.id) {
+    if ('method' in message) {
+      try {
+        const result = await execute(message.method, ...message.params);
+        ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          result
+        });
+        return;
+      } catch (error) {
+        ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          error
+        });
+        return;
+      }
+    }
+    resolve(message.id, message);
+    return;
+  }
+  await execute(message.method, ...message.params);
+};
+
+const handleMessage$1 = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute$3, resolve, 'process');
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage$1);
+  } else {
+    // deprecated
+    ipc.onmessage = handleMessage$1;
+  }
+};
+const unhandleIpc = ipc => {
+  if ('removeEventListener' in ipc) {
+    ipc.removeEventListener('message', handleMessage$1);
+  } else {
+    // deprecated
+    ipc.onmessage = null;
+  }
+};
+
 const ElectronMessagePort = 1;
 const MessagePort$1 = 2;
 const ModuleWorker = 3;
@@ -1564,7 +2002,7 @@ const isTest = () => {
 };
 
 const stringify = value => {
-  return JSON.stringify(value, null, 2) + NewLine$1;
+  return JSON.stringify(value, null, 2) + NewLine$2;
 };
 const stringifyCompact = value => {
   return JSON.stringify(value);
@@ -1597,14 +2035,14 @@ const invoke$u = async (method, ...params) => {
   const {
     ipc
   } = state$y;
-  const result = await invoke$x(ipc, method, ...params);
+  const result = await invoke$w(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$b = async (method, ...params) => {
   const {
     ipc
   } = state$y;
-  const result = await invokeAndTransfer$e(ipc, method, ...params);
+  const result = await invokeAndTransfer$d(ipc, method, ...params);
   return result;
 };
 
@@ -1711,7 +2149,7 @@ const launchExtensionManagementWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.extensionManagementWorkerPath', extensionManagementWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Extensions.initialize', getPlatform$1());
+  await invoke$w(ipc, 'Extensions.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -1769,7 +2207,7 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$w(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$x(/* 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
@@ -1877,7 +2315,7 @@ const handleEvent = async (id, event) => {
       if (!ipc) {
         return;
       }
-      await invoke$x(ipc, alternate.callBackCommandId, event);
+      await invoke$w(ipc, alternate.callBackCommandId, event);
       return;
     }
     console.warn(`target not found ${id}`);
@@ -1938,7 +2376,7 @@ const reloadElectron = () => {
 };
 
 const reloadWeb = () => {
-  return invoke$w('Window.reload');
+  return invoke$x('Window.reload');
 };
 
 const getFn$2 = () => {
@@ -2086,7 +2524,7 @@ const launchTestWorker = async () => {
 
 const execute$2 = async href => {
   const ipc = await launchTestWorker();
-  await invoke$x(ipc, 'Test.execute', href, getPlatform$1(), assetDir);
+  await invoke$w(ipc, 'Test.execute', href, getPlatform$1(), assetDir);
 };
 
 const executeCurrentTest = async (platform, initData) => {
@@ -2209,7 +2647,7 @@ const getAvailableKeyBindings = keyBindings => {
 const update = () => {
   const matchingKeyBindings = getMatchingKeyBindings(state$s.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$w('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  invoke$x('KeyBindings.setIdentifiers', keyBindingIdentifiers);
   state$s.matchingKeyBindings = matchingKeyBindings;
   state$s.keyBindingIdentifiers = keyBindingIdentifiers;
 };
@@ -2385,13 +2823,13 @@ const serializeObjects = objects => {
 };
 
 const clear$5 = async storageType => {
-  await invoke$w(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$x(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$w('WebStorage.getAll', storageType);
+  return invoke$x('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$w(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$x(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$6 = async (storageType, key) => {
@@ -2406,7 +2844,7 @@ const getJson$6 = async (storageType, key) => {
   }
 };
 const setText$1 = async (storageType, key, value) => {
-  await invoke$w(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$x(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$5 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -2414,7 +2852,7 @@ const setJson$5 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = serializeObjects(objects);
-  await invoke$w('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$x('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -2623,20 +3061,20 @@ const getResolvedRoot = async href => {
 };
 
 const getHref = () => {
-  return invoke$w(/* Location.getHref */'Location.getHref');
+  return invoke$x(/* Location.getHref */'Location.getHref');
 };
 const setPathName = pathName => {
-  return invoke$w(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+  return invoke$x(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
 const hydrate$6 = () => {
-  return invoke$w(/* Location.hydrate */'Location.hydrate');
+  return invoke$x(/* Location.hydrate */'Location.hydrate');
 };
 const getHost = () => {
   return location.host;
 };
 
 const set$a = title => {
-  return invoke$w('WindowTitle.set', title);
+  return invoke$x('WindowTitle.set', title);
 };
 
 const state$p = {
@@ -2863,7 +3301,7 @@ const create$_ = async ({
     port1,
     port2
   } = getPortTuple(port);
-  await invokeAndTransfer$d('IpcParent.create', {
+  await invokeAndTransfer$e('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
@@ -2939,7 +3377,7 @@ const getConfig = () => {
 
 const objects = Object.create(null);
 const transferToRendererProcess = async (objectId, transferable) => {
-  await invokeAndTransfer$d('Transferrable.transfer', transferable, objectId);
+  await invokeAndTransfer$e('Transferrable.transfer', transferable, objectId);
 };
 const transfer = (objectId, transferable) => {
   number(objectId);
@@ -2971,9 +3409,9 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$x(ipc, 'Workspace.setWorkspacePath', state$p.workspacePath);
+  await invoke$w(ipc, 'Workspace.setWorkspacePath', state$p.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$x(ipc, 'Workspace.setWorkspacePath', state$p.workspacePath);
+    await invoke$w(ipc, 'Workspace.setWorkspacePath', state$p.workspacePath);
   });
   return ipc;
 };
@@ -3055,7 +3493,7 @@ const hydrate$4 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$w('Window.onVisibilityChange');
+  await invoke$x('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$4(viewletId);
@@ -3088,7 +3526,7 @@ const launchFileSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$x(ipc, 'QuickPick.initialize');
+    await invoke$w(ipc, 'QuickPick.initialize');
   } catch {
     // ignore
   }
@@ -3304,7 +3742,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$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$x(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3330,7 +3768,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
     return;
   }
   updateDynamicFocusContext(commands);
-  await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$x(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -3536,7 +3974,7 @@ const maybeRegisterEvents = module => {
       const commands = render$F(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
       instance.state = newState;
       instance.renderedState = newState;
-      await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$x(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     };
     addListener('workspace.change', handleUpdate);
   }
@@ -3563,7 +4001,7 @@ const maybeRegisterEvents = module => {
         const commands = render$F(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$x(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -3591,7 +4029,7 @@ const maybeRegisterMenuEntries = async module => {
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
   if (!module.hasFunctionalEvents) {
-    await invoke$w(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
+    await invoke$x(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
   }
   await loadModule$1(id, module);
   await maybeRegisterWrappedCommands(id, module);
@@ -3685,7 +4123,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$w('Viewlet.registerEventListeners', viewletUid, eventListeners);
+      await invoke$x('Viewlet.registerEventListeners', viewletUid, eventListeners);
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
       await module.show(newState);
@@ -3739,7 +4177,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$w(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$x(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -3800,7 +4238,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       commands.push(...extraCommands);
       updateDynamicFocusContext(commands);
-      await invoke$w(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$x(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else if (!module.hasFunctionalEvents && shouldRender) {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -3821,7 +4259,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$w(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$x(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -3843,10 +4281,10 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$w(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$x(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$w(kLoadModule, Error$4);
+      await invoke$x(kLoadModule, Error$4);
       commands.push([kCreate, Error$4, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -3855,7 +4293,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$w(kLoadModule, module.customErrorRenderer);
+        await invoke$x(kLoadModule, module.customErrorRenderer);
         commands.push([kCreate, module.customErrorRenderer, viewletUid]);
         commands.push(['Viewlet.setDom2', viewletUid, dom]);
         commands.push([kAppend, parentUid, viewletUid]);
@@ -3957,7 +4395,7 @@ const focus$5 = async id => {
     commands.push(...render$F(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$w('Viewlet.sendMultiple', commands);
+  await invoke$x('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -4000,7 +4438,7 @@ const dispose$r = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$w(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$x(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -4181,7 +4619,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$w(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$x(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -4224,7 +4662,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$w('Viewlet.executeCommands', commands);
+  await invoke$x('Viewlet.executeCommands', commands);
 };
 const closeWidget = async id => {
   try {
@@ -4236,7 +4674,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$w(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$x(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4294,7 +4732,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$w(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$x(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 
 // @ts-ignore
@@ -4334,7 +4772,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$w('Viewlet.sendMultiple', commands);
+    await invoke$x('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4421,7 +4859,7 @@ const hydrate$3 = async (platform, assetDir) => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$w('InitData.getInitData');
+  const rendererProcessInitData = await invoke$x('InitData.getInitData');
   // TODO get the following items
   // - location.href
   // - workspace
@@ -4528,7 +4966,7 @@ const create$Y = (rawLines, loc, opts = {}) => {
       return ['>', gutter, line.length > 0 ? ` ${line}` : '', markerLine].join('');
     }
     return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`;
-  }).join(NewLine$1);
+  }).join(NewLine$2);
   if (opts.message && !hasColumns) {
     frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
   }
@@ -4612,7 +5050,7 @@ const getNthFileExtension = (file, startIndex) => {
 
 const splitLines = lines => {
   string(lines);
-  return lines.split(NewLine$1);
+  return lines.split(NewLine$2);
 };
 
 // TODO merge all of this with extension host languages module
@@ -5400,7 +5838,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$C.ipc;
+  const originalIpc = state$D.rpc.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -5415,33 +5853,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$C.ipc.onmessage = originalAddEventListsner;
-          state$C.ipc.send = originalSend;
+          state$D.rpc.ipc.onmessage = originalAddEventListsner;
+          state$D.rpc.ipc.send = originalSend;
           await execute$3('ElectronWindow.close');
-          state$C.ipc.onmessage = wrappedOnMessage;
-          state$C.ipc.send = wrappedSend;
+          state$D.rpc.ipc.onmessage = wrappedOnMessage;
+          state$D.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$C.ipc.onmessage = originalAddEventListsner;
-          state$C.ipc.send = originalSend;
+          state$D.rpc.ipc.onmessage = originalAddEventListsner;
+          state$D.rpc.ipc.send = originalSend;
           await execute$3('ElectronWindow.minimize');
-          state$C.ipc.onmessage = wrappedOnMessage;
-          state$C.ipc.send = wrappedSend;
+          state$D.rpc.ipc.onmessage = wrappedOnMessage;
+          state$D.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$C.ipc.onmessage = originalAddEventListsner;
-          state$C.ipc.send = originalSend;
+          state$D.rpc.ipc.onmessage = originalAddEventListsner;
+          state$D.rpc.ipc.send = originalSend;
           await execute$3('ElectronWindow.maximize');
-          state$C.ipc.onmessage = wrappedOnMessage;
-          state$C.ipc.send = wrappedSend;
+          state$D.rpc.ipc.onmessage = wrappedOnMessage;
+          state$D.rpc.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$C.ipc.send = wrappedSend;
-  state$C.ipc.addEventListener('message', wrappedOnMessage);
+  state$D.rpc.send = wrappedSend;
+  state$D.rpc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -5513,7 +5951,7 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$C.ipc = wrapIpc(state$C.ipc, 'renderer-process', event => event.data);
+  state$D.rpc.ipc = wrapIpc(state$D.rpc, 'renderer-process', event => event.data);
   state$y.ipc = wrapIpc(state$y.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
@@ -5808,7 +6246,7 @@ const startup = async (platform, assetDir) => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$w('Viewlet.executeCommands', commands);
+  await invoke$x('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
@@ -5857,7 +6295,426 @@ const startup = async (platform, assetDir) => {
   await watcherPromises;
 };
 
+const lazy = key => async (...args) => {
+  await loadCommand(key);
+  execute$3(key, ...args);
+};
+const commandMap = {
+  'About.showAbout': lazy('About.showAbout'),
+  'Ajax.getBlob': lazy('Ajax.getBlob'),
+  'Ajax.getJson': lazy('Ajax.getJson'),
+  'Ajax.getText': lazy('Ajax.getText'),
+  'Audio.handleAudioError': lazy('Audio.handleAudioError'),
+  'Audio.playBell': lazy('Audio.playBell'),
+  'AutoUpdater.checkForUpdates': lazy('AutoUpdater.checkForUpdates'),
+  'Blob.base64StringToBlob': lazy('Blob.base64StringToBlob'),
+  'Blob.binaryStringToBlob': lazy('Blob.binaryStringToBlob'),
+  'Blob.blobToBinaryString': lazy('Blob.blobToBinaryString'),
+  'Blob.getSrc': lazy('Blob.getSrc'),
+  'BulkReplacement.applyBulkReplacement': lazy('BulkReplacement.applyBulkReplacement'),
+  'CacheStorage.clearCache': lazy('CacheStorage.clearCache'),
+  'CacheStorage.getJson': lazy('CacheStorage.getJson'),
+  'CacheStorage.setJson': lazy('CacheStorage.setJson'),
+  'Callback.resolve': lazy('Callback.resolve'),
+  'Chrome.close': lazy('Chrome.close'),
+  'Chrome.exit': lazy('Chrome.exit'),
+  'Chrome.maximize': lazy('Chrome.maximize'),
+  'Chrome.minimize': lazy('Chrome.minimize'),
+  'Chrome.unmaximize': lazy('Chrome.unmaximize'),
+  'ClipBoard.disableMemoryClipBoard': lazy('ClipBoard.disableMemoryClipBoard'),
+  'ClipBoard.enableMemoryClipBoard': lazy('ClipBoard.enableMemoryClipBoard'),
+  'ClipBoard.execCopy': lazy('ClipBoard.execCopy'),
+  'ClipBoard.hotReload': lazy('ClipBoard.hotReload'),
+  'ClipBoard.readMemoryText': lazy('ClipBoard.readMemoryText'),
+  'ClipBoard.readNativeFiles': lazy('ClipBoard.readNativeFiles'),
+  'ClipBoard.readText': lazy('ClipBoard.readText'),
+  'ClipBoard.writeImage': lazy('ClipBoard.writeImage'),
+  'ClipBoard.writeNativeFiles': lazy('ClipBoard.writeNativeFiles'),
+  'ClipBoard.writeText': lazy('ClipBoard.writeText'),
+  'ColorTheme.getColorThemeNames': lazy('ColorTheme.getColorThemeNames'),
+  'ColorTheme.hydrate': lazy('ColorTheme.hydrate'),
+  'ColorTheme.reload': lazy('ColorTheme.reload'),
+  'ColorTheme.setColorTheme': lazy('ColorTheme.setColorTheme'),
+  'ConfirmPrompt.mock': lazy('ConfirmPrompt.mock'),
+  'ConfirmPrompt.prompt': lazy('ConfirmPrompt.prompt'),
+  'ConfirmPrompt.showErrorMessage': lazy('ConfirmPrompt.showErrorMessage'),
+  'ContentTracing.start': lazy('ContentTracing.start'),
+  'ContentTracing.stop': lazy('ContentTracing.stop'),
+  'ContextMenu.show': lazy('ContextMenu.show'),
+  'ContextMenu.show2': lazy('ContextMenu.show2'),
+  'Debug.paused': lazy('Debug.paused'),
+  'Debug.resumed': lazy('Debug.resumed'),
+  'Debug.scriptParsed': lazy('Debug.scriptParsed'),
+  'DebugSharedProcess.debugSharedProcess': lazy('DebugSharedProcess.debugSharedProcess'),
+  'Developer.allocateMemoryInSharedProcess': lazy('Developer.allocateMemoryInSharedProcess'),
+  'Developer.clearCache': lazy('Developer.clearCache'),
+  'Developer.crashMainProcess': lazy('Developer.crashMainProcess'),
+  'Developer.crashSharedProcess': lazy('Developer.crashSharedProcess'),
+  'Developer.createSharedProcessHeapSnapshot': lazy('Developer.createSharedProcessHeapSnapshot'),
+  'Developer.createSharedProcessProfile': lazy('Developer.createSharedProcessProfile'),
+  'Developer.downloadViewletState': lazy('Developer.downloadViewletState'),
+  'Developer.getMemoryUsageContent': lazy('Developer.getMemoryUsageContent'),
+  'Developer.getStartupPerformanceContent': lazy('Developer.getStartupPerformanceContent'),
+  'Developer.openBrowserViewOverview': lazy('Developer.openBrowserViewOverview'),
+  'Developer.openCacheFolder': lazy('Developer.openCacheFolder'),
+  'Developer.openConfigFolder': lazy('Developer.openConfigFolder'),
+  'Developer.openDataFolder': lazy('Developer.openDataFolder'),
+  'Developer.openIframeInspector': lazy('Developer.openIframeInspector'),
+  'Developer.openLogsFolder': lazy('Developer.openLogsFolder'),
+  'Developer.openProcessExplorer': lazy('Developer.openProcessExplorer'),
+  'Developer.openScreenCastView': lazy('Developer.openScreenCastView'),
+  'Developer.openStorageOverview': lazy('Developer.openStorageOverview'),
+  'Developer.reloadColorTheme': lazy('Developer.reloadColorTheme'),
+  'Developer.reloadIconTheme': lazy('Developer.reloadIconTheme'),
+  'Developer.showColorThemeCss': lazy('Developer.showColorThemeCss'),
+  'Developer.showMemoryUsage': lazy('Developer.showMemoryUsage'),
+  'Developer.showStartupPerformance': lazy('Developer.showStartupPerformance'),
+  'Developer.startupPerformance': lazy('Developer.startupPerformance'),
+  'Developer.toggleDeveloperTools': lazy('Developer.toggleDeveloperTools'),
+  'Dialog.close': lazy('Dialog.close'),
+  'Dialog.handleClick': lazy('Dialog.handleClick'),
+  'Dialog.openFile': lazy('Dialog.openFile'),
+  'Dialog.openFolder': lazy('Dialog.openFolder'),
+  'Dialog.showMessage': lazy('Dialog.showMessage'),
+  'Document.getSelectionText': lazy('Document.getSelectionText'),
+  'Download.downloadFile': lazy('Download.downloadFile'),
+  'Download.downloadJson': lazy('Download.downloadJson'),
+  'Download.downloadToDownloadsFolder': lazy('Download.downloadToDownloadsFolder'),
+  'EditorDiagnostics.hydrate': lazy('EditorDiagnostics.hydrate'),
+  'EditorError.3900': lazy('EditorError.3900'),
+  'ElectronBrowserView.handleDidNavigate': lazy('ElectronBrowserView.handleDidNavigate'),
+  'ElectronBrowserView.handleTitleUpdated': lazy('ElectronBrowserView.handleTitleUpdated'),
+  'ElectronBrowserView.handleWillNavigate': lazy('ElectronBrowserView.handleWillNavigate'),
+  'ElectronClipBoard.writeText': lazy('ElectronClipBoard.writeText'),
+  'ElectronContentTracing.startRecording': lazy('ElectronContentTracing.startRecording'),
+  'ElectronContentTracing.stopRecording': lazy('ElectronContentTracing.stopRecording'),
+  'ElectronDialog.showMessageBox': lazy('ElectronDialog.showMessageBox'),
+  'ElectronWindow.close': lazy('ElectronWindow.close'),
+  'ElectronWindow.maximize': lazy('ElectronWindow.maximize'),
+  'ElectronWindow.minimize': lazy('ElectronWindow.minimize'),
+  'ElectronWindow.openNew': lazy('ElectronWindow.openNew'),
+  'ElectronWindow.toggleDevtools': lazy('ElectronWindow.toggleDevtools'),
+  'ElectronWindow.unmaximize': lazy('ElectronWindow.unmaximize'),
+  'ElectronWindow.zoomIn': lazy('ElectronWindow.zoomIn'),
+  'ElectronWindow.zoomOut': lazy('ElectronWindow.zoomOut'),
+  'ElectronWindow.zoomReset': lazy('ElectronWindow.zoomReset'),
+  'ErrorHandling.handleError': lazy('ErrorHandling.handleError'),
+  'ErrorHandling.showErrorDialog': lazy('ErrorHandling.showErrorDialog'),
+  'Exec.exec': lazy('Exec.exec'),
+  'Exit.exit': lazy('Exit.exit'),
+  'ExtensionHost.executeCommand': lazy('ExtensionHost.executeCommand'),
+  'ExtensionHost.getCommands': lazy('ExtensionHost.getCommands'),
+  'ExtensionHost.loadWebExtension': lazy('ExtensionHost.loadWebExtension'),
+  'ExtensionHost.searchFileWithFetch': lazy('ExtensionHost.searchFileWithFetch'),
+  'ExtensionHostBraceCompletion.executeBraceCompletionProvider': lazy('ExtensionHostBraceCompletion.executeBraceCompletionProvider'),
+  'ExtensionHostClosingTagCompletion.executeClosingTagProvider': lazy('ExtensionHostClosingTagCompletion.executeClosingTagProvider'),
+  'ExtensionHostDefinition.executeDefinitionProvider': lazy('ExtensionHostDefinition.executeDefinitionProvider'),
+  'ExtensionHostDialog.showInformationMessage': lazy('ExtensionHostDialog.showInformationMessage'),
+  'ExtensionHostHover.executeHoverProvider': lazy('ExtensionHostHover.executeHoverProvider'),
+  'ExtensionHostManagement.activateByEvent': lazy('ExtensionHostManagement.activateByEvent'),
+  'ExtensionHostOrganizeImports.organizeImports': lazy('ExtensionHostOrganizeImports.organizeImports'),
+  'ExtensionHostQuickPick.show': lazy('ExtensionHostQuickPick.show'),
+  'ExtensionHostSelection.executeGrowSelection': lazy('ExtensionHostSelection.executeGrowSelection'),
+  'ExtensionHostState.getSavedState': lazy('ExtensionHostState.getSavedState'),
+  'ExtensionHostState.saveState': lazy('ExtensionHostState.saveState'),
+  'ExtensionHostTabCompletion.executeTabCompletionProvider': lazy('ExtensionHostTabCompletion.executeTabCompletionProvider'),
+  'ExtensionHostTextSearch.executeTextSearchProvider': lazy('ExtensionHostTextSearch.executeTextSearchProvider'),
+  'ExtensionHostTextSearch.textSearchFetch': lazy('ExtensionHostTextSearch.textSearchFetch'),
+  'ExtensionHostTextSearch.textSearchHtml': lazy('ExtensionHostTextSearch.textSearchHtml'),
+  'ExtensionHostTextSearch.textSearchMemory': lazy('ExtensionHostTextSearch.textSearchMemory'),
+  'ExtensionHostTextSearch.textSearchMemory2': lazy('ExtensionHostTextSearch.textSearchMemory2'),
+  'ExtensionHostTypeDefinition.executeTypeDefinitionProvider': lazy('ExtensionHostTypeDefinition.executeTypeDefinitionProvider'),
+  'ExtensionHostWorkerContentSecurityPolicy.set': lazy('ExtensionHostWorkerContentSecurityPolicy.set'),
+  'ExtensionManagement.disable': lazy('ExtensionManagement.disable'),
+  'ExtensionManagement.enable': lazy('ExtensionManagement.enable'),
+  'ExtensionManagement.getAllExtensions': lazy('ExtensionManagement.getAllExtensions'),
+  'ExtensionManagement.getExtension': lazy('ExtensionManagement.getExtension'),
+  'ExtensionManagement.getExtensions': lazy('ExtensionManagement.getExtensions'),
+  'ExtensionManagement.getExtensionsEtag': lazy('ExtensionManagement.getExtensionsEtag'),
+  'ExtensionManagement.handleExtensionStatusUpdate': lazy('ExtensionManagement.handleExtensionStatusUpdate'),
+  'ExtensionManagement.invalidateExtensionsCache': lazy('ExtensionManagement.invalidateExtensionsCache'),
+  'ExtensionManagement.uninstall': lazy('ExtensionManagement.uninstall'),
+  'ExtensionMeta.addNodeExtension': lazy('ExtensionMeta.addNodeExtension'),
+  'ExtensionMeta.addWebExtension': lazy('ExtensionMeta.addWebExtension'),
+  'Extensions.openCachedExtensionsFolder': lazy('Extensions.openCachedExtensionsFolder'),
+  'Extensions.openExtensionsFolder': lazy('Extensions.openExtensionsFolder'),
+  'FilePicker.mockSaveFilePicker': lazy('FilePicker.mockSaveFilePicker'),
+  'FilePicker.showDirectoryPicker': lazy('FilePicker.showDirectoryPicker'),
+  'FilePicker.showFilePicker': lazy('FilePicker.showFilePicker'),
+  'FilePicker.showSaveFilePicker': lazy('FilePicker.showSaveFilePicker'),
+  'FileSystem.chmod': lazy('FileSystem.chmod'),
+  'FileSystem.copy': lazy('FileSystem.copy'),
+  'FileSystem.exists': lazy('FileSystem.exists'),
+  'FileSystem.getBlob': lazy('FileSystem.getBlob'),
+  'FileSystem.getFolderSize': lazy('FileSystem.getFolderSize'),
+  'FileSystem.getPathSeparator': lazy('FileSystem.getPathSeparator'),
+  'FileSystem.getRealPath': lazy('FileSystem.getRealPath'),
+  'FileSystem.mkdir': lazy('FileSystem.mkdir'),
+  'FileSystem.readDirWithFileTypes': lazy('FileSystem.readDirWithFileTypes'),
+  'FileSystem.readFile': lazy('FileSystem.readFile'),
+  'FileSystem.readJson': lazy('FileSystem.readJson'),
+  'FileSystem.remove': lazy('FileSystem.remove'),
+  'FileSystem.rename': lazy('FileSystem.rename'),
+  'FileSystem.stat': lazy('FileSystem.stat'),
+  'FileSystem.writeBlob': lazy('FileSystem.writeBlob'),
+  'FileSystem.writeFile': lazy('FileSystem.writeFile'),
+  'FileSystemHandle.addFileHandle': lazy('FileSystemHandle.addFileHandle'),
+  'FileSystemHandle.getFileHandles': lazy('FileSystemHandle.getFileHandles'),
+  'FileSystemHandle.getFilePathElectron': lazy('FileSystemHandle.getFilePathElectron'),
+  'FileWatcher.handleEvent': lazy('FileWatcher.handleEvent'),
+  'FileWatcher.watchFile': lazy('FileWatcher.watchFile'),
+  'Focus.removeAdditionalFocus': lazy('Focus.removeAdditionalFocus'),
+  'Focus.setAdditionalFocus': lazy('Focus.setAdditionalFocus'),
+  'Focus.setFocus': lazy('Focus.setFocus'),
+  'GetActiveEditor.getActiveEditorId': lazy('GetActiveEditor.getActiveEditorId'),
+  'GetEditorSourceActions.getEditorSourceActions': lazy('GetEditorSourceActions.getEditorSourceActions'),
+  'GetWindowId.getWindowId': lazy('GetWindowId.getWindowId'),
+  'IconTheme.getFileIcon': lazy('IconTheme.getFileIcon'),
+  'IconTheme.getFileIcons': lazy('IconTheme.getFileIcons'),
+  'IconTheme.getFolderIcon': lazy('IconTheme.getFolderIcon'),
+  'IconTheme.getIcon': lazy('IconTheme.getIcon'),
+  'IconTheme.getIcons': lazy('IconTheme.getIcons'),
+  'IconTheme.hydrate': lazy('IconTheme.hydrate'),
+  'IconTheme.setIconTheme': lazy('IconTheme.setIconTheme'),
+  'ImagePreview.hide': lazy('ImagePreview.hide'),
+  'ImagePreview.show': lazy('ImagePreview.show'),
+  'IndexedDb.addHandle': lazy('IndexedDb.addHandle'),
+  'IndexedDb.getHandle': lazy('IndexedDb.getHandle'),
+  'IpcParent.create': lazy('IpcParent.create'),
+  'KeyBindings.handleKeyBinding': lazy('KeyBindings.handleKeyBinding'),
+  'KeyBindings.hydrate': lazy('KeyBindings.hydrate'),
+  'KeyBindings.setIdentifiers': lazy('KeyBindings.setIdentifiers'),
+  'KeyBindingsInitial.getKeyBindings': lazy('KeyBindingsInitial.getKeyBindings'),
+  'Languages.getLanguageConfiguration': lazy('Languages.getLanguageConfiguration'),
+  'Listener.3444': lazy('Listener.3444'),
+  'LocalStorage.clear': lazy('LocalStorage.clear'),
+  'LocalStorage.getJson': lazy('LocalStorage.getJson'),
+  'LocalStorage.getText': lazy('LocalStorage.getText'),
+  'LocalStorage.setJson': lazy('LocalStorage.setJson'),
+  'LocalStorage.setText': lazy('LocalStorage.setText'),
+  'Main.focus': lazy('Main.focus'),
+  'Main.handleClickClose': lazy('Main.handleClickClose'),
+  'Main.handleDragEnd': lazy('Main.handleDragEnd'),
+  'Main.handleDragLeave': lazy('Main.handleDragLeave'),
+  'Main.handleDragOver': lazy('Main.handleDragOver'),
+  'Main.handleTabContextMenu': lazy('Main.handleTabContextMenu'),
+  'Main.openBackgroundTab': lazy('Main.openBackgroundTab'),
+  'Main.openKeyBindings': lazy('Main.openKeyBindings'),
+  'Main.reopenEditorWith': lazy('Main.reopenEditorWith'),
+  'Main.save': lazy('Main.save'),
+  'Markdown.getVirtualDom': lazy('Markdown.getVirtualDom'),
+  'Markdown.renderMarkdown': lazy('Markdown.renderMarkdown'),
+  'MeasureTextHeight.measureTextBlockHeight': lazy('MeasureTextHeight.measureTextBlockHeight'),
+  'MeasureTextHeight.measureTextHeight': lazy('MeasureTextHeight.measureTextHeight'),
+  'Menu.focusFirst': lazy('Menu.focusFirst'),
+  'Menu.focusIndex': lazy('Menu.focusIndex'),
+  'Menu.focusLast': lazy('Menu.focusLast'),
+  'Menu.focusNext': lazy('Menu.focusNext'),
+  'Menu.focusPrevious': lazy('Menu.focusPrevious'),
+  'Menu.handleMouseEnter': lazy('Menu.handleMouseEnter'),
+  'Menu.handleMouseLeave': lazy('Menu.handleMouseLeave'),
+  'Menu.hide': lazy('Menu.hide'),
+  'Menu.selectIndex': lazy('Menu.selectIndex'),
+  'Menu.selectItem': lazy('Menu.selectItem'),
+  'Menu.show': lazy('Menu.show'),
+  'Mime.getMediaMimeType': lazy('Mime.getMediaMimeType'),
+  'Mime.getTextMime': lazy('Mime.getTextMime'),
+  'MouseActions.add': lazy('MouseActions.add'),
+  'MouseActions.get': lazy('MouseActions.get'),
+  'NativeHost.handleMaximized': lazy('NativeHost.handleMaximized'),
+  'NativeHost.handleMinimized': lazy('NativeHost.handleMinimized'),
+  'NativeHost.handleUnmaximized': lazy('NativeHost.handleUnmaximized'),
+  'Navigation.focusActivityBar': lazy('Navigation.focusActivityBar'),
+  'Navigation.focusMain': lazy('Navigation.focusMain'),
+  'Navigation.focusNextPart': lazy('Navigation.focusNextPart'),
+  'Navigation.focusPanel': lazy('Navigation.focusPanel'),
+  'Navigation.focusPreviousPart': lazy('Navigation.focusPreviousPart'),
+  'Navigation.focusSideBar': lazy('Navigation.focusSideBar'),
+  'Navigation.focusStatusBar': lazy('Navigation.focusStatusBar'),
+  'Navigation.focusTitleBar': lazy('Navigation.focusTitleBar'),
+  'Notification.create': lazy('Notification.create'),
+  'Notification.dispose': lazy('Notification.dispose'),
+  'Notification.handleClick': lazy('Notification.handleClick'),
+  'Notification.showWithOptions': lazy('Notification.showWithOptions'),
+  'OffscreenCanvas.create': lazy('OffscreenCanvas.create'),
+  'OffscreenCanvas.createForTerminal': lazy('OffscreenCanvas.createForTerminal'),
+  'Open.openExternal': lazy('Open.openExternal'),
+  'Open.openUrl': lazy('Open.openUrl'),
+  'OpenNativeFolder.openNativeFolder': lazy('OpenNativeFolder.openNativeFolder'),
+  'Panel.handleClickAction': lazy('Panel.handleClickAction'),
+  'Panel.handleFilterInput': lazy('Panel.handleFilterInput'),
+  'Panel.hidePanel': lazy('Panel.hidePanel'),
+  'Panel.selectIndex': lazy('Panel.selectIndex'),
+  'Panel.selectView': lazy('Panel.selectView'),
+  'Panel.toggleView': lazy('Panel.toggleView'),
+  'PersistentFileHandle.addHandle': lazy('PersistentFileHandle.addHandle'),
+  'PersistentFileHandle.getHandle': lazy('PersistentFileHandle.getHandle'),
+  'PersistentFileHandle.removeHandle': lazy('PersistentFileHandle.removeHandle'),
+  'PlatformPaths.getCachePath': lazy('PlatformPaths.getCachePath'),
+  'PlatformPaths.getCacheUri': lazy('PlatformPaths.getCacheUri'),
+  'PlatformPaths.getDisabledExtensionsJsonPath': lazy('PlatformPaths.getDisabledExtensionsJsonPath'),
+  'PlatformPaths.getLogsDir': lazy('PlatformPaths.getLogsDir'),
+  'PlatformPaths.getTmpDir': lazy('PlatformPaths.getTmpDir'),
+  'PointerCapture.mock': lazy('PointerCapture.mock'),
+  'PointerCapture.unmock': lazy('PointerCapture.unmock'),
+  'Preferences.get': lazy('Preferences.get'),
+  'Preferences.getAll': lazy('Preferences.getAll'),
+  'Preferences.getMany': lazy('Preferences.getMany'),
+  'Preferences.hydrate': lazy('Preferences.hydrate'),
+  'Preferences.openKeyBindingsJson': lazy('Preferences.openKeyBindingsJson'),
+  'Preferences.openSettingsJson': lazy('Preferences.openSettingsJson'),
+  'Preferences.openSettingsUi': lazy('Preferences.openSettingsUi'),
+  'Preferences.update': lazy('Preferences.update'),
+  'Process.getArch': lazy('Process.getArch'),
+  'Process.getChromeVersion': lazy('Process.getChromeVersion'),
+  'Process.getElectronVersion': lazy('Process.getElectronVersion'),
+  'Process.getNodeVersion': lazy('Process.getNodeVersion'),
+  'Process.getV8Version': lazy('Process.getV8Version'),
+  'Prompt.prompt': lazy('Prompt.prompt'),
+  'QuickPick.executeCallback': lazy('QuickPick.executeCallback'),
+  'QuickPick.show': lazy('QuickPick.show'),
+  'QuickPick.showColorTheme': lazy('QuickPick.showColorTheme'),
+  'QuickPick.showCommands': lazy('QuickPick.showCommands'),
+  'QuickPick.showCustom': lazy('QuickPick.showCustom'),
+  'QuickPick.showEverything': lazy('QuickPick.showEverything'),
+  'QuickPick.showFile': lazy('QuickPick.showFile'),
+  'QuickPick.showRecent': lazy('QuickPick.showRecent'),
+  'RebuildNodePty.rebuildNodePty': lazy('RebuildNodePty.rebuildNodePty'),
+  'RecentlyOpened.addToRecentlyOpened': lazy('RecentlyOpened.addToRecentlyOpened'),
+  'RecentlyOpened.clearRecentlyOpened': lazy('RecentlyOpened.clearRecentlyOpened'),
+  'RecentlyOpened.getRecentlyOpened': lazy('RecentlyOpened.getRecentlyOpened'),
+  'RecentlyOpened.hydrate': lazy('RecentlyOpened.hydrate'),
+  'Reload.reload': lazy('Reload.reload'),
+  'SaveFileAs.saveFileAs': lazy('SaveFileAs.saveFileAs'),
+  'SaveState.handleVisibilityChange': lazy('SaveState.handleVisibilityChange'),
+  'SaveState.hydrate': lazy('SaveState.hydrate'),
+  'SearchProcess.invoke': lazy('SearchProcess.invoke'),
+  'SendMessagePortToElectron.sendMessagePortToElectron': lazy('SendMessagePortToElectron.sendMessagePortToElectron'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker'),
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker': lazy('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker'),
+  'SendMessagePortToRendererProcess.sendMessagePortToRendererProcess': lazy('SendMessagePortToRendererProcess.sendMessagePortToRendererProcess'),
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker': lazy('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker'),
+  'SessionReplay.downloadSession': lazy('SessionReplay.downloadSession'),
+  'SessionReplay.openSession': lazy('SessionReplay.openSession'),
+  'SessionReplay.replayCurrentSession': lazy('SessionReplay.replayCurrentSession'),
+  'SessionReplay.replaySession': lazy('SessionReplay.replaySession'),
+  'SessionStorage.clear': lazy('SessionStorage.clear'),
+  'SessionStorage.getJson': lazy('SessionStorage.getJson'),
+  'SideBar.focus': lazy('SideBar.focus'),
+  'SideBar.handleClickAction': lazy('SideBar.handleClickAction'),
+  'SideBar.handleUpdateStateChange': lazy('SideBar.handleUpdateStateChange'),
+  'SideBar.open': lazy('SideBar.open'),
+  'SideBar.openViewlet': lazy('SideBar.openViewlet'),
+  'SideBar.show': lazy('SideBar.show'),
+  'SimpleBrowser.getDomTree': lazy('SimpleBrowser.getDomTree'),
+  'SimpleBrowser.go': lazy('SimpleBrowser.go'),
+  'SimpleBrowser.handleDidNavigate': lazy('SimpleBrowser.handleDidNavigate'),
+  'SimpleBrowser.handleDidNavigationCancel': lazy('SimpleBrowser.handleDidNavigationCancel'),
+  'SimpleBrowser.handleInput': lazy('SimpleBrowser.handleInput'),
+  'SimpleBrowser.handleKeyBinding': lazy('SimpleBrowser.handleKeyBinding'),
+  'SimpleBrowser.handleTitleUpdated': lazy('SimpleBrowser.handleTitleUpdated'),
+  'SimpleBrowser.handleWillNavigate': lazy('SimpleBrowser.handleWillNavigate'),
+  'SimpleBrowser.insertCss': lazy('SimpleBrowser.insertCss'),
+  'SimpleBrowser.insertJavaScript': lazy('SimpleBrowser.insertJavaScript'),
+  'SimpleBrowser.setUrl': lazy('SimpleBrowser.setUrl'),
+  'Terminal.clear': lazy('Terminal.clear'),
+  'Terminal.handleBlur': lazy('Terminal.handleBlur'),
+  'Terminal.handleKeyDown': lazy('Terminal.handleKeyDown'),
+  'Terminal.handleMouseDown': lazy('Terminal.handleMouseDown'),
+  'Terminals.addTerminal': lazy('Terminals.addTerminal'),
+  'Terminals.handleClickTab': lazy('Terminals.handleClickTab'),
+  'Test.execute': lazy('Test.execute'),
+  'TestFrameWork.checkConditionError': lazy('TestFrameWork.checkConditionError'),
+  'TestFrameWork.checkMultiElementCondition': lazy('TestFrameWork.checkMultiElementCondition'),
+  'TestFrameWork.checkSingleElementCondition': lazy('TestFrameWork.checkSingleElementCondition'),
+  'TestFrameWork.performAction': lazy('TestFrameWork.performAction'),
+  'TestFrameWork.showOverlay': lazy('TestFrameWork.showOverlay'),
+  'Timeout.sleep': lazy('Timeout.sleep'),
+  'Transferrable.acquire': lazy('Transferrable.acquire'),
+  'Transferrable.transfer': lazy('Transferrable.transfer'),
+  'Transferrable.transferToRendererProcess': lazy('Transferrable.transferToRendererProcess'),
+  'Url.createObjectUrl': lazy('Url.createObjectUrl'),
+  'Url.revokeObjectUrl': lazy('Url.revokeObjectUrl'),
+  'Viewlet.2133': lazy('Viewlet.2133'),
+  'Viewlet.closeWidget': lazy('Viewlet.closeWidget'),
+  'Viewlet.dispose': lazy('Viewlet.dispose'),
+  'Viewlet.executeViewletCommand': lazy('Viewlet.executeViewletCommand'),
+  'Viewlet.focus': lazy('Viewlet.focus'),
+  'Viewlet.getAllStates': lazy('Viewlet.getAllStates'),
+  'Viewlet.openWidget': lazy('Viewlet.openWidget'),
+  'Viewlet.send': lazy('Viewlet.send'),
+  'ViewletDebugConsole.clear': lazy('ViewletDebugConsole.clear'),
+  'ViewletDebugConsole.evaluate': lazy('ViewletDebugConsole.evaluate'),
+  'ViewletDebugConsole.handleFocus': lazy('ViewletDebugConsole.handleFocus'),
+  'ViewletDebugConsole.handleInput': lazy('ViewletDebugConsole.handleInput'),
+  'ViewletDefineKeyBinding.handleBlur': lazy('ViewletDefineKeyBinding.handleBlur'),
+  'ViewletDefineKeyBinding.handleKeyDown': lazy('ViewletDefineKeyBinding.handleKeyDown'),
+  'ViewletE2eTest.handleClickAt': lazy('ViewletE2eTest.handleClickAt'),
+  'ViewletE2eTest.handleSashCornerPointerDown': lazy('ViewletE2eTest.handleSashCornerPointerDown'),
+  'ViewletE2eTest.handleSashCornerPointerMove': lazy('ViewletE2eTest.handleSashCornerPointerMove'),
+  'ViewletE2eTest.handleSashCornerPointerUp': lazy('ViewletE2eTest.handleSashCornerPointerUp'),
+  'ViewletE2eTests.handleClickAt': lazy('ViewletE2eTests.handleClickAt'),
+  'ViewletE2eTests.handleContextMenu': lazy('ViewletE2eTests.handleContextMenu'),
+  'ViewletE2eTests.handleLoad': lazy('ViewletE2eTests.handleLoad'),
+  'ViewletE2eTests.openInNewTab': lazy('ViewletE2eTests.openInNewTab'),
+  'ViewletE2eTests.runAll': lazy('ViewletE2eTests.runAll'),
+  'ViewletLayout.getActiveSideBarView': lazy('ViewletLayout.getActiveSideBarView'),
+  'ViewletLayout.getAllQuickPickMenuEntries': lazy('ViewletLayout.getAllQuickPickMenuEntries'),
+  'ViewletLayout.getAssetDir': lazy('ViewletLayout.getAssetDir'),
+  'ViewletLayout.getBadgeCounts': lazy('ViewletLayout.getBadgeCounts'),
+  'ViewletLayout.getCommit': lazy('ViewletLayout.getCommit'),
+  'ViewletLayout.getPlatform': lazy('ViewletLayout.getPlatform'),
+  'ViewletQuickPickElectron.handleBeforeInput': lazy('ViewletQuickPickElectron.handleBeforeInput'),
+  'ViewletQuickPickElectron.handleBlur': lazy('ViewletQuickPickElectron.handleBlur'),
+  'ViewletQuickPickElectron.handleClickAt': lazy('ViewletQuickPickElectron.handleClickAt'),
+  'ViewletQuickPickElectron.handleInput': lazy('ViewletQuickPickElectron.handleInput'),
+  'ViewletQuickPickElectron.handleWheel': lazy('ViewletQuickPickElectron.handleWheel'),
+  'ViewletQuickPickElectron.selectCurrentIndex': lazy('ViewletQuickPickElectron.selectCurrentIndex'),
+  'ViewletQuickPickElectron.selectIndex': lazy('ViewletQuickPickElectron.selectIndex'),
+  'ViewletQuickPickElectron.selectItem': lazy('ViewletQuickPickElectron.selectItem'),
+  'WebView.compatExtensionHostWorkerInvoke': lazy('WebView.compatExtensionHostWorkerInvoke'),
+  'WebView.compatExtensionHostWorkerInvokeAndTransfer': lazy('WebView.compatExtensionHostWorkerInvokeAndTransfer'),
+  'WebView.compatRendererProcessInvoke': lazy('WebView.compatRendererProcessInvoke'),
+  'WebView.compatRendererProcessInvokeAndTransfer': lazy('WebView.compatRendererProcessInvokeAndTransfer'),
+  'WebView.compatSharedProcessInvoke': lazy('WebView.compatSharedProcessInvoke'),
+  'WebView.getSavedState': lazy('WebView.getSavedState'),
+  'WebView.getSecret': lazy('WebView.getSecret'),
+  'WebView.getWebViewInfo': lazy('WebView.getWebViewInfo'),
+  'WebView.getWebViewInfo2': lazy('WebView.getWebViewInfo2'),
+  'WebView.getWebViews': lazy('WebView.getWebViews'),
+  'WebView.registerInterceptor': lazy('WebView.registerInterceptor'),
+  'WebView.setPort': lazy('WebView.setPort'),
+  'WebView.unregisterInterceptor': lazy('WebView.unregisterInterceptor'),
+  'Window.close': lazy('Window.close'),
+  'Window.exit': lazy('Window.exit'),
+  'Window.maximize': lazy('Window.maximize'),
+  'Window.minimize': lazy('Window.minimize'),
+  'Window.openNew': lazy('Window.openNew'),
+  'Window.unmaximize': lazy('Window.unmaximize'),
+  'Window.zoomIn': lazy('Window.zoomIn'),
+  'Window.zoomOut': lazy('Window.zoomOut'),
+  'Window.zoomReset': lazy('Window.zoomReset'),
+  'WindowTitle.set': lazy('WindowTitle.set'),
+  'Workspace.close': lazy('Workspace.close'),
+  'Workspace.getPath': lazy('Workspace.getPath'),
+  'Workspace.getUri': lazy('Workspace.getUri'),
+  'Workspace.hydrate': lazy('Workspace.hydrate'),
+  'Workspace.setPath': lazy('Workspace.setPath'),
+  'Workspace.setUri': lazy('Workspace.setUri')
+};
+
 const main = async () => {
+  Object.assign(commandMapRef, commandMap);
   await startup(getPlatform$1(), assetDir);
 };
 main();
@@ -5912,7 +6769,7 @@ const getPort = async ipcId => {
     port2
   } = getPortTuple();
   // TODO call sendMessagePortToElectron function
-  const webContentsId = await invokeAndTransfer$d('IpcParent.create', {
+  const webContentsId = await invokeAndTransfer$e('IpcParent.create', {
     method: Electron,
     port: port1,
     ipcId
@@ -7369,7 +8226,7 @@ const launchFileSystemWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.fileSystemWorkerPath', fileSystemWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Initialize.initialize', getPlatform$1());
+  await invoke$w(ipc, 'Initialize.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -7678,7 +8535,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$w('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$x('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -7912,7 +8769,7 @@ const launchDebugWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.debugWorkerPath', debugWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Initialize.initialize');
+  await invoke$w(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -8121,7 +8978,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$w(/* Audio.play */3211, /* src */src);
+  await invoke$x(/* Audio.play */3211, /* src */src);
 };
 
 const name$2a = 'Audio';
@@ -8188,7 +9045,7 @@ const GetActiveEditor_ipc = {
 };
 
 const getSelectionText = () => {
-  return invoke$w('Css.getSelectionText');
+  return invoke$x('Css.getSelectionText');
 };
 
 const name$27 = 'Document';
@@ -8282,14 +9139,14 @@ const PlatformPaths_ipc = {
 };
 
 const getFileHandles = ids => {
-  return invoke$w('FileHandles.get', ids);
+  return invoke$x('FileHandles.get', ids);
 };
 const addFileHandle = fileHandle => {
-  return invoke$w('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$x('FileSystemHandle.addFileHandle', fileHandle);
 };
 
 const getFilePathElectron = async file => {
-  return invoke$w('GetFilePathElectron.getFilePathElectron', file);
+  return invoke$x('GetFilePathElectron.getFilePathElectron', file);
 };
 
 const name$23 = 'FileSystemHandle';
@@ -8355,7 +9212,7 @@ const getNewContent = (oldContent, changes) => {
       endColumnIndex
     } = changes[i];
     while (rowIndex < startRowIndex) {
-      newLineIndex = getNewLineIndex$1(oldContent, newLineIndex + 1);
+      newLineIndex = getNewLineIndex$2(oldContent, newLineIndex + 1);
       rowIndex++;
     }
     if (copiedContentIndex <= newLineIndex) {
@@ -8475,7 +9332,7 @@ const setResponse = async (key, value, contentType) => {
   }
   const cacheName = getCacheName();
   const cache = await caches.open(cacheName);
-  await cache.put(key, create$11(value, {
+  await cache.put(key, create$12(value, {
     headers: new Headers({
       'Content-Type': contentType,
       'Content-Length': `${value.length}`
@@ -8631,7 +9488,7 @@ const launchClipBoardWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.clipBoardWorkerPath', clipBoardWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'ClipBoard.initialize', getPlatform$1());
+  await invoke$w(ipc, 'ClipBoard.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -8664,14 +9521,14 @@ const readNativeFiles = async () => {
 };
 const writeImage = async blob => {
   try {
-    return await invoke$w('ClipBoard.writeImage', blob);
+    return await invoke$x('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$w('ClipBoard.execCopy');
+    return await invoke$x('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
@@ -8761,7 +9618,7 @@ const promptError = async (message, confirmMessage, title) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$w('ConfirmPrompt.prompt', message);
+  const result = await invoke$x('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -8801,7 +9658,7 @@ const ok = () => {
 let _mockId$1 = 0;
 const showMockConfirmPrompt = async (message, options) => {
   const ipc = get$d();
-  const result = await invoke$x(ipc, 'Test.executeMock', _mockId$1, message, options);
+  const result = await invoke$w(ipc, 'Test.executeMock', _mockId$1, message, options);
   return result;
 };
 const mock$1 = mockId => {
@@ -9148,7 +10005,7 @@ const formatStartupPerformanceEntries = (entries, firstTimeOrigin) => {
 };
 
 const joinLines = lines => {
-  return lines.join(NewLine$1);
+  return lines.join(NewLine$2);
 };
 
 const formatNodeTiming = nodeStartupTiming => {
@@ -9401,10 +10258,10 @@ const getSharedProcessMemoryUsage = () => {
   return invoke$u(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$w('Performance.getMemory');
+  return invoke$x('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$w('Performance.measureUserAgentSpecificMemory');
+  return invoke$x('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -9647,7 +10504,7 @@ const revokeObjectUrl = url => {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$w(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$x(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
@@ -9746,7 +10603,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$w(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$x(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$1R = {
@@ -9971,7 +10828,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$w('FilePicker.showDirectoryPicker', options);
+    return await invoke$x('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -9982,11 +10839,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$w('FilePicker.showFilePicker', options);
+  return invoke$x('FilePicker.showFilePicker', options);
 };
 const doShowSaveFilePicker = async options => {
   try {
-    return await invoke$w('FilePicker.showSaveFilePicker', options);
+    return await invoke$x('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -9999,7 +10856,7 @@ const doShowSaveFilePicker = async options => {
 let _mockId = 0;
 const doShowMockSaveFilePicker = async () => {
   const ipc = get$d();
-  const result = await invoke$x(ipc, 'Test.executeMock', _mockId);
+  const result = await invoke$w(ipc, 'Test.executeMock', _mockId);
   return result;
 };
 const showSaveFilePicker = async options => {
@@ -10090,15 +10947,15 @@ const show$8 = async (uri, top, left) => {
     if (version !== state$a.versionId) {
       return;
     }
-    await invoke$w(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$x(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$w(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$x(/* 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$w(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$x(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -10598,22 +11455,22 @@ const state$8 = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$w(/* ActivityBar.focus */717115);
+  await invoke$x(/* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$w(/* StatusBar.focus */8882);
+  await invoke$x(/* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$w(/* Panel.focus */6664);
+  await invoke$x(/* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$w(/* SideBar.focus */5554);
+  await invoke$x(/* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$w(/* TitleBar.focus */1331);
+  await invoke$x(/* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$w(/* Main.focus */2145);
+  await invoke$x(/* Main.focus */2145);
 };
 const focusPart = part => {
   state$8.focusedPart = part;
@@ -10724,7 +11581,7 @@ const create$P = async (type, text) => {
     type,
     text
   });
-  await invoke$w(/* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$x(/* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -10733,7 +11590,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$w(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$x(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$1 = index => {
   console.log('handle click');
@@ -10749,7 +11606,7 @@ const handleClick$1 = index => {
   });
 };
 const dispose$q = async id => {
-  await invoke$w(/* Notification.dispose */'Notification.dispose', /* id */id);
+  await invoke$x(/* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$1r = 'Notification';
@@ -10768,7 +11625,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async url => {
   try {
-    await invoke$w(/* Open.openUrl */'Open.openUrl', /* url */url);
+    await invoke$x(/* Open.openUrl */'Open.openUrl', /* url */url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -10845,7 +11702,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$w('Prompt.prompt', message, defaultValue);
+  return invoke$x('Prompt.prompt', message, defaultValue);
 };
 
 const name$1m = 'Prompt';
@@ -10996,19 +11853,19 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$w('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$x('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$w('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$x('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$w('TestFrameWork.showOverlay', ...args);
+  return invoke$x('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$w('TestFrameWork.performAction', ...args);
+  return invoke$x('TestFrameWork.performAction', ...args);
 };
 const checkConditionError = (...args) => {
-  return invoke$w('TestFrameWork.checkConditionError', ...args);
+  return invoke$x('TestFrameWork.checkConditionError', ...args);
 };
 
 const name$1d = 'TestFrameWork';
@@ -11103,10 +11960,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$w('PointerCapture.mock');
+  return invoke$x('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$w('PointerCapture.unmock');
+  return invoke$x('PointerCapture.unmock');
 };
 
 const name$17 = 'PointerCapture';
@@ -11297,7 +12154,7 @@ const {
 const create$O = async canvasId => {
   number(canvasId);
   const id = create$$();
-  await invoke$w('OffscreenCanvas.create', canvasId, id);
+  await invoke$x('OffscreenCanvas.create', canvasId, id);
   const canvas = acquire(id);
   return canvas;
 };
@@ -11586,7 +12443,7 @@ const ExtensionHostClosingTagCompletion_ipc = {
 const sendMessagePortToRendererProcess$1 = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$d(initialCommand, port);
+  await invokeAndTransfer$e(initialCommand, port);
 };
 
 const name$R = 'SendMessagePortToRendererProcess';
@@ -11647,7 +12504,7 @@ const launchEditorWorker = async () => {
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
-  await invoke$x(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  await invoke$w(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
@@ -11685,7 +12542,7 @@ const launchIframeWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.iframeWorkerPath', iframeWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Iframes.initialize', getPlatform$1());
+  await invoke$w(ipc, 'Iframes.initialize', getPlatform$1());
   return ipc;
 };
 
@@ -11703,7 +12560,7 @@ const launchSourceControlWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.sourceControlWorkerPath', sourceControlWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Initialize.initialize');
+  await invoke$w(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -11753,7 +12610,7 @@ const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$d(initialCommand, port, rpcId);
+  await invokeAndTransfer$e(initialCommand, port, rpcId);
 };
 const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -11915,7 +12772,7 @@ const isGitpod = getHost().endsWith('.gitpod.io');
 const WebView = 'lvce-oss-webview';
 
 const setPort = async (uid, port, origin, portType) => {
-  await invokeAndTransfer$d('WebView.setPort', uid, port, origin, portType);
+  await invokeAndTransfer$e('WebView.setPort', uid, port, origin, portType);
 };
 
 /**
@@ -11952,10 +12809,10 @@ const compat = {
     return invoke$u(...args);
   },
   rendererProcessInvoke(...args) {
-    return invoke$w(...args);
+    return invoke$x(...args);
   },
   rendererProcessInvokeAndTransfer(...args) {
-    return invokeAndTransfer$d(...args);
+    return invokeAndTransfer$e(...args);
   },
   extensionHostWorkerInvokeAndTransfer(...args) {
     return invokeAndTransfer$9(...args);
@@ -12020,7 +12877,7 @@ const getOrCreate$1 = () => {
 };
 const invoke$f = async (method, ...params) => {
   const ipc = await getOrCreate$1();
-  return invoke$x(ipc, method, ...params);
+  return invoke$w(ipc, method, ...params);
 };
 
 const name$K = 'SearchProcess';
@@ -12218,10 +13075,10 @@ const Markdown_ipc = {
 };
 
 const measureTextHeight = (text, fontFamily, fontSize) => {
-  return invoke$w('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
+  return invoke$x('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
 };
 const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke$w('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+  return invoke$x('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
 };
 
 const name$D = 'MeasureTextHeight';
@@ -12971,7 +13828,7 @@ const create$J = (id, uri, x, y, width, height) => {
 };
 const loadContent$E = state => {
   const update = async () => {
-    await invoke$w(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$x(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -15401,7 +16258,7 @@ const Commands$s = {
   ...wrapEditorCommands(ids),
   // TODO
   async showOverlayMessage(state, editor, ...args) {
-    await invoke$w(...args);
+    await invoke$x(...args);
     return state;
   },
   async hotReload(state, editor, ...args) {
@@ -15678,7 +16535,7 @@ const launchExplorerWorker = async () => {
     name: 'Explorer Worker'
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Explorer.initialize');
+  await invoke$w(ipc, 'Explorer.initialize');
   return ipc;
 };
 
@@ -15928,7 +16785,7 @@ const launchExtensionDetailViewWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.extensionDetailViewWorkerPath', extensionDetailViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'ExtensionDetail.initialize');
+  await invoke$w(ipc, 'ExtensionDetail.initialize');
   return ipc;
 };
 
@@ -16100,7 +16957,7 @@ const launchExtensionSearchViewWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$x(ipc, 'SearchExtensions.initialize');
+    await invoke$w(ipc, 'SearchExtensions.initialize');
   } catch {
     // ignore
   }
@@ -16477,7 +17334,7 @@ const launchReferencesWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.referencesWorkerPath', referencesWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'References.initialize');
+  await invoke$w(ipc, 'References.initialize');
   return ipc;
 };
 
@@ -17263,7 +18120,7 @@ const Preview$1 = {
   kReady: 'previewVisible'
 };
 
-const commit = '7177c9a';
+const commit = 'bc489d4';
 
 // TODO instead of reordering commands, have two command arrays
 // one for normal commands
@@ -18048,7 +18905,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$w('Viewlet.sendMultiple', commands);
+    await invoke$x('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -20234,7 +21091,7 @@ const loadContent$k = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$w('Viewlet.loadModule', MainTabs);
+  await invoke$x('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -20323,7 +21180,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$w(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$x(/* 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;
@@ -20348,7 +21205,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
     title,
     ...props
   });
-  await invoke$w('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$x('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state;
 };
@@ -21316,7 +22173,7 @@ const create$j = (id, uri, x, y, width, height) => {
 };
 const loadContent$j = state => {
   const update = async () => {
-    await invoke$w(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$x(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -21380,7 +22237,7 @@ const launchOutputViewWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.outputViewWorkerPath', outputViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Output.initialize');
+  await invoke$w(ipc, 'Output.initialize');
   return ipc;
 };
 
@@ -21664,7 +22521,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     const currentViewletUid = currentViewletState.uid;
     number(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    await invoke$w('Viewlet.sendMultiple', commands);
+    await invoke$x('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$4)) {
       state.currentViewletId = Error$4;
     }
@@ -21826,7 +22683,7 @@ const launchProblemsWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.problemsWorkerPath', problemsViewWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Problems.initialize');
+  await invoke$w(ipc, 'Problems.initialize');
   return ipc;
 };
 
@@ -22579,11 +23436,11 @@ const getSources = async options => {
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$w('ScreenCapture.start', captureId, options);
+  await invoke$x('ScreenCapture.start', captureId, options);
 };
 const dispose$8 = async captureId => {
   number(captureId);
-  await invoke$w('ScreenCapture.dispose', captureId);
+  await invoke$x('ScreenCapture.dispose', captureId);
 };
 
 const createScreenCaptureStream = async captureId => {
@@ -22672,7 +23529,7 @@ const launchTextSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$x(ipc, 'TextSearch.initialize', getPlatform$1());
+    await invoke$w(ipc, 'TextSearch.initialize', getPlatform$1());
   } catch (error) {
     // ignore
   }
@@ -22873,7 +23730,7 @@ const launchSettingsWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.settingsWorkerPath', settingsWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Initialize.initialize');
+  await invoke$w(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -23163,7 +24020,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
       activityBar.state = newState;
       commands.push(...extraCommands);
     }
-    await invoke$w('Viewlet.sendMultiple', commands);
+    await invoke$x('Viewlet.sendMultiple', commands);
   }
 
   // // TODO race condition (check if disposed after created)
@@ -23316,7 +24173,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'Initialize.initialize');
+  await invoke$w(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -24403,7 +25260,7 @@ const launchStatusBarWorker = async () => {
     url: getConfiguredWorkerUrl$1('develop.statusBarWorkerPath', statusBarWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$x(ipc, 'StatusBar.initialize');
+  await invoke$w(ipc, 'StatusBar.initialize');
   return ipc;
 };
 
@@ -24752,7 +25609,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$w(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$x(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 /**
@@ -24918,7 +25775,7 @@ const addTerminal = async state => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$w('Viewlet.sendMultiple', commands);
+  await invoke$x('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -24959,7 +25816,7 @@ const focusIndex = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$w('Viewlet.sendMultiple', commands);
+  await invoke$x('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index
@@ -25288,7 +26145,7 @@ const resize = (state, dimensions) => {
   };
 };
 const dispose = async state => {
-  await invoke$w('WebView.dispose', state.uid);
+  await invoke$x('WebView.dispose', state.uid);
   return state;
 };