@lvce-editor/static-server 0.103.21 → 0.103.22

package/static/{4973751 → 5af6a2b}/packages/test-worker/dist/testWorkerMain.js

@@ -945,7 +945,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const createRpc = ipc => {
+const createRpc$1 = ipc => {
   const callbacks = Object.create(null);
   ipc._resolve = (id, response) => {
     const fn = callbacks[id];
@@ -1025,7 +1025,7 @@ const create$5 = async ({
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   messagePort.start();
   return rpc;
 };
@@ -1102,7 +1102,7 @@ const create$2 = async ({
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   return rpc;
 };
 
@@ -1113,7 +1113,7 @@ const create$1 = async ({
   register(commandMap);
   const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
   handleIpc(ipc);
-  const rpc = createRpc(ipc);
+  const rpc = createRpc$1(ipc);
   return rpc;
 };
 
@@ -1137,15 +1137,15 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
-  rpcs[id] = rpc;
+const rpcs$1 = Object.create(null);
+const set$8 = (id, rpc) => {
+  rpcs$1[id] = rpc;
 };
 const get$2 = id => {
-  return rpcs[id];
+  return rpcs$1[id];
 };
 const remove$1 = id => {
-  delete rpcs[id];
+  delete rpcs$1[id];
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
@@ -1171,7 +1171,7 @@ const create = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$7(rpcId, mockRpc);
+      set$8(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1180,7 +1180,7 @@ const create = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$7(rpcId, rpc);
+      set$8(rpcId, rpc);
     }
   };
 };
@@ -1202,27 +1202,34 @@ const RendererWorker = 1;
 const TestWorker = 9001;
 
 const {
-  invoke: invoke$5,
-  set: set$6
+  invoke: invoke$8,
+  set: set$7
 } = create(EditorWorker);
 
 const {
-  invoke: invoke$4,
-  set: set$5
+  invoke: invoke$7,
+  set: set$6
 } = create(ErrorWorker);
 
 const {
-  invoke: invoke$3,
-  set: set$4
+  invoke: invoke$6,
+  set: set$5
 } = create(ExtensionManagementWorker);
 
+const rpcId = 123_456;
 const {
-  invoke: invoke$2,
+  invoke: invoke$5,
+  set: set$4
+} = create(rpcId);
+// TODO add functions
+
+const {
+  invoke: invoke$4,
   set: set$3
 } = create(OpenerWorker);
 
 const {
-  invoke: invoke$1,
+  invoke: invoke$3,
   invokeAndTransfer,
   set: set$2
 } = create(RendererWorker);
@@ -1239,7 +1246,7 @@ const sendMessagePortToErrorWorker = async (port, rpcId) => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
 };
 const readFile$1 = async uri => {
-  return invoke$1('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const sendMessagePortToRendererProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1250,13 +1257,24 @@ const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 const getPreference = async key => {
-  return await invoke$1('Preferences.get', key);
+  return await invoke$3('Preferences.get', key);
 };
 
-const send$4 = async port => {
+const send$5 = async port => {
   await sendMessagePortToEditorWorker(port, TestWorker);
 };
 const initializeEditorWorker = async () => {
+  const rpc = await create$3({
+    commandMap: {},
+    send: send$5
+  });
+  set$7(rpc);
+};
+
+const send$4 = async port => {
+  await sendMessagePortToErrorWorker(port, TestWorker);
+};
+const initializeErrorWorker = async () => {
   const rpc = await create$3({
     commandMap: {},
     send: send$4
@@ -1265,9 +1283,9 @@ const initializeEditorWorker = async () => {
 };
 
 const send$3 = async port => {
-  await sendMessagePortToErrorWorker(port, TestWorker);
+  await sendMessagePortToExtensionManagementWorker(port, TestWorker);
 };
-const initializeErrorWorker = async () => {
+const initializeExtensionManagementWorker = async () => {
   const rpc = await create$3({
     commandMap: {},
     send: send$3
@@ -1276,9 +1294,9 @@ const initializeErrorWorker = async () => {
 };
 
 const send$2 = async port => {
-  await sendMessagePortToExtensionManagementWorker(port, TestWorker);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMainAreaWorker', port, 'MainArea.handleTestWorkerMessagePort', TestWorker);
 };
-const initializeExtensionManagementWorker = async () => {
+const initializeMainAreaWorker = async () => {
   const rpc = await create$3({
     commandMap: {},
     send: send$2
@@ -1299,7 +1317,7 @@ const initializeOpenerWorker = async () => {
 
 // @ts-nocheck
 
-const state$4 = {
+const state$5 = {
   mockRpcs: Object.create(null),
   /**
    * @type {any[]}
@@ -1307,7 +1325,7 @@ const state$4 = {
   pendingTests: []
 };
 const addTest = (name, fn) => {
-  state$4.pendingTests.push({
+  state$5.pendingTests.push({
     fn,
     name
   });
@@ -1315,10 +1333,10 @@ const addTest = (name, fn) => {
 const setMockRpc = mockRpc => {
   object(mockRpc);
   string$1(mockRpc.name);
-  state$4.mockRpcs[mockRpc.name] = mockRpc;
+  state$5.mockRpcs[mockRpc.name] = mockRpc;
 };
 const getMockRpc = name => {
-  return state$4.mockRpcs[name];
+  return state$5.mockRpcs[name];
 };
 
 const executeMockRpcFunction = async (name, method, ...params) => {
@@ -1333,17 +1351,17 @@ const executeMockRpcFunction = async (name, method, ...params) => {
   return fn(...params);
 };
 
-const state$3 = {
+const state$4 = {
   autoFixError: undefined
 };
 const get$1 = () => {
-  return state$3.autoFixError;
+  return state$4.autoFixError;
 };
 const set$1 = value => {
-  state$3.autoFixError = value;
+  state$4.autoFixError = value;
 };
 const clear$3 = () => {
-  state$3.autoFixError = undefined;
+  state$4.autoFixError = undefined;
 };
 
 class AssertionError extends Error {
@@ -1360,23 +1378,26 @@ const getConditionLocator = locator => {
   return locator._parsed;
 };
 
-const state$2 = {
+const state$3 = {
   rpc: undefined
 };
 const send = async port => {
   await sendMessagePortToRendererProcess(port);
 };
 const initialize = async () => {
-  state$2.rpc = await create$3({
+  state$3.rpc = await create$3({
     commandMap: {},
     send
   });
 };
-const invoke = (method, ...params) => {
-  if (state$2.rpc) {
-    return state$2.rpc.invoke(method, ...params);
+const isInitialized = () => {
+  return state$3.rpc !== undefined;
+};
+const invoke$2 = (method, ...params) => {
+  if (state$3.rpc) {
+    return state$3.rpc.invoke(method, ...params);
   }
-  return invoke$1(method, ...params);
+  return invoke$3(method, ...params);
 };
 
 const webViews = Object.create(null);
@@ -1394,7 +1415,7 @@ const getLocatorInvoke = locator => {
     const module = get(locator.webViewId);
     return module.invoke;
   }
-  return invoke;
+  return invoke$2;
 };
 
 const locatorInvoke = async (locator, method, ...params) => {
@@ -1903,29 +1924,63 @@ const skipTest = async id => {
   const state = 'skip';
   const background = 'yellow';
   const text = `test skipped ${id}`;
-  await invoke('TestFrameWork.showOverlay', state, background, text);
+  await invoke$2('TestFrameWork.showOverlay', state, background, text);
 };
 const {
   expect
 } = Expect$1;
 
+const rendererWorkerCommands$1 = new Set(['ActivityBar.handleSideBarHidden', 'About.showAbout', 'Chat.handleInputCut', 'Chat.handleInputPaste', 'Chat.getComposerSelection', 'Chat.selectIndex', 'Chat.setNewChatModelPickerEnabled', 'ChatDebug.setIndexedDbSupportForTest', 'ChatDebug.getPayload', 'ChatDebug.getResponse', 'DiffView.setWordWrap', 'ExtensionDetail.selectFeature', 'Explorer.restoreState', 'LanguageModels.addModel', 'LanguageModels.clearFilterInput', 'LanguageModels.removeModel', 'Main.closeTabsLeft', 'Main.focusFirst', 'Main.focusLast', 'Main.openKeyBindings', 'Main.saveAll', 'QuickPick.showCommands', 'Search.focusPage', 'Search.handleInputConextMenu', 'Search.openDetails', 'StatusBar.updateStatusBarItems']);
+const rpcs = new Map();
+const createRpc = rpcId => {
+  return create$3({
+    commandMap: {},
+    async send(port) {
+      await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToViewWorker', port, rpcId);
+    }
+  });
+};
+const getRpc = rpcId => {
+  let rpc = rpcs.get(rpcId);
+  if (!rpc) {
+    rpc = createRpc(rpcId);
+    rpcs.set(rpcId, rpc);
+  }
+  return rpc;
+};
+const invoke$1 = async (rpcId, commandId, ...args) => {
+  if (!isInitialized() || rendererWorkerCommands$1.has(commandId)) {
+    return invoke$3(commandId, ...args);
+  }
+  let uid;
+  try {
+    uid = await invoke$2('DirectView.getUid', rpcId);
+  } catch {
+    return invoke$3(commandId, ...args);
+  }
+  const rpc = await getRpc(rpcId);
+  const separatorIndex = commandId.indexOf('.');
+  const command = commandId.slice(separatorIndex + 1);
+  return rpc.invoke('Viewlet.executeViewletCommand', uid, command, ...args);
+};
+
 const show$9 = async () => {
-  return invoke$1('About.showAbout');
+  return invoke$1('About', 'About.showAbout');
 };
 const handleClickOk = async () => {
-  return invoke$1('About.handleClickOk');
+  return invoke$1('About', 'About.handleClickOk');
 };
 const handleClickClose$1 = async () => {
-  return invoke$1('About.handleClickClose');
+  return invoke$1('About', 'About.handleClickClose');
 };
 const handleClickCopy = async () => {
-  return invoke$1('About.handleClickCopy');
+  return invoke$1('About', 'About.handleClickCopy');
 };
 const focusNext$b = async () => {
-  return invoke$1('About.focusNext');
+  return invoke$1('About', 'About.focusNext');
 };
 const focusPrevious$b = async () => {
-  return invoke$1('About.focusPrevious');
+  return invoke$1('About', 'About.focusPrevious');
 };
 
 const About = {
@@ -1937,84 +1992,72 @@ const About = {
   show: show$9
 };
 
-const execute$1 = async (id, ...args) => {
-  return invoke$1(id, ...args);
-};
-const executeExtensionCommand = async (commandId, ...args) => {
-  return invoke$3('Extensions.executeCommand', commandId, ...args);
-};
-
-const Command = {
-  execute: execute$1,
-  executeExtensionCommand
-};
-
 const focus$2 = async () => {
-  await invoke$1('ActivityBar.focus');
+  await invoke$1('ActivityBar', 'ActivityBar.focus');
 };
 const toggleActivityBarItem = async id => {
-  await invoke$1('ActivityBar.toggleActivityBarItem', id);
+  await invoke$1('ActivityBar', 'ActivityBar.toggleActivityBarItem', id);
 };
 const setUserLoginState = async (loginState, userInfo) => {
   if (userInfo === undefined) {
-    await invoke$1('ActivityBar.setUserLoginState', loginState);
+    await invoke$1('ActivityBar', 'ActivityBar.setUserLoginState', loginState);
     return;
   }
-  await invoke$1('ActivityBar.setUserLoginState', loginState, userInfo);
+  await invoke$1('ActivityBar', 'ActivityBar.setUserLoginState', loginState, userInfo);
 };
 const focusFirst$9 = async () => {
-  await invoke$1('ActivityBar.focusFirst');
+  await invoke$1('ActivityBar', 'ActivityBar.focusFirst');
 };
 const setAccountEnabled = async enabled => {
-  await invoke$1('ActivityBar.setAccountEnabled', enabled);
+  await invoke$1('ActivityBar', 'ActivityBar.setAccountEnabled', enabled);
 };
 const focusLast$8 = async () => {
-  await invoke$1('ActivityBar.focusLast');
+  await invoke$1('ActivityBar', 'ActivityBar.focusLast');
 };
 const focusNext$a = async () => {
-  await invoke$1('ActivityBar.focusNext');
+  await invoke$1('ActivityBar', 'ActivityBar.focusNext');
 };
 const focusPrevious$a = async () => {
-  await invoke$1('ActivityBar.focusPrevious');
+  await invoke$1('ActivityBar', 'ActivityBar.focusPrevious');
 };
 const handleClick$4 = async () => {
-  await execute$1('ActivityBar.handleClick', 0, -1e3, -1e3, '');
+  await invoke$1('ActivityBar', 'ActivityBar.handleClick', 0, -1e3, -1e3, '');
 };
 const handleClickIndex = async () => {
-  await execute$1('ActivityBar.handleClickIndex', 0, 1, 0, 0);
+  await invoke$1('ActivityBar', 'ActivityBar.handleClickIndex', 0, 1, 0, 0);
 };
 const handleSideBarHidden = async () => {
-  await invoke$1('ActivityBar.handleSideBarHidden');
+  await invoke$1('ActivityBar', 'ActivityBar.handleSideBarHidden');
 };
 const handleContextMenu$7 = async (uid, button, x, y) => {
-  await invoke$1('ActivityBar.handleContextMenu', uid, button, x, y);
+  await invoke$1('ActivityBar', 'ActivityBar.handleContextMenu', uid, button, x, y);
 };
 const handleExtensionsChanged$1 = async () => {
-  await invoke$1('ActivityBar.handleExtensionsChanged');
+  await invoke$1('ActivityBar', 'ActivityBar.handleExtensionsChanged');
 };
 const handleBadgeCountChange = async () => {
-  await execute$1('ActivityBar.handleBadgeCountChange', {});
+  await invoke$1('ActivityBar', 'ActivityBar.handleBadgeCountChange', {});
 };
 const handleSettingsChanged = async () => {
-  await execute$1('ActivityBar.handleSettingsChanged');
+  await invoke$1('ActivityBar', 'ActivityBar.handleSettingsChanged');
 };
 const setUpdateState = async config => {
-  await invoke$1('ActivityBar.handleUpdateStateChange', config);
+  await invoke$1('ActivityBar', 'ActivityBar.handleUpdateStateChange', config);
 };
 const selectCurrent = async () => {
-  await invoke$1('ActivityBar.selectCurrent');
+  await invoke$1('ActivityBar', 'ActivityBar.selectCurrent');
 };
 const handleClickSettings$2 = async (x, y) => {
-  await invoke$1('ActivityBar.handleClickSettings', x, y);
+  await invoke$1('ActivityBar', 'ActivityBar.handleClickSettings', x, y);
 };
 const handleClickAccount = async (x, y) => {
-  await invoke$1('ActivityBar.handleClickAccount', x, y);
+  await invoke$1('ActivityBar', 'ActivityBar.handleClickAccount', x, y);
 };
 const handleClickAdditionalViews = async (x, y) => {
-  await invoke$1('ActivityBar.handleClickAdditionalViews', x, y);
+  await invoke$1('ActivityBar', 'ActivityBar.handleClickAdditionalViews', x, y);
 };
 const resize = async dimensions => {
-  await invoke$1('ActivityBar.resize', dimensions);
+  await invoke$1('ActivityBar', 'ActivityBar.resize', dimensions);
 };
 
 const ActivityBar = {
@@ -2042,215 +2085,215 @@ const ActivityBar = {
 };
 
 const setReasoningPickerEnabled = async enabled => {
-  await invoke$1('Chat.setReasoningPickerEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setReasoningPickerEnabled', enabled);
 };
 const setReasoningEffort = async effort => {
-  await invoke$1('Chat.setReasoningEffort', effort);
+  await invoke$1('Chat', 'Chat.setReasoningEffort', effort);
 };
 const handleChatListContextMenu = async (eventX, eventY) => {
-  await invoke$1('Chat.handleChatListContextMenu', eventX, eventY);
+  await invoke$1('Chat', 'Chat.handleChatListContextMenu', eventX, eventY);
 };
 const setBackendUrl = async url => {
-  await invoke$1('Chat.setBackendUrl', url);
+  await invoke$1('Chat', 'Chat.setBackendUrl', url);
 };
 const setUseOwnBackend = async enabled => {
-  await invoke$1('Chat.setUseOwnBackend', enabled);
+  await invoke$1('Chat', 'Chat.setUseOwnBackend', enabled);
 };
 const handleClickBack = async () => {
-  await invoke$1('Chat.handleClickBack');
+  await invoke$1('Chat', 'Chat.handleClickBack');
 };
 const setNewChatModelPickerEnabled = async enabled => {
-  await invoke$1('Chat.setNewChatModelPickerEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setNewChatModelPickerEnabled', enabled);
 };
 const openAgentModePicker = async () => {
-  await invoke$1('Chat.openAgentModePicker');
+  await invoke$1('Chat', 'Chat.openAgentModePicker');
 };
 const handleClickSettings$1 = async () => {
-  await invoke$1('Chat.handleClickSettings');
+  await invoke$1('Chat', 'Chat.handleClickSettings');
 };
 const selectIndex$8 = async index => {
-  await invoke$1('Chat.selectIndex', index);
+  await invoke$1('Chat', 'Chat.selectIndex', index);
 };
 const handleClickClose = async () => {
-  await invoke$1('Chat.handleClickClose');
+  await invoke$1('Chat', 'Chat.handleClickClose');
 };
 const shouldHaveComposerSelection = async (start, end) => {
-  const selection = await invoke$1('Chat.getComposerSelection');
+  const selection = await invoke$1('Chat', 'Chat.getComposerSelection');
   if (selection.start !== start || selection.end !== end) {
     throw new Error(`Expected selection to be { start: ${start}, end: ${end} }, but got { start: ${selection.start}, end: ${selection.end} }`);
   }
 };
 const handleClickNew = async () => {
-  await invoke$1('Chat.handleClickNew');
+  await invoke$1('Chat', 'Chat.handleClickNew');
 };
 const enterNewLine = async () => {
-  await invoke$1('Chat.enterNewLine');
+  await invoke$1('Chat', 'Chat.enterNewLine');
 };
 const setScrollDownButtonEnabled = async enabled => {
-  await invoke$1('Chat.setScrollDownButtonEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setScrollDownButtonEnabled', enabled);
 };
 const show$8 = async () => {
-  await invoke$1('Layout.showSecondarySideBar');
-  await invoke$1('Chat.reset');
+  await invoke$3('Layout.showSecondarySideBar');
+  await invoke$1('Chat', 'Chat.reset');
 };
 const getSelectedSessionId = async () => {
-  return invoke$1('Chat.getSelectedSessionId');
+  return invoke$3('Chat.getSelectedSessionId');
 };
 const handleInput$9 = async text => {
-  await invoke$1('Chat.handleInput', 'composer', text, 'script');
+  await invoke$1('Chat', 'Chat.handleInput', 'composer', text, 'script');
 };
 const handleDropFiles = async file => {
-  await execute$1('Chat.handleDropFiles', 'composer-drop-target', [file]);
+  await invoke$1('Chat', 'Chat.handleDropFiles', 'composer-drop-target', [file]);
 };
 const showComposerAttachmentPreviewOverlay = async attachmentId => {
-  await execute$1('Chat.showComposerAttachmentPreviewOverlay', attachmentId);
+  await invoke$1('Chat', 'Chat.showComposerAttachmentPreviewOverlay', attachmentId);
 };
 const handleErrorComposerAttachmentPreviewOverlay = async () => {
-  await execute$1('Chat.handleErrorComposerAttachmentPreviewOverlay');
+  await invoke$1('Chat', 'Chat.handleErrorComposerAttachmentPreviewOverlay');
 };
 const handleClickSessionDebug = async () => {
-  await execute$1('Chat.handleClickSessionDebug');
+  await invoke$1('Chat', 'Chat.handleClickSessionDebug');
 };
 const handleChatHeaderContextMenu = async () => {
-  await execute$1('Chat.handleChatHeaderContextMenu', 0, 0);
+  await invoke$1('Chat', 'Chat.handleChatHeaderContextMenu', 0, 0);
 };
 const reset = async () => {
-  await invoke$1('Chat.reset');
+  await invoke$1('Chat', 'Chat.reset');
 };
 const handleMessagesScroll = async (id, x, y) => {
-  await invoke$1('Chat.handleMessagesScroll', id, x, y);
+  await invoke$1('Chat', 'Chat.handleMessagesScroll', id, x, y);
 };
 const mockOpenApiStreamFinish = async () => {
-  await invoke$1('Chat.mockOpenApiStreamFinish');
+  await invoke$1('Chat', 'Chat.mockOpenApiStreamFinish');
 };
 const mockOpenApiStreamPushChunk = async chunk => {
-  await invoke$1('Chat.mockOpenApiStreamPushChunk', chunk);
+  await invoke$1('Chat', 'Chat.mockOpenApiStreamPushChunk', chunk);
 };
 const openMockSession = async (sessionId, messages) => {
-  await invoke$1('Chat.openMockSession', sessionId, messages);
+  await invoke$1('Chat', 'Chat.openMockSession', sessionId, messages);
 };
 const mockBackendSetHttpErrorResponse = async response => {
-  await invoke$1('Chat.mockBackendSetHttpErrorResponse', response.statusCode, response);
+  await invoke$1('Chat', 'Chat.mockBackendSetHttpErrorResponse', response.statusCode, response);
 };
 const registerMockResponse = async options => {
-  await invoke$1('Chat.registerMockResponse', options);
+  await invoke$1('Chat', 'Chat.registerMockResponse', options);
 };
 const handleSubmit = async () => {
-  await invoke$1('Chat.handleSubmit');
+  await invoke$1('Chat', 'Chat.handleSubmit');
 };
 const setStreamingEnabled = async enabled => {
-  await invoke$1('Chat.setStreamingEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setStreamingEnabled', enabled);
 };
 const useMockApi = async () => {
-  await invoke$1('Chat.useMockApi', true);
+  await invoke$1('Chat', 'Chat.useMockApi', true);
 };
 const openGitBranchPicker = async () => {
-  await invoke$1('Chat.openGitBranchPicker');
+  await invoke$1('Chat', 'Chat.openGitBranchPicker');
 };
 const closeGitBranchPicker = async () => {
-  await invoke$1('Chat.closeGitBranchPicker');
+  await invoke$1('Chat', 'Chat.closeGitBranchPicker');
 };
 const setAuthEnabled = async enabled => {
-  await invoke$1('Chat.setAuthEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setAuthEnabled', enabled);
 };
 const mockBackendAuthResponse = async response => {
-  await invoke$1('Chat.mockBackendAuthResponse', response);
+  await invoke$1('Chat', 'Chat.mockBackendAuthResponse', response);
 };
 const mockOpenApiRequestGetAll = async () => {
-  return invoke$1('Chat.mockOpenApiRequestGetAll');
+  return invoke$3('Chat.mockOpenApiRequestGetAll');
 };
 const rerender = async () => {
-  await invoke$1('Chat.rerender');
+  await invoke$1('Chat', 'Chat.rerender');
 };
 const setSearchEnabled = async enabled => {
-  await invoke$1('Chat.setSearchEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setSearchEnabled', enabled);
 };
 const mockOpenApiRequestReset = async () => {
-  await invoke$1('Chat.mockOpenApiRequestReset');
+  await invoke$1('Chat', 'Chat.mockOpenApiRequestReset');
 };
 const mockOpenApiStreamReset = async () => {
-  await invoke$1('Chat.mockOpenApiStreamReset');
+  await invoke$1('Chat', 'Chat.mockOpenApiStreamReset');
 };
 const openModelPicker = async () => {
-  await invoke$1('Chat.openModelPicker');
+  await invoke$1('Chat', 'Chat.openModelPicker');
 };
 const handleModelPickerInput = async value => {
-  await invoke$1('Chat.handleInput', 'model-picker-search', value);
+  await invoke$1('Chat', 'Chat.handleInput', 'model-picker-search', value);
 };
 const handleClickDelete = async () => {
-  await invoke$1('Chat.handleClickDelete');
+  await invoke$1('Chat', 'Chat.handleClickDelete');
 };
 const handleContextMenuChatImageAttachment = async (id, x, y) => {
-  await invoke$1('Chat.handleContextMenuChatImageAttachment', id, x, y);
+  await invoke$1('Chat', 'Chat.handleContextMenuChatImageAttachment', id, x, y);
 };
 const setAddContextButtonEnabled = async enabled => {
-  await invoke$1('Chat.setAddContextButtonEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setAddContextButtonEnabled', enabled);
 };
 const deleteSessionAtIndex = async index => {
-  await invoke$1('Chat.deleteSessionAtIndex', index);
+  await invoke$1('Chat', 'Chat.deleteSessionAtIndex', index);
 };
 const handleModelChange = async modelId => {
-  await invoke$1('Chat.handleModelChange', modelId);
+  await invoke$1('Chat', 'Chat.handleModelChange', modelId);
 };
 const handleModelInputBlur = async () => {
-  await execute$1('Chat.handleModelInputBlur');
+  await invoke$1('Chat', 'Chat.handleModelInputBlur');
 };
 const handleInputPaste$1 = async () => {
-  await invoke$1('Chat.handleInputPaste');
+  await invoke$1('Chat', 'Chat.handleInputPaste');
 };
 const setQuestionToolEnabled = async enabled => {
-  await invoke$1('Chat.setQuestionToolEnabled', enabled);
+  await invoke$1('Chat', 'Chat.setQuestionToolEnabled', enabled);
 };
 const handleInputCopy$1 = async () => {
-  await invoke$1('Chat.handleInputCopy');
+  await invoke$1('Chat', 'Chat.handleInputCopy');
 };
 const handleClickFileName = async fileName => {
-  await invoke$1('Chat.handleClickFileName', fileName);
+  await invoke$1('Chat', 'Chat.handleClickFileName', fileName);
 };
 const handleInputCut$1 = async () => {
-  await invoke$1('Chat.handleInputCut');
+  await invoke$1('Chat', 'Chat.handleInputCut');
 };
 const clearInput$1 = async () => {
-  await execute$1('Chat.clearInput');
+  await invoke$1('Chat', 'Chat.clearInput');
 };
 const handleProjectListContextMenu = async (id, x, y) => {
-  await execute$1('Chat.handleProjectListContextMenu', id, x, y);
+  await invoke$1('Chat', 'Chat.handleProjectListContextMenu', id, x, y);
 };
 const mockOpenAiResponse = async options => {
-  return invoke$1('Chat.mockOpenAiResponse', options);
+  return invoke$3('Chat.mockOpenAiResponse', options);
 };
 const handleInputFocus = async () => {
-  return execute$1('Chat.handleInputFocus', 'chat-list');
+  return invoke$1('Chat', 'Chat.handleInputFocus', 'chat-list');
 };
 const openDebugView = async () => {
-  return execute$1('Chat.openDebugView');
+  return invoke$1('Chat', 'Chat.openDebugView');
 };
 const chatListFocusPrevious = async () => {
-  return execute$1('Chat.chatListFocusPrevious');
+  return invoke$1('Chat', 'Chat.chatListFocusPrevious');
 };
 const chatListFocusFirst = async () => {
-  return execute$1('Chat.chatListFocusFirst');
+  return invoke$1('Chat', 'Chat.chatListFocusFirst');
 };
 const chatListFocusLast = async () => {
-  return execute$1('Chat.chatListFocusLast');
+  return invoke$1('Chat', 'Chat.chatListFocusLast');
 };
 const chatListFocusNext = async () => {
-  return execute$1('Chat.chatListFocusNext');
+  return invoke$1('Chat', 'Chat.chatListFocusNext');
 };
 const setNowForTest = async now => {
-  await execute$1('Chat.setNowForTest', now);
+  await invoke$1('Chat', 'Chat.setNowForTest', now);
 };
 const getAuthState = async () => {
-  return invoke$1('Chat.getAuthState');
+  return invoke$3('Chat.getAuthState');
 };
 const setShowChatListTime = async showTime => {
-  return invoke$1('Chat.setShowChatListTime', showTime);
+  return invoke$1('Chat', 'Chat.setShowChatListTime', showTime);
 };
 const handleAgentModeChange = async newAgentMode => {
-  return invoke$1('Chat.handleAgentModeChange', newAgentMode);
+  return invoke$1('Chat', 'Chat.handleAgentModeChange', newAgentMode);
 };
 const mockOpenApiSetResponse = async items => {
-  return invoke$1('Chat.mockOpenApiSetResponse', items);
+  return invoke$1('Chat', 'Chat.mockOpenApiSetResponse', items);
 };
 
 const Chat = {
@@ -2391,14 +2434,14 @@ class ChatDebugShouldHavePayloadError extends Error {
 }
 
 const open$b = async sessionId => {
-  await invoke$1('Main.openUri', `chat-debug://${sessionId}`);
+  await invoke$1('MainArea', 'Main.openUri', `chat-debug://${sessionId}`);
 };
 const open2 = async ({
   events,
   sessionId,
   useDevtoolsLayout
 }) => {
-  await invoke$1('Main.openUri', `chat-debug://${sessionId}`);
+  await invoke$1('MainArea', 'Main.openUri', `chat-debug://${sessionId}`);
   if (events) {
     await setEvents(events);
   }
@@ -2407,25 +2450,25 @@ const open2 = async ({
   }
 };
 const handleTimelineDoubleClick = async () => {
-  await invoke$1('ChatDebug.handleTimelineDoubleClick');
+  await invoke$1('ChatDebug', 'ChatDebug.handleTimelineDoubleClick');
 };
 const setEvents = async events => {
-  await invoke$1('ChatDebug.setEvents', events);
+  await invoke$1('ChatDebug', 'ChatDebug.setEvents', events);
 };
 const toggleHeadersSection = async sectionId => {
-  await invoke$1('ChatDebug.handleInput', 'toggleHeadersSection', sectionId, false);
+  await invoke$1('ChatDebug', 'ChatDebug.handleInput', 'toggleHeadersSection', sectionId, false);
 };
 const setIndexedDbSupportForTest = async supported => {
-  await invoke$1('ChatDebug.setIndexedDbSupportForTest', supported);
+  await invoke$1('ChatDebug', 'ChatDebug.setIndexedDbSupportForTest', supported);
 };
 const handleRootContextMenu = async () => {
-  await invoke$1('ChatDebug.handleRootContextMenu');
+  await invoke$1('ChatDebug', 'ChatDebug.handleRootContextMenu');
 };
 const resetIndexedDbSupportForTest = async () => {
-  await invoke$1('ChatDebug.setIndexedDbSupportForTest');
+  await invoke$1('ChatDebug', 'ChatDebug.setIndexedDbSupportForTest');
 };
 const selectEventRow = async index => {
-  await invoke$1('ChatDebug.handleEventRowClick', String(index));
+  await invoke$1('ChatDebug', 'ChatDebug.handleEventRowClick', String(index));
 };
 const getActualPayload = error => {
   if (!error || typeof error !== 'object') {
@@ -2441,14 +2484,14 @@ const getActualPayload = error => {
 };
 const shouldHavePayload = async expectedPayload => {
   try {
-    await invoke$1('ChatDebug.shouldHavePayload', expectedPayload);
+    await invoke$1('ChatDebug', 'ChatDebug.shouldHavePayload', expectedPayload);
   } catch (error) {
     const actualPayload = getActualPayload(error);
     throw new ChatDebugShouldHavePayloadError(expectedPayload, actualPayload, error);
   }
 };
 const shouldHavePayload2 = async expectedPayload => {
-  const actualPayload = await invoke$1('ChatDebug.getPayload');
+  const actualPayload = await invoke$1('ChatDebug', 'ChatDebug.getPayload');
   try {
     assertPayloadMatches(actualPayload, expectedPayload, 'payload');
   } catch (error) {
@@ -2456,7 +2499,7 @@ const shouldHavePayload2 = async expectedPayload => {
   }
 };
 const shouldHaveResponse = async expectedPayload => {
-  const actualPayload = await invoke$1('ChatDebug.getResponse');
+  const actualPayload = await invoke$1('ChatDebug', 'ChatDebug.getResponse');
   try {
     assertPayloadMatches(actualPayload, expectedPayload, 'response');
   } catch (error) {
@@ -2465,19 +2508,19 @@ const shouldHaveResponse = async expectedPayload => {
   }
 };
 const handleInput$8 = async (name, value, checked) => {
-  await invoke$1('ChatDebug.handleInput', name, value, checked);
+  await invoke$1('ChatDebug', 'ChatDebug.handleInput', name, value, checked);
 };
 const useDevtoolsLayout = async () => {
   await handleInput$8('useDevtoolsLayout', '', true);
 };
 const handleHeaderContextMenu = async (x, y) => {
-  await invoke$1('ChatDebug.handleHeaderContextMenu', x, y);
+  await invoke$1('ChatDebug', 'ChatDebug.handleHeaderContextMenu', x, y);
 };
 const setFilter = async value => {
   await handleInput$8('filter', value, false);
 };
 const handlePreviewTextPointerDown = async (x, y) => {
-  await invoke$1('ChatDebug.handlePreviewTextPointerDown', x, y);
+  await invoke$1('ChatDebug', 'ChatDebug.handlePreviewTextPointerDown', x, y);
 };
 const setEventCategoryFilter = async value => {
   await handleInput$8('eventCategoryFilter', value, false);
@@ -2492,7 +2535,7 @@ const setShowResponsePartEvents = async enabled => {
   await handleInput$8('showResponsePartEvents', '', enabled);
 };
 const handleTableFocus = async () => {
-  await invoke$1('ChatDebug.handleTableFocus');
+  await invoke$1('ChatDebug', 'ChatDebug.handleTableFocus');
 };
 const setShowEventStreamFinishedEvents = async enabled => {
   await handleInput$8('showEventStreamFinishedEvents', '', enabled);
@@ -2501,7 +2544,7 @@ const closeDetails = async () => {
   await handleInput$8('closeDetails', 'close', false);
 };
 const openTab = async id => {
-  await invoke$1('ChatDebug.handleInput', 'detailTab', id, false);
+  await invoke$1('ChatDebug', 'ChatDebug.handleInput', 'detailTab', id, false);
 };
 const openTabPreview = async () => {
   await openTab('preview');
@@ -2513,13 +2556,13 @@ const openTabResponse = async () => {
   await openTab('response');
 };
 const handleTimelinePointerDown = async (name, x, y) => {
-  await invoke$1('ChatDebug.handleTimelinePointerDown', name, x, y);
+  await invoke$1('ChatDebug', 'ChatDebug.handleTimelinePointerDown', name, x, y);
 };
 const handleTimelinePointerMove = async x => {
-  await invoke$1('ChatDebug.handleTimelinePointerMove', x);
+  await invoke$1('ChatDebug', 'ChatDebug.handleTimelinePointerMove', x);
 };
 const handleTimelinePointerUp = async x => {
-  await invoke$1('ChatDebug.handleTimelinePointerUp', x);
+  await invoke$1('ChatDebug', 'ChatDebug.handleTimelinePointerUp', x);
 };
 const openTabTokens = async () => {
   await openTab('tokens');
@@ -2531,19 +2574,19 @@ const openTabHeaders = async () => {
   await openTab('headers');
 };
 const setSessionId = async sessionId => {
-  await invoke$1('ChatDebug.setSessionId', sessionId);
+  await invoke$1('ChatDebug', 'ChatDebug.setSessionId', sessionId);
 };
 const appendStoredEventForTest = async event => {
-  await invoke$1('ChatDebug.appendStoredEventForTest', event);
+  await invoke$1('ChatDebug', 'ChatDebug.appendStoredEventForTest', event);
 };
 const handleClickRefresh = async () => {
-  await invoke$1('ChatDebug.handleClickRefresh');
+  await invoke$1('ChatDebug', 'ChatDebug.handleClickRefresh');
 };
 const handleEventCategoryFilter = async filter => {
-  await invoke$1('ChatDebug.handleEventCategoryFilter', filter);
+  await invoke$1('ChatDebug', 'ChatDebug.handleEventCategoryFilter', filter);
 };
 const handleTableBodyContextMenu = async (x, y) => {
-  await invoke$1('ChatDebug.handleTableBodyContextMenu', x, y);
+  await invoke$1('ChatDebug', 'ChatDebug.handleTableBodyContextMenu', x, y);
 };
 
 const ChatDebug = {
@@ -2588,17 +2631,29 @@ const ChatDebug = {
   useDevtoolsLayout
 };
 
+const state$2 = {
+  enabled: false
+};
+const isEnabled = () => {
+  return state$2.enabled;
+};
+const setEnabled = enabled => {
+  state$2.enabled = enabled;
+};
+
 const readNativeFiles = async () => {
-  await invoke$1('ClipBoard.readNativeFiles');
+  await invoke$3('ClipBoard.readNativeFiles');
 };
 const writeNativeFiles = async uris => {
-  await invoke$1('ClipBoard.writeNativeFiles', uris);
+  await invoke$3('ClipBoard.writeNativeFiles', uris);
 };
 const enableMemoryClipBoard = async () => {
-  await invoke$1('ClipBoard.enableMemoryClipBoard');
+  await invoke$3('ClipBoard.enableMemoryClipBoard');
+  setEnabled(true);
 };
 const disableMemoryClipBoard = async () => {
-  await invoke$1('ClipBoard.disableMemoryClipBoard');
+  await invoke$3('ClipBoard.disableMemoryClipBoard');
+  setEnabled(false);
 };
 const matchesExpectedText$1 = (actualText, expectedText) => {
   if (typeof expectedText === 'string') {
@@ -2607,7 +2662,7 @@ const matchesExpectedText$1 = (actualText, expectedText) => {
   return expectedText.test(actualText);
 };
 const shouldHaveText$1 = async expectedText => {
-  const actualText = await invoke$1('ClipBoard.readMemoryText');
+  const actualText = await invoke$3('ClipBoard.readMemoryText');
   if (!matchesExpectedText$1(actualText, expectedText)) {
     throw new AssertionError(`expected clipboard to have text "${expectedText}" but was "${actualText}"`);
   }
@@ -2625,7 +2680,7 @@ const imageReadAttempts = 100;
 const imageReadDelay = 50;
 const waitForMemoryImage = async () => {
   for (let attempt = 0; attempt < imageReadAttempts; attempt++) {
-    const actualImage = await invoke$1('ClipBoard.readMemoryImage');
+    const actualImage = await invoke$3('ClipBoard.readMemoryImage');
     if (actualImage instanceof Blob) {
       return actualImage;
     }
@@ -2640,7 +2695,7 @@ const shouldHaveImage = async expectedUri => {
   if (!(actualImage instanceof Blob)) {
     throw new AssertionError(`expected clipboard to have image "${expectedUri}" but it had no image`);
   }
-  const expectedImage = await invoke$1('FileSystem.getBlob', expectedUri);
+  const expectedImage = await invoke$3('FileSystem.getBlob', expectedUri);
   if (!(expectedImage instanceof Blob)) {
     throw new AssertionError(`expected image "${expectedUri}" could not be read`);
   }
@@ -2653,7 +2708,7 @@ const shouldHaveImage = async expectedUri => {
   }
 };
 const writeText = async text => {
-  await invoke$1('ClipBoard.writeText', text);
+  await invoke$3('ClipBoard.writeText', text);
 };
 
 const ClipBoard = {
@@ -2666,8 +2721,27 @@ const ClipBoard = {
   writeText
 };
 
+const rendererWorkerCommands = new Set(['ColorPicker.setRelativeX', 'Editor.addAllMissingImports', 'Editor.indentLess', 'Editor.rename', 'Editor.sortImports', 'EditorCompletion.handlePointerdown', 'EditorCompletion.selectCurrentIndex', 'EditorHover.close', 'EditorRename.cancel', 'EditorSourceAction.selectCurrentIndex', 'EditorSourceActions.selectCurrent', 'FindWidget.focusElement']);
+const invoke = async (commandId, ...args) => {
+  if (!isInitialized() || rendererWorkerCommands.has(commandId)) {
+    return invoke$3(commandId, ...args);
+  }
+  let editorUid;
+  try {
+    editorUid = await invoke$2('DirectView.getFocusedUid', 'Editor');
+  } catch {
+    try {
+      const mainAreaUid = await invoke$2('DirectView.getUid', 'MainArea');
+      editorUid = await invoke$5('MainArea.getActiveEditorUid', mainAreaUid);
+    } catch {
+      return invoke$3(commandId, ...args);
+    }
+  }
+  return invoke$8('Editor.executeViewletCommand', editorUid, commandId, ...args);
+};
+
 const setRelativeX = async x => {
-  await invoke$1('ColorPicker.setRelativeX', x);
+  await invoke('ColorPicker.setRelativeX', x);
 };
 
 const ColorPicker = {
@@ -2675,18 +2749,30 @@ const ColorPicker = {
 };
 
 const setColorTheme = async id => {
-  await invoke$1('ColorTheme.setColorTheme', id);
+  await invoke$3('ColorTheme.setColorTheme', id);
 };
 
 const ColorTheme = {
   setColorTheme
 };
 
+const execute$1 = async (id, ...args) => {
+  return invoke$3(id, ...args);
+};
+const executeExtensionCommand = async (commandId, ...args) => {
+  return invoke$6('Extensions.executeCommand', commandId, ...args);
+};
+
+const Command = {
+  execute: execute$1,
+  executeExtensionCommand
+};
+
 const selectIndex$7 = async (level, index) => {
-  await invoke$1('Menu.selectIndex', level, index);
+  await invoke$3('Menu.selectIndex', level, index);
 };
 const selectItem$1 = async text => {
-  await invoke$1('Menu.selectItem', text);
+  await invoke$3('Menu.selectItem', text);
 };
 
 const ContextMenu = {
@@ -2695,28 +2781,28 @@ const ContextMenu = {
 };
 
 const openIframeInspector = async () => {
-  return invoke$1('Developer.openIframeInspector');
+  return invoke$3('Developer.openIframeInspector');
 };
 const openCacheFolder = async () => {
-  return invoke$1('Developer.openCacheFolder');
+  return invoke$3('Developer.openCacheFolder');
 };
 const openConfigFolder = async () => {
-  return invoke$1('Developer.openConfigFolder');
+  return invoke$3('Developer.openConfigFolder');
 };
 const openLogsFolder = async () => {
-  return invoke$1('Developer.openLogsFolder');
+  return invoke$3('Developer.openLogsFolder');
 };
 const openProcessExplorer = async () => {
-  return invoke$1('Developer.openProcessExplorer');
+  return invoke$3('Developer.openProcessExplorer');
 };
 const reloadColorTheme = async () => {
-  return invoke$1('Developer.reloadColorTheme');
+  return invoke$3('Developer.reloadColorTheme');
 };
 const reloadIconTheme = async () => {
-  return invoke$1('Developer.reloadIconTheme');
+  return invoke$3('Developer.reloadIconTheme');
 };
 const toggleDeveloperTools = async () => {
-  return invoke$1('Developer.toggleDeveloperTools');
+  return invoke$3('Developer.toggleDeveloperTools');
 };
 
 const Developer = {
@@ -2746,15 +2832,15 @@ const executeMock$1 = (id, ...args) => {
 };
 
 const showSaveFilePicker = async () => {
-  await invoke$1('FilePicker.showSaveFilePicker');
+  await invoke$3('FilePicker.showSaveFilePicker');
 };
 const mockSaveFilePicker = async fn => {
   const id = registerMock(fn);
-  await invoke$1('FilePicker.mockSaveFilePicker', id);
+  await invoke$3('FilePicker.mockSaveFilePicker', id);
 };
 const mockConfirm = async fn => {
   const id = registerMock(fn);
-  await invoke$1('ConfirmPrompt.mock', id);
+  await invoke$3('ConfirmPrompt.mock', id);
 };
 const executeMock = (id, ...args) => {
   return executeMock$1(id, ...args);
@@ -2838,16 +2924,16 @@ const serializeForError = value => {
   });
 };
 const openUri = async uri => {
-  await invoke$1('Main.openUri', uri);
+  await invoke$1('MainArea', 'Main.openUri', uri);
 };
 const openUris = async uris => {
-  await invoke$1('Main.openUris', uris);
+  await invoke$1('MainArea', 'Main.openUris', uris);
 };
 const openInput = async options => {
-  await invoke$1('Main.openInput', options);
+  await invoke$1('MainArea', 'Main.openInput', options);
 };
 const saveState$1 = async uid => {
-  return invoke$1('Main.saveState', uid);
+  return invoke$3('Main.saveState', uid);
 };
 const shouldHaveLayout = async (expectedLayout, uid = defaultMainAreaUid) => {
   const state = await saveState$1(uid);
@@ -2866,70 +2952,70 @@ const shouldHaveLayout = async (expectedLayout, uid = defaultMainAreaUid) => {
   }
 };
 const splitRight = async () => {
-  await invoke$1('Main.splitRight');
+  await invoke$1('MainArea', 'Main.splitRight');
 };
 const splitDown = async () => {
-  await invoke$1('Main.splitDown');
+  await invoke$1('MainArea', 'Main.splitDown');
 };
 const openKeyBindings = async () => {
-  await invoke$1('Main.openKeyBindings');
+  await invoke$1('MainArea', 'Main.openKeyBindings');
 };
 const handleClickTogglePreview = async () => {
-  await invoke$1('Main.handleClickTogglePreview');
+  await invoke$1('MainArea', 'Main.handleClickTogglePreview');
 };
 const handleClickAction = async (action, rawGroupId) => {
-  await invoke$1('Main.handleClickAction', action, rawGroupId);
+  await invoke$1('MainArea', 'Main.handleClickAction', action, rawGroupId);
 };
 const closeAllEditors = async () => {
-  await invoke$1('Main.closeAllEditors');
+  await invoke$1('MainArea', 'Main.closeAllEditors');
 };
 const closeTabsLeft = async () => {
-  await invoke$1('Main.closeTabsLeft');
+  await invoke$1('MainArea', 'Main.closeTabsLeft');
 };
 const handleModifiedStatusChange = async (uri, newStatus) => {
-  await invoke$1('Main.handleModifiedStatusChange', uri, newStatus);
+  await invoke$1('MainArea', 'Main.handleModifiedStatusChange', uri, newStatus);
 };
 const closeTabsRight = async () => {
-  await invoke$1('Main.closeTabsRight');
+  await invoke$1('MainArea', 'Main.closeTabsRight');
 };
 const selectTab$2 = async (groupIndex, tabIndex) => {
-  await invoke$1('Main.selectTab', groupIndex, tabIndex);
+  await invoke$1('MainArea', 'Main.selectTab', groupIndex, tabIndex);
 };
 const closeOthers = async () => {
-  await invoke$1('Main.closeOthers');
+  await invoke$1('MainArea', 'Main.closeOthers');
 };
 const closeActiveEditor = async () => {
-  await invoke$1('Main.closeActiveEditor');
+  await invoke$1('MainArea', 'Main.closeActiveEditor');
 };
 const save = async () => {
-  await invoke$1('Main.save');
+  await invoke$1('MainArea', 'Main.save');
 };
 const saveAll = async () => {
-  await invoke$1('Main.saveAll');
+  await invoke$1('MainArea', 'Main.saveAll');
 };
 const focusFirst$8 = async () => {
-  await invoke$1('Main.focusFirst');
+  await invoke$1('MainArea', 'Main.focusFirst');
 };
 const focusNext$9 = async () => {
-  await invoke$1('Main.focusNext');
+  await invoke$1('MainArea', 'Main.focusNext');
 };
 const focusPrevious$9 = async () => {
-  await invoke$1('Main.focusPrevious');
+  await invoke$1('MainArea', 'Main.focusPrevious');
 };
 const handleClickCloseTab = async (rawGroupIndex, rawIndex) => {
-  await invoke$1('Main.handleClickCloseTab', rawGroupIndex, rawIndex);
+  await invoke$1('MainArea', 'Main.handleClickCloseTab', rawGroupIndex, rawIndex);
 };
 const focusLast$7 = async () => {
-  await invoke$1('Main.focusLast');
+  await invoke$1('MainArea', 'Main.focusLast');
 };
 const handleTabContextMenu = async (button, x, y) => {
-  await invoke$1('Main.handleTabContextMenu', button, x, y);
+  await invoke$1('MainArea', 'Main.handleTabContextMenu', button, x, y);
 };
 const copyPath$2 = async () => {
-  await invoke$1('Main.copyPath');
+  await invoke$1('MainArea', 'Main.copyPath');
 };
 const copyRelativePath$1 = async () => {
-  await invoke$1('Main.copyRelativePath');
+  await invoke$1('MainArea', 'Main.copyRelativePath');
 };
 
 const Main = {
@@ -2974,58 +3060,58 @@ const shouldHaveContentRight = async expectedContent => {
   await expect$1(contentRight).toHaveText(expectedContent);
 };
 const setDiffMode = async diffMode => {
-  await execute$1('DiffView.setDiffMode', diffMode);
+  await invoke$1('DiffView', 'DiffView.setDiffMode', diffMode);
 };
 const toggleDiffMode = async () => {
-  await execute$1('DiffView.toggleDiffMode');
+  await invoke$1('DiffView', 'DiffView.toggleDiffMode');
 };
 const setLayout = async layout => {
-  await execute$1('DiffView.setLayout', layout);
+  await invoke$1('DiffView', 'DiffView.setLayout', layout);
 };
 const setFontFamily = async fontFamily => {
-  await execute$1('DiffView.setFontFamily', fontFamily);
+  await invoke$1('DiffView', 'DiffView.setFontFamily', fontFamily);
 };
 const setWordWrap = async enabled => {
-  await execute$1('DiffView.setWordWrap', enabled);
+  await invoke$1('DiffView', 'DiffView.setWordWrap', enabled);
 };
 const toggleWhitespace = async () => {
-  await execute$1('DiffView.toggleWhitespace');
+  await invoke$1('DiffView', 'DiffView.toggleWhitespace');
 };
 const handleWheel$3 = async (deltaMode, deltaY) => {
-  await execute$1('DiffView.handleWheel', deltaMode, deltaY);
+  await invoke$1('DiffView', 'DiffView.handleWheel', deltaMode, deltaY);
 };
 const handleResize = async (width, height) => {
-  await execute$1('DiffView.handleResize', width, height);
+  await invoke$1('DiffView', 'DiffView.handleResize', width, height);
 };
 const handleWorkspaceChange = async () => {
-  await execute$1('DiffView.handleWorkspaceChange');
+  await invoke$1('DiffView', 'DiffView.handleWorkspaceChange');
 };
 const handleClickAt$4 = async (clientX, clientY, targetName) => {
-  await execute$1('DiffView.handleClickAt', clientX, clientY, targetName);
+  await invoke$1('DiffView', 'DiffView.handleClickAt', clientX, clientY, targetName);
 };
 const handleSashPointerDown = async (clientX, clientY) => {
-  await execute$1('DiffView.handleSashPointerDown', clientX, clientY);
+  await invoke$1('DiffView', 'DiffView.handleSashPointerDown', clientX, clientY);
 };
 const handleSashPointerMove = async (clientX, clientY) => {
-  await execute$1('DiffView.handleSashPointerMove', clientX, clientY);
+  await invoke$1('DiffView', 'DiffView.handleSashPointerMove', clientX, clientY);
 };
 const handleSashPointerUp = async (clientX, clientY) => {
-  await execute$1('DiffView.handleSashPointerUp', clientX, clientY);
+  await invoke$1('DiffView', 'DiffView.handleSashPointerUp', clientX, clientY);
 };
 const handleScrollBarPointerDown = async clientY => {
-  await execute$1('DiffView.handleScrollBarPointerDown', clientY);
+  await invoke$1('DiffView', 'DiffView.handleScrollBarPointerDown', clientY);
 };
 const handleScrollBarPointerMove = async clientY => {
-  await execute$1('DiffView.handleScrollBarPointerMove', clientY);
+  await invoke$1('DiffView', 'DiffView.handleScrollBarPointerMove', clientY);
 };
 const handleScrollBarPointerUp = async clientY => {
-  await execute$1('DiffView.handleScrollBarPointerUp', clientY);
+  await invoke$1('DiffView', 'DiffView.handleScrollBarPointerUp', clientY);
 };
 const setCursorPosition = async (rowIndex, columnIndex) => {
-  await execute$1('DiffView.setCursorPosition', rowIndex, columnIndex);
+  await invoke$1('DiffView', 'DiffView.setCursorPosition', rowIndex, columnIndex);
 };
 const handleInput$7 = async text => {
-  await execute$1('DiffView.handleInput', text);
+  await invoke$1('DiffView', 'DiffView.handleInput', text);
 };
 
 const DiffView = {
@@ -3100,7 +3186,7 @@ const areTokensEqual = (actual, expected) => {
 };
 
 const getEditorKey = async () => {
-  const keys = await invoke$5('Editor.getKeys');
+  const keys = await invoke$8('Editor.getKeys');
   if (keys.length === 0) {
     throw new Error(`no editor found`);
   }
@@ -3112,15 +3198,15 @@ const getEditorKey = async () => {
 const Script = 2;
 
 const update$1 = settings => {
-  return invoke$1('Preferences.update', settings);
+  return invoke$3('Preferences.update', settings);
 };
 const enableDiagnostics$1 = () => {
-  return invoke$1('Preferences.update', {
+  return invoke$3('Preferences.update', {
     'editor.diagnostics': true
   });
 };
 const disableDiagnostics$1 = () => {
-  return invoke$1('Preferences.update', {
+  return invoke$3('Preferences.update', {
     'editor.diagnostics': false
   });
 };
@@ -3132,279 +3218,279 @@ const Settings = {
 };
 
 const setCursor = async (rowIndex, columnIndex) => {
-  await invoke$1('Editor.cursorSet', rowIndex, columnIndex);
+  await invoke('Editor.cursorSet', rowIndex, columnIndex);
 };
 const cancelSelection = async () => {
-  await invoke$1('Editor.cancelSelection');
+  await invoke('Editor.cancelSelection');
 };
 const openCompletion = async () => {
-  await invoke$1('Editor.openCompletion');
+  await invoke('Editor.openCompletion');
 };
 const closeCompletion = async () => {
-  await invoke$1('EditorCompletion.close');
+  await invoke('EditorCompletion.close');
 };
 const openEditorContextMenu = async () => {
-  await invoke$1('Editor.handleContextMenu', 0, 0);
+  await invoke('Editor.handleContextMenu', 0, 0);
 };
 const invokeTabCompletion = async () => {
-  await invoke$1('Editor.tabCompletion');
+  await invoke('Editor.tabCompletion');
 };
 const executeTabCompletion = async () => {
-  await invoke$1('Editor.tabCompletion');
+  await invoke('Editor.tabCompletion');
 };
 const invokeBraceCompletion = async text => {
-  await invoke$1('Editor.braceCompletion', text);
+  await invoke('Editor.braceCompletion', text);
 };
 const cursorCharacterRight = async () => {
-  await invoke$1('Editor.cursorCharacterRight');
+  await invoke('Editor.cursorCharacterRight');
 };
 const cursorCharacterLeft = async () => {
-  await invoke$1('Editor.cursorCharacterLeft');
+  await invoke('Editor.cursorCharacterLeft');
 };
 const copyLineDown = async () => {
-  await invoke$1('Editor.copyLineDown');
+  await invoke('Editor.copyLineDown');
 };
 const cursorDown = async () => {
-  await invoke$1('Editor.cursorDown');
+  await invoke('Editor.cursorDown');
 };
 const selectDown$1 = async () => {
-  await invoke$1('Editor.selectDown');
+  await invoke('Editor.selectDown');
 };
 const selectLine = async () => {
-  await invoke$1('Editor.selectLine');
+  await invoke('Editor.selectLine');
 };
 const selectAllLeft = async () => {
-  await invoke$1('Editor.selectAllLeft');
+  await invoke('Editor.selectAllLeft');
 };
 const selectionGrow = async () => {
-  await invoke$1('Editor.selectionGrow');
+  await invoke('Editor.selectionGrow');
 };
 const selectAllRight = async () => {
-  await invoke$1('Editor.selectAllRight');
+  await invoke('Editor.selectAllRight');
 };
 const selectAllOccurrences = async () => {
-  await invoke$1('Editor.selectAllOccurrences');
+  await invoke('Editor.selectAllOccurrences');
 };
 const selectUp$1 = async () => {
-  await invoke$1('Editor.selectUp');
+  await invoke('Editor.selectUp');
 };
 const cursorUp = async () => {
-  await invoke$1('Editor.cursorUp');
+  await invoke('Editor.cursorUp');
 };
 const cursorWordLeft = async () => {
-  await invoke$1('Editor.cursorWordLeft');
+  await invoke('Editor.cursorWordLeft');
 };
 const selectWordLeft = async () => {
-  await invoke$1('Editor.selectWordLeft');
+  await invoke('Editor.selectWordLeft');
 };
 const selectWordRight = async () => {
-  await invoke$1('Editor.selectWordRight');
+  await invoke('Editor.selectWordRight');
 };
 const setText = async text => {
-  await invoke$1('Editor.setText', text);
+  await invoke('Editor.setText', text);
 };
 const deleteAll = async () => {
-  await invoke$1('Editor.deleteAll');
+  await invoke('Editor.deleteAll');
 };
 const selectCharacterLeft = async () => {
-  await invoke$1('Editor.selectCharacterLeft');
+  await invoke('Editor.selectCharacterLeft');
 };
 const selectCharacterRight = async () => {
-  await invoke$1('Editor.selectCharacterRight');
+  await invoke('Editor.selectCharacterRight');
 };
 const deleteCharacterLeft = async () => {
-  await invoke$1('Editor.deleteCharacterLeft');
+  await invoke('Editor.deleteCharacterLeft');
 };
 const deleteWordPartRight = async () => {
-  await invoke$1('Editor.deleteWordPartRight');
+  await invoke('Editor.deleteWordPartRight');
 };
 const deleteWordRight = async () => {
-  await invoke$1('Editor.deleteWordRight');
+  await invoke('Editor.deleteWordRight');
 };
 const deleteWordPartLeft = async () => {
-  await invoke$1('Editor.deleteWordPartLeft');
+  await invoke('Editor.deleteWordPartLeft');
 };
 const deleteWordLeft = async () => {
-  await invoke$1('Editor.deleteWordLeft');
+  await invoke('Editor.deleteWordLeft');
 };
 const deleteHorizontalRight = async () => {
-  await invoke$1('Editor.deleteHorizontalRight');
+  await invoke('Editor.deleteHorizontalRight');
 };
 const deleteCharacterRight = async () => {
-  await invoke$1('Editor.deleteCharacterRight');
+  await invoke('Editor.deleteCharacterRight');
 };
 const cursorWordRight = async () => {
-  await invoke$1('Editor.cursorWordRight');
+  await invoke('Editor.cursorWordRight');
 };
 const goToDefinition = async () => {
-  await invoke$1('Editor.goToDefinition');
+  await invoke('Editor.goToDefinition');
 };
 const openHover = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const goToTypeDefinition = async () => {
-  await invoke$1('Editor.goToTypeDefinition');
+  await invoke('Editor.goToTypeDefinition');
 };
 const type = async text => {
-  await invoke$1('Editor.type', text);
+  await invoke('Editor.type', text);
 };
 const findAllReferences = async () => {
-  await invoke$1('SideBar.show', 'References', /* focus */true);
+  await invoke$3('SideBar.show', 'References', /* focus */true);
 };
 const findAllImplementations = async () => {
-  await invoke$1('SideBar.show', 'Implementations', /* focus */true);
+  await invoke$3('SideBar.show', 'Implementations', /* focus */true);
 };
 const setSelections = async selections => {
-  await invoke$1('Editor.setSelections', selections);
+  await invoke('Editor.setSelections', selections);
 };
 const selectNextOccurrence = async () => {
-  await invoke$1('Editor.selectNextOccurrence');
+  await invoke('Editor.selectNextOccurrence');
 };
 const selectPreviousOccurrence = async () => {
-  await invoke$1('Editor.selectPreviousOccurrence');
+  await invoke('Editor.selectPreviousOccurrence');
 };
 const openFindWidget = async () => {
-  await invoke$1('Editor.openFind');
+  await invoke('Editor.openFind');
 };
 const setDeltaY$1 = async deltaY => {
-  await invoke$1('Editor.setDeltaY', deltaY);
+  await invoke('Editor.setDeltaY', deltaY);
 };
 const format = async () => {
-  await invoke$1('Editor.format');
+  await invoke('Editor.format');
 };
 const indentMore = async () => {
-  await invoke$1('Editor.indentMore');
+  await invoke('Editor.indentMore');
 };
 const indentLess = async () => {
-  await invoke$1('Editor.indentLess');
+  await invoke('Editor.indentLess');
 };
 const moveLineDown = async () => {
-  await invoke$1('Editor.moveLineDown');
+  await invoke('Editor.moveLineDown');
 };
 const pasteText = async text => {
-  await invoke$1('Editor.pasteText', text);
+  await invoke('Editor.pasteText', text);
 };
 const sortLinesAscending = async () => {
-  await invoke$1('Editor.sortLinesAscending');
+  await invoke('Editor.sortLinesAscending');
 };
 const typeWithAutoClosing = async text => {
-  await invoke$1('Editor.typeWithAutoClosing', text);
+  await invoke('Editor.typeWithAutoClosing', text);
 };
 const handleTab = async () => {
-  await invoke$1('Editor.handleTab');
+  await invoke('Editor.handleTab');
 };
 const unIndent = async () => {
-  await invoke$1('Editor.unIndent');
+  await invoke('Editor.unIndent');
 };
 const insertLineBreak = async () => {
-  await invoke$1('Editor.insertLineBreak');
+  await invoke('Editor.insertLineBreak');
 };
 const openSourceActions = async () => {
-  await invoke$1('Editor.showSourceActions2');
+  await invoke('Editor.showSourceActions2');
 };
 const sourceActionsSelectCurrent = async () => {
-  await invoke$1('EditorSourceActions.selectCurrent');
+  await invoke('EditorSourceActions.selectCurrent');
 };
 const openCompletionDetails = async () => {
-  await invoke$1('EditorCompletion.openDetails');
+  await invoke('EditorCompletion.openDetails');
 };
 const closeCompletionDetails = async () => {
-  await invoke$1('EditorCompletion.closeDetails');
+  await invoke('EditorCompletion.closeDetails');
 };
 const toggleCompletionDetails = async () => {
-  await invoke$1('EditorCompletion.toggleDetails');
+  await invoke('EditorCompletion.toggleDetails');
 };
 const organizeImports = async () => {
-  await invoke$1('Editor.organizeImports');
+  await invoke('Editor.organizeImports');
 };
 const addAllMissingImports = async () => {
-  await invoke$1('Editor.addAllMissingImports');
+  await invoke('Editor.addAllMissingImports');
 };
 const sortImports = async () => {
-  await invoke$1('Editor.sortImports');
+  await invoke('Editor.sortImports');
 };
 const toggleLineComment = async () => {
-  await invoke$1('Editor.toggleLineComment');
+  await invoke('Editor.toggleLineComment');
 };
 const toggleBlockComment = async () => {
-  await invoke$1('Editor.toggleBlockComment');
+  await invoke('Editor.toggleBlockComment');
 };
 const selectAll$1 = async () => {
-  await invoke$1('Editor.toggleBlockComment');
+  await invoke('Editor.toggleBlockComment');
 };
 const openColorPicker = async () => {
-  await invoke$1('Editor.openColorPicker');
+  await invoke('Editor.openColorPicker');
 };
 const openFind = async () => {
-  await invoke$1('Editor.openFind2');
+  await invoke('Editor.openFind2');
 };
 const deleteAllLeft = async () => {
-  await invoke$1('Editor.deleteAllLeft');
+  await invoke('Editor.deleteAllLeft');
 };
 const deleteAllRight = async () => {
-  await invoke$1('Editor.deleteAllRight');
+  await invoke('Editor.deleteAllRight');
 };
 const cursorWordPartLeft = async () => {
-  await invoke$1('Editor.cursorWordPartLeft');
+  await invoke('Editor.cursorWordPartLeft');
 };
 const cursorWordPartRight = async () => {
-  await invoke$1('Editor.cursorWordPartRight');
+  await invoke('Editor.cursorWordPartRight');
 };
 const cursorEnd = async () => {
-  await invoke$1('Editor.cursorEnd');
+  await invoke('Editor.cursorEnd');
 };
 const cursorHome = async () => {
-  await invoke$1('Editor.cursorHome');
+  await invoke('Editor.cursorHome');
 };
 const copyLineUp = async () => {
-  await invoke$1('Editor.copyLineUp');
+  await invoke('Editor.copyLineUp');
 };
 const copy$1 = async () => {
-  await invoke$1('Editor.copy');
+  await invoke('Editor.copy');
 };
 const closeColorPicker = async () => {
-  await invoke$1('Editor.closeColorPicker');
+  await invoke('Editor.closeColorPicker');
 };
 const openContextMenu$2 = async () => {
   const button = 0;
   const x = 0;
   const y = 0;
-  await invoke$1('Editor.contextMenu', button, x, y);
+  await invoke('Editor.contextMenu', button, x, y);
 };
 const getText = async () => {
-  return invoke$1('Editor.getText');
+  return invoke$3('Editor.getText');
 };
 const rename$2 = async () => {
-  await invoke$1('Editor.rename');
+  await invoke('Editor.rename');
 };
 const showHover = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const openRename = async () => {
-  await invoke$1('Editor.openRename');
+  await invoke('Editor.openRename');
 };
 const rename2 = async newName => {
   await openRename();
-  await invoke$1('EditorRename.handleInput', newName, Script);
-  await invoke$1('EditorRename.accept');
+  await invoke('EditorRename.handleInput', newName, Script);
+  await invoke('EditorRename.accept');
 };
 const growSelection = async () => {
-  await invoke$1('Editor.selectionGrow');
+  await invoke('Editor.selectionGrow');
 };
 const getSelections = async () => {
   const key = await getEditorKey();
-  return invoke$5('Editor.getSelections', key);
+  return invoke$8('Editor.getSelections', key);
 };
 const shouldHaveText = async expectedText => {
   const key = await getEditorKey();
-  const text = await invoke$5('Editor.getText', key);
+  const text = await invoke$8('Editor.getText', key);
   if (text !== expectedText) {
     throw new Error(`Expected editor to have text ${expectedText} but was ${text}`);
   }
 };
 const shouldHaveTokens = async expectedTokens => {
   const key = await getEditorKey();
-  const text = await invoke$5('Editor.getTokens', key);
+  const text = await invoke$8('Editor.getTokens', key);
   if (!areTokensEqual(text, expectedTokens)) {
     const stringifiedActual = JSON.stringify(text);
     const stringifiedExpected = JSON.stringify(expectedTokens);
@@ -3413,20 +3499,20 @@ const shouldHaveTokens = async expectedTokens => {
 };
 const shouldHaveSelections = async expectedSelections => {
   const key = await getEditorKey();
-  const selections = await invoke$5('Editor.getSelections', key);
+  const selections = await invoke$8('Editor.getSelections', key);
   if (!areSelectionsEqual(selections, expectedSelections)) {
     throw new Error(`Expected editor to have selections ${expectedSelections} but was ${selections}`);
   }
 };
 const undo = async () => {
-  await invoke$5('Editor.undo');
+  await invoke$8('Editor.undo');
 };
 const redo = async () => {
-  await invoke$5('Editor.redo');
+  await invoke$8('Editor.redo');
 };
 const shouldHaveDiagnostics = async expectedDiagnostics => {
   const key = await getEditorKey();
-  const diagnostics = await invoke$5('Editor.getDiagnostics', key);
+  const diagnostics = await invoke$8('Editor.getDiagnostics', key);
   if (!areDiagnosticsEqual(diagnostics, expectedDiagnostics)) {
     const stringifiedActual = JSON.stringify(diagnostics);
     const stringifiedExpected = JSON.stringify(expectedDiagnostics);
@@ -3434,14 +3520,14 @@ const shouldHaveDiagnostics = async expectedDiagnostics => {
   }
 };
 const shouldHaveDiagnosticProviderResult = async (expectedDiagnostics, editorId = 1) => {
-  const [languageId, text, uri] = await Promise.all([invoke$5('Editor.getLanguageId', editorId), invoke$5('Editor.getText', editorId), invoke$5('Editor.getUri', editorId)]);
+  const [languageId, text, uri] = await Promise.all([invoke$8('Editor.getLanguageId', editorId), invoke$8('Editor.getText', editorId), invoke$8('Editor.getUri', editorId)]);
   const textDocument = {
     documentId: editorId,
     languageId,
     text,
     uri
   };
-  const diagnostics = await invoke$3('Extensions.executeDiagnosticProvider', textDocument);
+  const diagnostics = await invoke$6('Extensions.executeDiagnosticProvider', textDocument);
   if (!areDiagnosticsEqual(diagnostics, expectedDiagnostics)) {
     const stringifiedActual = JSON.stringify(diagnostics);
     const stringifiedExpected = JSON.stringify(expectedDiagnostics);
@@ -3570,19 +3656,19 @@ const Editor = {
 };
 
 const selectIndex$6 = async index => {
-  await invoke$1('EditorCompletion.selectIndex', index);
+  await invoke('EditorCompletion.selectIndex', index);
 };
 const selectCurrentIndex$2 = async () => {
-  await invoke$1('EditorCompletion.selectCurrentIndex');
+  await invoke('EditorCompletion.selectCurrentIndex');
 };
 const close$4 = async () => {
-  await invoke$1('EditorCompletion.close');
+  await invoke('EditorCompletion.close');
 };
 const handleWheel$2 = async (deltaMode, deltaY) => {
-  await invoke$1('EditorCompletion.handleWheel', deltaMode, deltaY);
+  await invoke('EditorCompletion.handleWheel', deltaMode, deltaY);
 };
 const handlePointerdown = async (clientX, clientY) => {
-  await invoke$1('EditorCompletion.handlePointerdown', clientX, clientY);
+  await invoke('EditorCompletion.handlePointerdown', clientX, clientY);
 };
 
 const EditorCompletion = {
@@ -3594,10 +3680,10 @@ const EditorCompletion = {
 };
 
 const show$7 = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const close$3 = async () => {
-  await invoke$1('EditorHover.close');
+  await invoke('EditorHover.close');
 };
 
 const EditorHover = {
@@ -3606,13 +3692,13 @@ const EditorHover = {
 };
 
 const handleInput$6 = async value => {
-  await invoke$1('EditorRename.handleInput', value, Script);
+  await invoke('EditorRename.handleInput', value, Script);
 };
 const accept = async () => {
-  await invoke$1('EditorRename.accept');
+  await invoke('EditorRename.accept');
 };
 const cancel = async () => {
-  await invoke$1('EditorRename.cancel');
+  await invoke('EditorRename.cancel');
 };
 
 const EditorRename = {
@@ -3622,10 +3708,10 @@ const EditorRename = {
 };
 
 const selectIndex$5 = async index => {
-  await invoke$1('EditorSourceAction.selectIndex', index);
+  await invoke('EditorSourceAction.selectIndex', index);
 };
 const selectCurrentIndex$1 = async () => {
-  await invoke$1('EditorSourceAction.selectCurrentIndex');
+  await invoke('EditorSourceAction.selectCurrentIndex');
 };
 
 const EditorSourceAction = {
@@ -3634,158 +3720,158 @@ const EditorSourceAction = {
 };
 
 const openContextMenu$1 = async index => {
-  await invoke$1('Explorer.handleContextMenuKeyboard', index);
+  await invoke$1('Explorer', 'Explorer.handleContextMenuKeyboard', index);
 };
 const handleDragLeave = async () => {
-  await invoke$1('Explorer.handleDragLeave');
+  await invoke$1('Explorer', 'Explorer.handleDragLeave');
 };
 const handleBlur$2 = async () => {
-  await invoke$1('Explorer.handleBlur');
+  await invoke$1('Explorer', 'Explorer.handleBlur');
 };
 const handleEscape = async () => {
-  await invoke$1('Explorer.handleEscape');
+  await invoke$1('Explorer', 'Explorer.handleEscape');
 };
 const handleDropIndex = async (fileHandles, files, paths, index) => {
-  await invoke$1('Explorer.handleDropIndex', fileHandles, files, paths, index);
+  await invoke$1('Explorer', 'Explorer.handleDropIndex', fileHandles, files, paths, index);
 };
 const handleInputBlur = async () => {
-  await invoke$1('Explorer.handleInputBlur');
+  await invoke$1('Explorer', 'Explorer.handleInputBlur');
 };
 const focus$1 = async () => {
-  await invoke$1('Explorer.focusIndex', -1);
+  await invoke$1('Explorer', 'Explorer.focusIndex', -1);
 };
 const setDeltaY = async deltaY => {
-  await invoke$1('Explorer.setDeltaY', deltaY);
+  await invoke$1('Explorer', 'Explorer.setDeltaY', deltaY);
 };
 const focusNext$8 = async () => {
-  await invoke$1('Explorer.focusNext');
+  await invoke$1('Explorer', 'Explorer.focusNext');
 };
 const focusNone = async () => {
-  await invoke$1('Explorer.focusNone');
+  await invoke$1('Explorer', 'Explorer.focusNone');
 };
 const focusPrevious$8 = async () => {
-  await invoke$1('Explorer.focusPrevious');
+  await invoke$1('Explorer', 'Explorer.focusPrevious');
 };
 const selectUp = async () => {
-  await invoke$1('Explorer.selectUp');
+  await invoke$1('Explorer', 'Explorer.selectUp');
 };
 const handleDragOverIndex = async index => {
-  await invoke$1('Explorer.handleDragOverIndex', index);
+  await invoke$1('Explorer', 'Explorer.handleDragOverIndex', index);
 };
 const selectDown = async () => {
-  await invoke$1('Explorer.selectDown');
+  await invoke$1('Explorer', 'Explorer.selectDown');
 };
 const collapseAll$3 = async () => {
-  await invoke$1('Explorer.collapseAll');
+  await invoke$1('Explorer', 'Explorer.collapseAll');
 };
 const refresh$2 = async () => {
-  await invoke$1('Explorer.refresh');
+  await invoke$1('Explorer', 'Explorer.refresh');
 };
 const focusIndex$5 = async index => {
-  await invoke$1('Explorer.focusIndex', index);
+  await invoke$1('Explorer', 'Explorer.focusIndex', index);
 };
 const clickCurrent = async () => {
-  await invoke$1('Explorer.handleClickCurrent');
+  await invoke$1('Explorer', 'Explorer.handleClickCurrent');
 };
 const handleArrowLeft$2 = async () => {
-  await invoke$1('Explorer.handleArrowLeft');
+  await invoke$1('Explorer', 'Explorer.handleArrowLeft');
 };
 const handleArrowRight$2 = async () => {
-  await invoke$1('Explorer.handleArrowRight');
+  await invoke$1('Explorer', 'Explorer.handleArrowRight');
 };
 const focusLast$6 = async () => {
-  await invoke$1('Explorer.focusLast');
+  await invoke$1('Explorer', 'Explorer.focusLast');
 };
 const focusFirst$7 = async () => {
-  await invoke$1('Explorer.focusFirst');
+  await invoke$1('Explorer', 'Explorer.focusFirst');
 };
 const removeDirent = async () => {
-  await invoke$1('Explorer.removeDirent');
+  await invoke$1('Explorer', 'Explorer.removeDirent');
 };
 const expandRecursively = async () => {
-  await invoke$1('Explorer.expandRecursively');
+  await invoke$1('Explorer', 'Explorer.expandRecursively');
 };
 const newFile = async () => {
-  await invoke$1('Explorer.newFile');
+  await invoke$1('Explorer', 'Explorer.newFile');
 };
 const newFolder = async () => {
-  await invoke$1('Explorer.newFolder');
+  await invoke$1('Explorer', 'Explorer.newFolder');
 };
 const copyPath$1 = async () => {
-  await invoke$1('Explorer.copyPath');
+  await invoke$1('Explorer', 'Explorer.copyPath');
 };
 const copyRelativePath = async () => {
-  await invoke$1('Explorer.copyRelativePath');
+  await invoke$1('Explorer', 'Explorer.copyRelativePath');
 };
 const handleClick$3 = async index => {
-  await invoke$1('Explorer.handleClick', index);
+  await invoke$1('Explorer', 'Explorer.handleClick', index);
 };
 const handleClickAt$3 = async (preventDefault, button, ctrlKey, shiftKey, x, y) => {
-  await invoke$1('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
+  await invoke$1('Explorer', 'Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
 };
 const handleClickOpenFolder = async () => {
-  await invoke$1('Explorer.handleClickOpenFolder');
+  await invoke$1('Explorer', 'Explorer.handleClickOpenFolder');
 };
 const handleDoubleClick$1 = async (eventX, eventY) => {
-  await invoke$1('Explorer.handleDoubleClick', eventX, eventY);
+  await invoke$1('Explorer', 'Explorer.handleDoubleClick', eventX, eventY);
 };
 const handleDrop = async (x, y, fileIds, fileList) => {
-  await invoke$1('Explorer.handleDrop', x, y, fileIds, fileList);
+  await invoke$1('Explorer', 'Explorer.handleDrop', x, y, fileIds, fileList);
 };
 const handleKeyDown$1 = async (defaultPrevented, key) => {
-  await invoke$1('Explorer.handleKeyDown', defaultPrevented, key);
+  await invoke$1('Explorer', 'Explorer.handleKeyDown', defaultPrevented, key);
 };
 const rename$1 = async () => {
-  await invoke$1('Explorer.renameDirent');
+  await invoke$1('Explorer', 'Explorer.renameDirent');
 };
 const selectAll = async () => {
-  await invoke$1('Explorer.selectAll');
+  await invoke$1('Explorer', 'Explorer.selectAll');
 };
 const renameDirent = async () => {
-  await invoke$1('Explorer.renameDirent');
+  await invoke$1('Explorer', 'Explorer.renameDirent');
 };
 const cancelEdit = async () => {
-  await invoke$1('Explorer.cancelEdit');
+  await invoke$1('Explorer', 'Explorer.cancelEdit');
 };
 const acceptEdit = async () => {
-  await invoke$1('Explorer.acceptEdit');
+  await invoke$1('Explorer', 'Explorer.acceptEdit');
 };
 const updateEditingValue = async value => {
-  await invoke$1('Explorer.updateEditingValue', value);
+  await invoke$1('Explorer', 'Explorer.updateEditingValue', value);
 };
 const expandAll$1 = async () => {
-  await invoke$1('Explorer.expandAll');
+  await invoke$1('Explorer', 'Explorer.expandAll');
 };
 const handleDragOver = async (x, y) => {
-  await invoke$1('Explorer.handleDragOver', x, y);
+  await invoke$1('Explorer', 'Explorer.handleDragOver', x, y);
 };
 const handleCut = async () => {
-  await invoke$1('Explorer.handleCut');
+  await invoke$1('Explorer', 'Explorer.handleCut');
 };
 const handleCopy = async () => {
-  await invoke$1('Explorer.handleCopy');
+  await invoke$1('Explorer', 'Explorer.handleCopy');
 };
 const handlePaste = async () => {
-  await invoke$1('Explorer.handlePaste');
+  await invoke$1('Explorer', 'Explorer.handlePaste');
 };
 const selectIndices = async indices => {
-  await invoke$1('Explorer.selectIndices', indices);
+  await invoke$1('Explorer', 'Explorer.selectIndices', indices);
 };
 const toggleIndividualSelection = async index => {
-  await invoke$1('Explorer.toggleIndividualSelection', index);
+  await invoke$1('Explorer', 'Explorer.toggleIndividualSelection', index);
 };
 const restoreState = async savedState => {
   if (savedState === undefined) {
-    await invoke$1('Explorer.restoreState');
+    await invoke$1('Explorer', 'Explorer.restoreState');
     return;
   }
-  await invoke$1('Explorer.restoreState', savedState);
+  await invoke$1('Explorer', 'Explorer.restoreState', savedState);
 };
 const reveal = async uri => {
-  await invoke$1('Explorer.reveal', uri);
+  await invoke$1('Explorer', 'Explorer.reveal', uri);
 };
 const saveState = async () => {
-  return invoke$1('Explorer.saveState');
+  return invoke$3('Explorer.saveState');
 };
 
 const Explorer = {
@@ -3844,28 +3930,28 @@ const Explorer = {
 const addWebExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke$3('Extensions.addWebExtension', absolutePath);
-  await invoke$1('ExtensionMeta.addWebExtension', absolutePath);
+  await invoke$6('Extensions.addWebExtension', absolutePath);
+  await invoke$3('ExtensionMeta.addWebExtension', absolutePath);
 };
 const executeFormattingProvider = async (textDocument, ...args) => {
-  return invoke$3('Extensions.executeFormattingProvider', textDocument, ...args);
+  return invoke$6('Extensions.executeFormattingProvider', textDocument, ...args);
 };
 const executeCompletionProvider = async (textDocument, ...args) => {
-  return invoke$3('Extensions.executeCompletionProvider', textDocument, ...args);
+  return invoke$6('Extensions.executeCompletionProvider', textDocument, ...args);
 };
 const enableWorkspace = async id => {
-  await invoke$3('Extensions.enableWorkspace', id);
+  await invoke$6('Extensions.enableWorkspace', id);
 };
 const disableWorkspace$1 = async id => {
-  await invoke$3('Extensions.disableWorkspace', id);
+  await invoke$6('Extensions.disableWorkspace', id);
 };
 const addNodeExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke$1('ExtensionMeta.addNodeExtension', absolutePath);
+  await invoke$3('ExtensionMeta.addNodeExtension', absolutePath);
 };
 const activateByEvent = async (event, assetDir, platform) => {
-  await invoke$3('Extensions.activateByEvent', event, assetDir, platform);
+  await invoke$6('Extensions.activateByEvent', event, assetDir, platform);
 };
 
 const Extension = {
@@ -3889,28 +3975,28 @@ const createGithubRelease = (overrides = {}) => {
   };
 };
 const handleClickCategory = async categoryId => {
-  await invoke$1('ExtensionDetail.handleClickCategory', categoryId);
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.handleClickCategory', categoryId);
 };
 const handleReadmeContextMenu = async (x, y, nodeName, href) => {
-  await invoke$1('ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
 };
 const copyReadmeLink = async href => {
-  await invoke$1('ExtensionDetail.copyReadmeLink', href);
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.copyReadmeLink', href);
 };
 const handleClickEnable = async () => {
-  await invoke$1('ExtensionDetail.handleClickEnable');
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.handleClickEnable');
 };
 const handleClickDisable = async () => {
-  await invoke$1('ExtensionDetail.handleClickDisable');
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.handleClickDisable');
 };
 const handleClickSetColorTheme = async () => {
-  await invoke$1('ExtensionDetail.handleClickSetColorTheme');
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.handleClickSetColorTheme');
 };
 const selectFeature = name => {
-  return invoke$1('ExtensionDetail.selectFeature', name);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.selectFeature', name);
 };
 const selectTab$1 = name => {
-  return invoke$1('ExtensionDetail.selectTab', name);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.selectTab', name);
 };
 const selectDetails = async () => {
   await selectTab$1('Details');
@@ -3922,26 +4008,26 @@ const selectChangelog = async () => {
   await selectTab$1('Changelog');
 };
 const focusNextTab = async () => {
-  await invoke$1('ExtensionDetail.focusNextTab');
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.focusNextTab');
 };
 const focusPreviousTab = async () => {
-  await invoke$1('ExtensionDetail.focusPreviousTab');
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.focusPreviousTab');
 };
 const open$9 = extensionId => {
   const uri = `extension-detail://${extensionId}`;
-  return invoke$1('Main.openUri', uri);
+  return invoke$3('Main.openUri', uri);
 };
 const handleClickUninstall = () => {
-  return invoke$1('ExtensionDetail.handleClickUninstall');
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.handleClickUninstall');
 };
 const handleImageContextMenu = (x, y) => {
-  return invoke$1('ExtensionDetail.handleImageContextMenu', x, y);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.handleImageContextMenu', x, y);
 };
 const handleMarkdownImageError = src => {
-  return invoke$1('ExtensionDetail.handleMarkdownImageError', src);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.handleMarkdownImageError', src);
 };
 const openFeature = featureName => {
-  return invoke$1('ExtensionDetail.handleFeaturesClick', featureName);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.handleFeaturesClick', featureName);
 };
 const openThemes = async () => {
   await openFeature('Theme');
@@ -3962,19 +4048,19 @@ const openSettings = async () => {
   await openFeature('Settings');
 };
 const handleScroll$1 = async scrollTop => {
-  return invoke$1('ExtensionDetail.handleScroll', scrollTop);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.handleScroll', scrollTop);
 };
 const hideSizeLink = async () => {
-  return invoke$1('ExtensionDetail.hideSizeLink');
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.hideSizeLink');
 };
 const handleTabFocus = async tabName => {
-  return invoke$1('ExtensionDetail.handleTabFocus', tabName);
+  return invoke$1('ExtensionDetail', 'ExtensionDetail.handleTabFocus', tabName);
 };
 const handleClickSettings = async (x, y) => {
-  await invoke$1('ExtensionDetail.handleClickSettings', x, y);
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.handleClickSettings', x, y);
 };
 const mockGithubApi = async options => {
-  await invoke$1('ExtensionDetail.mockGithubApi', options);
+  await invoke$1('ExtensionDetail', 'ExtensionDetail.mockGithubApi', options);
 };
 const openGithubChangelog = async (extensionUri, extensionId, options) => {
   await addWebExtension(extensionUri);
@@ -4018,10 +4104,10 @@ const ExtensionDetail = {
 };
 
 const open$8 = async id => {
-  await invoke$1('SideBar.openViewlet', id);
+  await invoke$3('SideBar.openViewlet', id);
 };
 const hide$1 = async () => {
-  await invoke$1('Layout.hideSideBar');
+  await invoke$3('Layout.hideSideBar');
 };
 
 const SideBar = {
@@ -4030,71 +4116,71 @@ const SideBar = {
 };
 
 const acceptCompletion = async () => {
-  await invoke$1('Extensions.acceptCompletion');
+  await invoke$1('SearchExtensions', 'Extensions.acceptCompletion');
 };
 const closeSuggest = async () => {
-  await invoke$1('Extensions.closeSuggest');
+  await invoke$1('SearchExtensions', 'Extensions.closeSuggest');
 };
 const focusFirst$6 = async () => {
-  await invoke$1('Extensions.focusFirst');
+  await invoke$1('SearchExtensions', 'Extensions.focusFirst');
 };
 const focusLast$5 = async () => {
-  await invoke$1('Extensions.focusLast');
+  await invoke$1('SearchExtensions', 'Extensions.focusLast');
 };
 const focusNext$7 = async () => {
-  await invoke$1('Extensions.focusNext');
+  await invoke$1('SearchExtensions', 'Extensions.focusNext');
 };
 const focusPrevious$7 = async () => {
-  await invoke$1('Extensions.focusPrevious');
+  await invoke$1('SearchExtensions', 'Extensions.focusPrevious');
 };
 const open$7 = async () => {
   await open$8('Extensions');
 };
 const handleInput$5 = async (value, inputSource = Script$1, cursorOffset = value.length) => {
-  await invoke$1('Extensions.handleInput', value, inputSource, cursorOffset);
+  await invoke$1('SearchExtensions', 'Extensions.handleInput', value, inputSource, cursorOffset);
 };
 const handleBlur$1 = async () => {
-  await invoke$1('Extensions.handleBlur');
+  await invoke$1('SearchExtensions', 'Extensions.handleBlur');
 };
 const handleClick$2 = async index => {
-  await invoke$1('Extensions.handleClick', index);
+  await invoke$1('SearchExtensions', 'Extensions.handleClick', index);
 };
 const handleClickAt$2 = async (button, eventX, eventY, name) => {
-  await invoke$1('Extensions.handleClickAt', button, eventX, eventY, name);
+  await invoke$1('SearchExtensions', 'Extensions.handleClickAt', button, eventX, eventY, name);
 };
 const handleClickFilter = async () => {
-  await invoke$1('Extensions.handleClickFilter');
+  await invoke$1('SearchExtensions', 'Extensions.handleClickFilter');
 };
 const handleSettingsButtonClick = async index => {
-  await invoke$1('Extensions.handleSettingsButtonClick', index);
+  await invoke$1('SearchExtensions', 'Extensions.handleSettingsButtonClick', index);
 };
 const handleUninstall = async id => {
-  await invoke$1('Extensions.handleUninstall', id);
+  await invoke$1('SearchExtensions', 'Extensions.handleUninstall', id);
 };
 const handleContextMenu$6 = async (button, x, y) => {
-  await invoke$1('Extensions.handleContextMenu', button, x, y);
+  await invoke$1('SearchExtensions', 'Extensions.handleContextMenu', button, x, y);
 };
 const copyExtensionInfo = async () => {
-  await invoke$1('Extensions.copyExtensionInfo');
+  await invoke$1('SearchExtensions', 'Extensions.copyExtensionInfo');
 };
 const copyExtensionId = async () => {
-  await invoke$1('Extensions.copyExtensionId');
+  await invoke$1('SearchExtensions', 'Extensions.copyExtensionId');
 };
 const clearSearchResults$1 = async () => {
-  await invoke$1('Extensions.clearSearchResults');
+  await invoke$1('SearchExtensions', 'Extensions.clearSearchResults');
 };
 const selectNextCompletion = async () => {
-  await invoke$1('Extensions.selectNextCompletion');
+  await invoke$1('SearchExtensions', 'Extensions.selectNextCompletion');
 };
 const selectPreviousCompletion = async () => {
-  await invoke$1('Extensions.selectPreviousCompletion');
+  await invoke$1('SearchExtensions', 'Extensions.selectPreviousCompletion');
 };
 const setExtensionStatus = async (id, status, builtin) => {
   if (builtin === undefined) {
-    await invoke$1('Extensions.setExtensionStatus', id, status);
+    await invoke$1('SearchExtensions', 'Extensions.setExtensionStatus', id, status);
     return;
   }
-  await invoke$1('Extensions.setExtensionStatus', id, status, builtin);
+  await invoke$1('SearchExtensions', 'Extensions.setExtensionStatus', id, status, builtin);
 };
 
 const ExtensionSearch = {
@@ -4135,7 +4221,7 @@ const toFileUrl$1 = url => {
 
 const getDirents = async fileUrl => {
   const allDirents = [];
-  const dirents = await invoke$1('FileSystem.readDirWithFileTypes', fileUrl);
+  const dirents = await invoke$3('FileSystem.readDirWithFileTypes', fileUrl);
   for (const dirent of dirents) {
     if (dirent.type === Directory) {
       const subDirents = await getDirents(`${fileUrl}/${dirent.name}`);
@@ -4202,7 +4288,7 @@ const loadFixtureToMemFs = async fileMap => {
   await Promise.all(Object.entries(fileMap).map(entry => {
     const [path, content] = entry;
     const memfsPath = `memfs:///fixture/${path}`;
-    return invoke$1('FileSystem.writeFile', memfsPath, content);
+    return invoke$3('FileSystem.writeFile', memfsPath, content);
   }));
   return `memfs:///fixture`;
 };
@@ -4222,29 +4308,29 @@ const stringifyJson = data => {
 };
 
 const writeFile = async (uri, content) => {
-  await invoke$1('FileSystem.writeFile', uri, content);
+  await invoke$3('FileSystem.writeFile', uri, content);
 };
 const writeJson = async (uri, data) => {
   const content = stringifyJson(data);
   await writeFile(uri, content);
 };
 const readFile = async uri => {
-  return invoke$1('FileSystem.readFile', uri);
+  return invoke$3('FileSystem.readFile', uri);
 };
 const addFileHandle = async file => {
-  return invoke$1('FileSystem.addFileHandle', file);
+  return invoke$3('FileSystem.addFileHandle', file);
 };
 const registerFileHandle = async fileHandle => {
-  return invoke$1('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$3('FileSystemHandle.addFileHandle', fileHandle);
 };
 const getDirectoryHandle = async uri => {
-  return invoke$1('FileSystemHandle.getDirectoryHandle', uri);
+  return invoke$3('FileSystemHandle.getDirectoryHandle', uri);
 };
 const removeFileHandle = async id => {
-  await invoke$1('FileSystemHandle.removeFileHandle', id);
+  await invoke$3('FileSystemHandle.removeFileHandle', id);
 };
 const mkdir = async uri => {
-  return invoke$1('FileSystem.mkdir', uri);
+  return invoke$3('FileSystem.mkdir', uri);
 };
 const writeFiles = async files => {
   // TODO maybe have a method to send all the files to file system worker directly
@@ -4256,7 +4342,7 @@ const setFiles = async files => {
   await writeFiles(files);
 };
 const readDir = async uri => {
-  return invoke$1('FileSystem.readDirWithFileTypes', uri);
+  return invoke$3('FileSystem.readDirWithFileTypes', uri);
 };
 const getParentUri = uri => {
   const url = new URL(uri);
@@ -4299,25 +4385,25 @@ const shouldHaveFile = async (uri, expectedContent) => {
   }
 };
 const remove = async uri => {
-  await invoke$1('FileSystem.remove', uri);
+  await invoke$3('FileSystem.remove', uri);
 };
 const deleteFile = async uri => {
-  await invoke$1('FileSystem.deleteFile', uri);
+  await invoke$3('FileSystem.deleteFile', uri);
 };
 const rename = async (oldUri, newUri) => {
-  await invoke$1('FileSystem.rename', oldUri, newUri);
+  await invoke$3('FileSystem.rename', oldUri, newUri);
 };
 const setProviderError = async enabled => {
-  await invoke$1('FileSystemProvider.setError', enabled);
+  await invoke$3('FileSystemProvider.setError', enabled);
 };
 const setProviderInvalidData = async enabled => {
-  await invoke$1('FileSystemProvider.setInvalidData', enabled);
+  await invoke$3('FileSystemProvider.setInvalidData', enabled);
 };
 const setReadOnly = async (uri, readOnly) => {
-  await invoke$1('FileSystem.setReadOnly', uri, readOnly);
+  await invoke$3('FileSystem.setReadOnly', uri, readOnly);
 };
 const symlink = async (target, path) => {
-  await invoke$1('FileSystem.symlink', target, path);
+  await invoke$3('FileSystem.symlink', target, path);
 };
 const windowsPathRegex = /^[A-Za-z]:\//;
 const toFileUri = path => {
@@ -4331,7 +4417,7 @@ const toFileUri = path => {
   return `file://${normalizedPath}`;
 };
 const getTmpDirFileScheme = async () => {
-  const tmpFolder = await invoke$1('PlatformPaths.getTmpDir');
+  const tmpFolder = await invoke$3('PlatformPaths.getTmpDir');
   const tmpUri = toFileUri(tmpFolder);
   const uri = `${tmpUri}/test-${Date.now()}`;
   await mkdir(uri);
@@ -4346,17 +4432,17 @@ const getTmpDir = async ({
     case Memfs:
       return 'memfs:///workspace';
     default:
-      return invoke$1('PlatformPaths.getTmpDir');
+      return invoke$3('PlatformPaths.getTmpDir');
   }
 };
 const chmod = async (uri, permissions) => {
-  await invoke$1('FileSystem.chmod', uri, permissions);
+  await invoke$3('FileSystem.chmod', uri, permissions);
 };
 const createExecutable = async content => {
   const tmpDir = await getTmpDir({
     scheme: 'file'
   });
-  const nodePath = await invoke$1('PlatformPaths.getNodePath');
+  const nodePath = await invoke$3('PlatformPaths.getNodePath');
   const gitPath = `${tmpDir}/git`;
   await writeFile(gitPath, `#!${nodePath}
   ${content}`);
@@ -4364,9 +4450,9 @@ const createExecutable = async content => {
   return gitPath;
 };
 const createExecutableFrom = async uri => {
-  const testPath = await invoke$1('PlatformPaths.getTestPath');
+  const testPath = await invoke$3('PlatformPaths.getTestPath');
   const absolutePath = testPath + Slash + uri;
-  const content = await invoke$1('Ajax.getText', absolutePath);
+  const content = await invoke$3('Ajax.getText', absolutePath);
   return createExecutable(content);
 };
 const getOpfsRoot = async () => {
@@ -4378,7 +4464,7 @@ const createDroppedFileHandle = async () => {
     create: true
   });
   const file = await fileHandle.getFile();
-  const id = await invoke$1('FileSystemHandle.addFileHandle', fileHandle);
+  const id = await invoke$3('FileSystemHandle.addFileHandle', fileHandle);
   return {
     file,
     id
@@ -4425,49 +4511,49 @@ const FileSystem = {
 };
 
 const focusNext$6 = async () => {
-  await invoke$1('FindWidget.focusNext');
+  await invoke('FindWidget.focusNext');
 };
 const focusPrevious$6 = async () => {
-  await invoke$1('FindWidget.focusPrevious');
+  await invoke('FindWidget.focusPrevious');
 };
 const close$2 = async () => {
-  await invoke$1('FindWidget.close');
+  await invoke('FindWidget.close');
 };
 const setReplaceValue$1 = async value => {
-  await invoke$1('FindWidget.handleReplaceInput', value, Script);
+  await invoke('FindWidget.handleReplaceInput', value, Script);
 };
 const setValue$2 = async value => {
-  await invoke$1('FindWidget.handleInput', value, Script);
+  await invoke('FindWidget.handleInput', value, Script);
 };
 const toggleReplace$1 = async () => {
-  await invoke$1('FindWidget.toggleReplace');
+  await invoke('FindWidget.toggleReplace');
 };
 const toggleMatchCase$1 = async () => {
-  await invoke$1('FindWidget.toggleMatchCase');
+  await invoke('FindWidget.toggleMatchCase');
 };
 const toggleMatchWholeWord$1 = async () => {
-  await invoke$1('FindWidget.toggleMatchWholeWord');
+  await invoke('FindWidget.toggleMatchWholeWord');
 };
 const togglePreserveCase$1 = async () => {
-  await invoke$1('FindWidget.togglePreserveCase');
+  await invoke('FindWidget.togglePreserveCase');
 };
 const toggleUseRegularExpression$1 = async () => {
-  await invoke$1('FindWidget.toggleUseRegularExpression');
+  await invoke('FindWidget.toggleUseRegularExpression');
 };
 const replace = async () => {
-  await invoke$1('FindWidget.replace');
+  await invoke('FindWidget.replace');
 };
 const replaceAll$1 = async () => {
-  await invoke$1('FindWidget.replaceAll');
+  await invoke('FindWidget.replaceAll');
 };
 const focusElement = async whenExpression => {
-  await invoke$1('FindWidget.focusElement', whenExpression);
+  await invoke('FindWidget.focusElement', whenExpression);
 };
 const focusNextElement = async () => {
-  await invoke$1('FindWidget.focusNextElement');
+  await invoke('FindWidget.focusNextElement');
 };
 const focusPreviousElement = async () => {
-  await invoke$1('FindWidget.focusPreviousElement');
+  await invoke('FindWidget.focusPreviousElement');
 };
 
 const FindWidget = {
@@ -4690,7 +4776,7 @@ const Git = {
 };
 
 const setIconTheme = async id => {
-  await invoke$1('IconTheme.setIconTheme', id);
+  await invoke$3('IconTheme.setIconTheme', id);
 };
 
 const IconTheme = {
@@ -4698,19 +4784,19 @@ const IconTheme = {
 };
 
 const selectIndex$4 = async index => {
-  return invoke$1('IframeInspector.selectIndex', index);
+  return invoke$3('IframeInspector.selectIndex', index);
 };
 const focusNext$5 = async () => {
-  return invoke$1('IframeInspector.focusNext');
+  return invoke$3('IframeInspector.focusNext');
 };
 const focusPrevious$5 = async () => {
-  return invoke$1('IframeInspector.focusPrevious');
+  return invoke$3('IframeInspector.focusPrevious');
 };
 const focusFirst$5 = async () => {
-  return invoke$1('IframeInspector.focusFirst');
+  return invoke$3('IframeInspector.focusFirst');
 };
 const focusLast$4 = async () => {
-  return invoke$1('IframeInspector.focusLast');
+  return invoke$3('IframeInspector.focusLast');
 };
 
 const IframeInspector = {
@@ -4722,73 +4808,73 @@ const IframeInspector = {
 };
 
 const open$6 = async () => {
-  await invoke$1('Main.openUri', 'app://keybindings');
+  await invoke$1('MainArea', 'Main.openUri', 'app://keybindings');
 };
 const handleInput$4 = value => {
-  return invoke$1('KeyBindings.handleInput', value);
+  return invoke$1('KeyBindings', 'KeyBindings.handleInput', value);
 };
 const handleClick$1 = (x, y) => {
-  return invoke$1('KeyBindings.handleClick', x, y);
+  return invoke$1('KeyBindings', 'KeyBindings.handleClick', x, y);
 };
 const handleWheel$1 = (deltaMode, deltaY) => {
-  return invoke$1('KeyBindings.handleWheel', deltaMode, deltaY);
+  return invoke$1('KeyBindings', 'KeyBindings.handleWheel', deltaMode, deltaY);
 };
 const handleDoubleClick = (x, y) => {
-  return invoke$1('KeyBindings.handleDoubleClick', x, y);
+  return invoke$1('KeyBindings', 'KeyBindings.handleDoubleClick', x, y);
 };
 const focusNext$4 = () => {
-  return invoke$1('KeyBindings.focusNext');
+  return invoke$1('KeyBindings', 'KeyBindings.focusNext');
 };
 const focusPrevious$4 = () => {
-  return invoke$1('KeyBindings.focusPrevious');
+  return invoke$1('KeyBindings', 'KeyBindings.focusPrevious');
 };
 const focusFirst$4 = () => {
-  return invoke$1('KeyBindings.focusFirst');
+  return invoke$1('KeyBindings', 'KeyBindings.focusFirst');
 };
 const focusIndex$4 = index => {
-  return invoke$1('KeyBindings.focusIndex', index);
+  return invoke$1('KeyBindings', 'KeyBindings.focusIndex', index);
 };
 const focusLast$3 = () => {
-  return invoke$1('KeyBindings.focusLast');
+  return invoke$1('KeyBindings', 'KeyBindings.focusLast');
 };
 const toggleRecordingKeys = () => {
-  return invoke$1('KeyBindings.toggleRecordingKeys');
+  return invoke$1('KeyBindings', 'KeyBindings.toggleRecordingKeys');
 };
 const startRecordingKeys = () => {
-  return invoke$1('KeyBindings.startRecordingKeys');
+  return invoke$1('KeyBindings', 'KeyBindings.startRecordingKeys');
 };
 const clearInput = () => {
-  return invoke$1('KeyBindings.clearInput');
+  return invoke$1('KeyBindings', 'KeyBindings.clearInput');
 };
 const sortByPrecedence = () => {
-  return invoke$1('KeyBindings.sortByPrecedence');
+  return invoke$1('KeyBindings', 'KeyBindings.sortByPrecedence');
 };
 const stopRecordingKeys = () => {
-  return invoke$1('KeyBindings.stopRecordingKeys');
+  return invoke$1('KeyBindings', 'KeyBindings.stopRecordingKeys');
 };
 const handleContextMenu$5 = (button, x, y) => {
-  return invoke$1('KeyBindings.handleContextMenu', button, x, y);
+  return invoke$1('KeyBindings', 'KeyBindings.handleContextMenu', button, x, y);
 };
 const copyCommandId = () => {
-  return invoke$1('KeyBindings.copyCommandId');
+  return invoke$1('KeyBindings', 'KeyBindings.copyCommandId');
 };
 const copyCommandTitle = () => {
-  return invoke$1('KeyBindings.copyCommandTitle');
+  return invoke$1('KeyBindings', 'KeyBindings.copyCommandTitle');
 };
 const addKeyBinding = () => {
-  return invoke$1('KeyBindings.addKeyBinding');
+  return invoke$1('KeyBindings', 'KeyBindings.addKeyBinding');
 };
 const removeKeyBinding = () => {
-  return invoke$1('KeyBindings.removeKeyBinding');
+  return invoke$1('KeyBindings', 'KeyBindings.removeKeyBinding');
 };
 const changeWhenExpression = () => {
-  return invoke$1('KeyBindings.changeWhenExpression');
+  return invoke$1('KeyBindings', 'KeyBindings.changeWhenExpression');
 };
 const showSameKeyBindings = () => {
-  return invoke$1('KeyBindings.showSameKeyBindings');
+  return invoke$1('KeyBindings', 'KeyBindings.showSameKeyBindings');
 };
 const resetKeyBinding = () => {
-  return invoke$1('KeyBindings.resetKeyBinding');
+  return invoke$1('KeyBindings', 'KeyBindings.resetKeyBinding');
 };
 
 const KeyBindingsEditor = {
@@ -4879,7 +4965,7 @@ const press = async key => {
     cancelable: true,
     ...keyOptions
   };
-  await invoke('TestFrameWork.performKeyBoardAction', 'press', options);
+  await invoke$2('TestFrameWork.performKeyBoardAction', 'press', options);
 };
 
 const KeyBoard = {
@@ -4887,19 +4973,19 @@ const KeyBoard = {
 };
 
 const open$5 = async () => {
-  await invoke$1('Main.openUri', 'language-models:///1');
+  await invoke$1('MainArea', 'Main.openUri', 'language-models:///1');
 };
 const handleFilterInput$2 = async value => {
-  await invoke$1('LanguageModels.handleFilterInput', value);
+  await invoke$1('LanguageModels', 'LanguageModels.handleFilterInput', value);
 };
 const clearFilterInput = async () => {
-  await invoke$1('LanguageModels.clearFilterInput');
+  await invoke$1('LanguageModels', 'LanguageModels.clearFilterInput');
 };
 const addModel = async () => {
-  await invoke$1('LanguageModels.addModel');
+  await invoke$1('LanguageModels', 'LanguageModels.addModel');
 };
 const removeModel = async id => {
-  await invoke$1('LanguageModels.removeModel', id);
+  await invoke$1('LanguageModels', 'LanguageModels.removeModel', id);
 };
 
 const LanguageModels = {
@@ -4940,10 +5026,10 @@ const hideSecondarySideBar = async () => {
   await execute$1('Layout.hideSecondarySideBar');
 };
 const handleWorkspaceRefresh = async () => {
-  await invoke$1('Layout.handleWorkspaceRefresh');
+  await invoke$3('Layout.handleWorkspaceRefresh');
 };
 const handleExtensionsChanged = async () => {
-  await invoke$1('Layout.handleExtensionsChanged');
+  await invoke$3('Layout.handleExtensionsChanged');
 };
 
 const Layout = {
@@ -4959,10 +5045,10 @@ const Layout = {
 };
 
 const enableMemoryOpener = async () => {
-  await invoke$2('Open.enableMemoryOpener');
+  await invoke$4('Open.enableMemoryOpener');
 };
 const disableMemoryOpener = async () => {
-  await invoke$2('Open.disableMemoryOpener');
+  await invoke$4('Open.disableMemoryOpener');
 };
 const matchesExpectedText = (actualText, expectedText) => {
   if (typeof expectedText === 'string') {
@@ -4971,7 +5057,7 @@ const matchesExpectedText = (actualText, expectedText) => {
   return expectedText.test(actualText);
 };
 const shouldHaveUrl = async expectedText => {
-  const actualText = await invoke$2('Open.readOpenedUrl');
+  const actualText = await invoke$4('Open.readOpenedUrl');
   if (!matchesExpectedText(actualText, expectedText)) {
     throw new AssertionError(`expected opened url to be "${expectedText}" but was "${actualText}"`);
   }
@@ -4984,26 +5070,26 @@ const Open = {
 };
 
 const close$1 = async () => {
-  await invoke$1('Panel.handleClickClose');
+  await invoke$1('Panel', 'Panel.handleClickClose');
 };
 const hide = async () => {
-  await invoke$1('Layout.hidePanel');
+  await invoke$3('Layout.hidePanel');
 };
 const open$4 = async id => {
-  await invoke$1('Layout.showPanel', id);
+  await invoke$3('Layout.showPanel', id);
 };
 const openProblems = async () => {
   await open$4('Problems');
-  await invoke$1('Panel.selectIndex', 0);
+  await invoke$1('Panel', 'Panel.selectIndex', 0);
 };
 const select$1 = async name => {
-  await invoke$1('Panel.selectName', name);
+  await invoke$1('Panel', 'Panel.selectName', name);
 };
 const maximize = async () => {
-  await invoke$1('Layout.maximizePanel');
+  await invoke$3('Layout.maximizePanel');
 };
 const unmaximize = async () => {
-  await invoke$1('Layout.unmaximizePanel');
+  await invoke$3('Layout.unmaximizePanel');
 };
 
 const Panel = {
@@ -5018,19 +5104,19 @@ const Panel = {
 
 const show$6 = async () => {
   await open$4('Output');
-  await invoke$1('Panel.selectIndex', 1);
+  await invoke$1('Panel', 'Panel.selectIndex', 1);
 };
 const handleFilterInput$1 = async text => {
-  await invoke$1('Output.handleFilterInput', text, Script);
+  await invoke$1('Output', 'Output.handleFilterInput', text, Script);
 };
 const selectChannel = async channelId => {
-  await invoke$1('Output.selectChannel', channelId);
+  await invoke$1('Output', 'Output.selectChannel', channelId);
 };
 const clear$2 = async () => {
-  await invoke$1('Output.clear');
+  await invoke$1('Output', 'Output.clear');
 };
 const saveAs = async () => {
-  await invoke$1('Output.saveAs');
+  await invoke$1('Output', 'Output.saveAs');
 };
 
 const Output = {
@@ -5056,7 +5142,7 @@ const getIsFirefox = () => {
 };
 
 const getNodePath$1 = () => {
-  return invoke$1(/* Platform.getNodePath */'Platform.getNodePath');
+  return invoke$3(/* Platform.getNodePath */'Platform.getNodePath');
 };
 
 const getNodePath = () => {
@@ -5072,38 +5158,38 @@ const Platform = {
 };
 
 const open$3 = async uri => {
-  await invoke$1('Layout.showPreview', uri);
+  await invoke$3('Layout.showPreview', uri);
 };
 const handleClick = async hdId => {
-  await invoke$1('Preview.handleClick', hdId);
+  await invoke$3('Preview.handleClick', hdId);
 };
 const handleInput$3 = async (hdId, value) => {
-  await invoke$1('Preview.handleInput', hdId, value);
+  await invoke$3('Preview.handleInput', hdId, value);
 };
 const handleMouseDown = async (hdId, clientX, clientY) => {
-  await invoke$1('Preview.handleMouseDown', hdId, clientX, clientY);
+  await invoke$3('Preview.handleMouseDown', hdId, clientX, clientY);
 };
 const handleMouseUp = async (hdId, value, clientX, clientY) => {
-  await invoke$1('Preview.handleMouseUp', hdId, value, clientX, clientY);
+  await invoke$3('Preview.handleMouseUp', hdId, value, clientX, clientY);
 };
 const handleMouseMove = async (hdId, value, clientX, clientY) => {
-  await invoke$1('Preview.handleMouseMove', hdId, value, clientX, clientY);
+  await invoke$3('Preview.handleMouseMove', hdId, value, clientX, clientY);
 };
 const handleKeyDown = async (hdId, key, code) => {
-  await invoke$1('Preview.handleKeyDown', hdId, key, code);
+  await invoke$3('Preview.handleKeyDown', hdId, key, code);
 };
 const setUri = async uri => {
-  await invoke$1('Preview.setUri', uri);
+  await invoke$3('Preview.setUri', uri);
 };
 
 /**
  * @deprecated use waitForMutation instead
  */
 const waitForClick = async () => {
-  await invoke$1('Preview.waitForClick');
+  await invoke$3('Preview.waitForClick');
 };
 const waitForMutation = async () => {
-  await invoke$1('Preview.waitForMutation');
+  await invoke$3('Preview.waitForMutation');
 };
 
 const Preview = {
@@ -5121,43 +5207,43 @@ const Preview = {
 
 const invokeOptionalIndex = async (command, index) => {
   if (index === undefined) {
-    await invoke$1(command);
+    await invoke$3(command);
     return;
   }
-  await invoke$1(command, index);
+  await invoke$3(command, index);
 };
 const open$2 = async () => {
-  await invoke$1('Developer.openProcessExplorer');
+  await invoke$3('Developer.openProcessExplorer');
 };
 const refresh$1 = async () => {
-  await invoke$1('ProcessExplorer.refresh');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.refresh');
 };
 const collapseAll$2 = async () => {
-  await invoke$1('ProcessExplorer.collapseAll');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.collapseAll');
 };
 const expandAll = async () => {
-  await invoke$1('ProcessExplorer.expandAll');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.expandAll');
 };
 const focusFirst$3 = async () => {
-  await invoke$1('ProcessExplorer.focusFirst');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.focusFirst');
 };
 const focusLast$2 = async () => {
-  await invoke$1('ProcessExplorer.focusLast');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.focusLast');
 };
 const focusNext$3 = async () => {
-  await invoke$1('ProcessExplorer.focusNext');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.focusNext');
 };
 const focusPrevious$3 = async () => {
-  await invoke$1('ProcessExplorer.focusPrevious');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.focusPrevious');
 };
 const handleArrowLeft$1 = async () => {
-  await invoke$1('ProcessExplorer.handleArrowLeft');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.handleArrowLeft');
 };
 const handleArrowRight$1 = async () => {
-  await invoke$1('ProcessExplorer.handleArrowRight');
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.handleArrowRight');
 };
 const clickRow = async index => {
-  await invoke$1('ProcessExplorer.handleClickAt', index);
+  await invoke$1('ProcessExplorer', 'ProcessExplorer.handleClickAt', index);
 };
 const doubleClickRow = async index => {
   await invokeOptionalIndex('ProcessExplorer.handleDoubleClick', index);
@@ -5286,46 +5372,46 @@ const ProcessExplorer = {
 };
 
 const show$5 = async () => {
-  await invoke$1('Panel.selectIndex', 0);
+  await invoke$1('Panel', 'Panel.selectIndex', 0);
 };
 const handleActiveEditorChange = async activeUri => {
-  await invoke$1('Problems.handleActiveEditorChange', activeUri);
+  await invoke$1('Problems', 'Problems.handleActiveEditorChange', activeUri);
 };
 const handleBlur = async () => {
-  await invoke$1('Problems.handleBlur');
+  await invoke$1('Problems', 'Problems.handleBlur');
 };
 const handleClickMoreFilters = async (eventX, eventY) => {
-  await invoke$1('Problems.handleClickMoreFilters', eventX, eventY);
+  await invoke$1('Problems', 'Problems.handleClickMoreFilters', eventX, eventY);
 };
 const handleContextMenu$4 = async (eventX, eventY) => {
-  await invoke$1('Problems.handleContextMenu', eventX, eventY);
+  await invoke$1('Problems', 'Problems.handleContextMenu', eventX, eventY);
 };
 const handleFilterInput = async text => {
-  await invoke$1('Problems.handleFilterInput', text, Script);
+  await invoke$1('Problems', 'Problems.handleFilterInput', text, Script);
 };
 const copyMessage = async () => {
-  await invoke$1('Problems.copyMessage');
+  await invoke$1('Problems', 'Problems.copyMessage');
 };
 const focusIndex$3 = async index => {
-  await invoke$1('Problems.focusIndex', index);
+  await invoke$1('Problems', 'Problems.focusIndex', index);
 };
 const handleArrowLeft = async () => {
-  await invoke$1('Problems.handleArrowLeft');
+  await invoke$1('Problems', 'Problems.handleArrowLeft');
 };
 const handleArrowRight = async () => {
-  await invoke$1('Problems.handleArrowRight');
+  await invoke$1('Problems', 'Problems.handleArrowRight');
 };
 const handleClickAt$1 = async (x, y) => {
-  await invoke$1('Problems.handleClickAt', x, y);
+  await invoke$1('Problems', 'Problems.handleClickAt', x, y);
 };
 const handleIconThemeChange = async () => {
-  await invoke$1('Problems.handleIconThemeChange');
+  await invoke$1('Problems', 'Problems.handleIconThemeChange');
 };
 const viewAsList = async () => {
-  await invoke$1('Problems.viewAsList');
+  await invoke$1('Problems', 'Problems.viewAsList');
 };
 const viewAsTable = async () => {
-  await invoke$1('Problems.viewAsTable');
+  await invoke$1('Problems', 'Problems.viewAsTable');
 };
 
 const Problems = {
@@ -5353,7 +5439,7 @@ const registerCallbackCommand = async commandId => {
     resolve
   } = Promise.withResolvers();
   callbacks[id] = resolve;
-  await invoke$1(`Test.registerTestCommand`, commandId);
+  await invoke$3(`Test.registerTestCommand`, commandId);
   return {
     promise
   };
@@ -5362,31 +5448,31 @@ const registerCallbackCommand = async commandId => {
 const QuickPick$1 = 'QuickPick';
 
 const open$1 = async () => {
-  await invoke$1('Viewlet.openWidget', QuickPick$1, 'everything');
+  await invoke$3('Viewlet.openWidget', QuickPick$1, 'everything');
 };
 const handleInput$2 = async value => {
-  await invoke$1('QuickPick.handleInput', value, 0);
+  await invoke$1('QuickPick', 'QuickPick.handleInput', value, 0);
 };
 const handleClickAt = async (x, y) => {
-  await invoke$1('QuickPick.handleClickAt', x, y);
+  await invoke$1('QuickPick', 'QuickPick.handleClickAt', x, y);
 };
 const setValue$1 = async value => {
-  await invoke$1('QuickPick.setValue', value);
+  await invoke$1('QuickPick', 'QuickPick.setValue', value);
 };
 const focusNext$2 = async () => {
-  await invoke$1('QuickPick.focusNext');
+  await invoke$1('QuickPick', 'QuickPick.focusNext');
 };
 const focusFirst$2 = async () => {
-  await invoke$1('QuickPick.focusFirst');
+  await invoke$1('QuickPick', 'QuickPick.focusFirst');
 };
 const focusLast$1 = async () => {
-  await invoke$1('QuickPick.focusLast');
+  await invoke$1('QuickPick', 'QuickPick.focusLast');
 };
 const focusIndex$2 = async index => {
-  await invoke$1('QuickPick.focusIndex', index);
+  await invoke$1('QuickPick', 'QuickPick.focusIndex', index);
 };
 const focusPrevious$2 = async () => {
-  await invoke$1('QuickPick.focusPrevious');
+  await invoke$1('QuickPick', 'QuickPick.focusPrevious');
 };
 const ignoreSelectionFailure = async promise => {
   try {
@@ -5399,11 +5485,11 @@ const selectItem = async (label, {
   waitUntil = 'done'
 } = {}) => {
   if (waitUntil === 'done') {
-    await invoke$1('QuickPick.selectItem', label);
+    await invoke$1('QuickPick', 'QuickPick.selectItem', label);
     return;
   }
-  const visiblePromise = waitUntil === 'quickPick' ? invoke$1('QuickPick.waitUntilVisible') : undefined;
-  const promise = Promise.resolve(invoke$1('QuickPick.selectItem', label));
+  const visiblePromise = waitUntil === 'quickPick' ? invoke$1('QuickPick', 'QuickPick.waitUntilVisible') : undefined;
+  const promise = Promise.resolve(invoke$1('QuickPick', 'QuickPick.selectItem', label));
   if (waitUntil === 'none') {
     void ignoreSelectionFailure(promise);
     return;
@@ -5412,15 +5498,15 @@ const selectItem = async (label, {
   await visiblePromise;
 };
 const selectIndex$3 = async index => {
-  await invoke$1('QuickPick.selectIndex', index);
+  await invoke$1('QuickPick', 'QuickPick.selectIndex', index);
 };
 const selectCurrentIndex = async () => {
-  await invoke$1('QuickPick.selectCurrentIndex');
+  await invoke$1('QuickPick', 'QuickPick.selectCurrentIndex');
 };
 const executeCommand = async label => {
-  await invoke$1('QuickPick.showCommands');
-  await invoke$1('QuickPick.handleInput', label, 0);
-  await invoke$1('QuickPick.selectItem', label);
+  await invoke$1('QuickPick', 'QuickPick.showCommands');
+  await invoke$1('QuickPick', 'QuickPick.handleInput', label, 0);
+  await invoke$1('QuickPick', 'QuickPick.selectItem', label);
 };
 const selectItem2 = async ({
   callbackCommand,
@@ -5429,7 +5515,7 @@ const selectItem2 = async ({
   const {
     promise
   } = await registerCallbackCommand(callbackCommand);
-  await Promise.all([promise, invoke$1('QuickPick.selectItem', label)]);
+  await Promise.all([promise, invoke$1('QuickPick', 'QuickPick.selectItem', label)]);
 };
 
 const QuickPick = {
@@ -5450,13 +5536,13 @@ const QuickPick = {
 };
 
 const clear$1 = async () => {
-  return invoke$1('References.clear');
+  return invoke$3('References.clear');
 };
 const collapseAll$1 = async () => {
-  return invoke$1('References.collapseAll');
+  return invoke$3('References.collapseAll');
 };
 const refresh = async () => {
-  return invoke$1('References.refresh');
+  return invoke$3('References.refresh');
 };
 
 const References = {
@@ -5469,31 +5555,31 @@ const show$4 = async () => {
   await open$8('Run And Debug');
 };
 const handleClickSectionBreakPoints = async () => {
-  await invoke$1('Run And Debug.handleClickSectionBreakPoints');
+  await invoke$3('Run And Debug.handleClickSectionBreakPoints');
 };
 const handleClickSectionWatch = async () => {
-  await invoke$1('Run And Debug.handleClickSectionWatch');
+  await invoke$3('Run And Debug.handleClickSectionWatch');
 };
 const addWatchExpression = async expression => {
-  await invoke$1('Run And Debug.addWatchExpression', expression);
+  await invoke$3('Run And Debug.addWatchExpression', expression);
 };
 const handleWatchValueChange = async () => {
-  await invoke$1('Run And Debug.handleWatchValueChange');
+  await invoke$3('Run And Debug.handleWatchValueChange');
 };
 const acceptWatchExpressionEdit = async () => {
-  await invoke$1('Run And Debug.acceptWatchExpressionEdit');
+  await invoke$3('Run And Debug.acceptWatchExpressionEdit');
 };
 const selectIndex$2 = async index => {
-  await invoke$1('Run And Debug.selectIndex', index);
+  await invoke$3('Run And Debug.selectIndex', index);
 };
 const setPauseOnExceptions = async value => {
-  await invoke$1('Run And Debug.setPauseOnExceptions', value);
+  await invoke$3('Run And Debug.setPauseOnExceptions', value);
 };
 const handleRename = async () => {
-  await invoke$1('Run And Debug.handleRename');
+  await invoke$3('Run And Debug.handleRename');
 };
 const handleSpace = async () => {
-  await invoke$1('Run And Debug.handleSpace');
+  await invoke$3('Run And Debug.handleSpace');
 };
 
 const RunAndDebug = {
@@ -5510,28 +5596,28 @@ const RunAndDebug = {
 };
 
 const show$3 = async () => {
-  await invoke$1('Main.openUri', 'running-extensions:///1');
+  await invoke$1('MainArea', 'Main.openUri', 'running-extensions:///1');
 };
 const setExtensions = async extensions => {
-  await invoke$1('RunningExtensions.setExtensions', extensions);
+  await invoke$1('RunningExtensions', 'RunningExtensions.setExtensions', extensions);
 };
 const handleContextMenu$3 = async (index, x = 0, y = 0) => {
-  await invoke$1('RunningExtensions.handleContextMenu', index, x, y);
+  await invoke$1('RunningExtensions', 'RunningExtensions.handleContextMenu', index, x, y);
 };
 const copyId = async index => {
-  await invoke$1('RunningExtensions.copyId', index);
+  await invoke$1('RunningExtensions', 'RunningExtensions.copyId', index);
 };
 const disable = async index => {
-  await invoke$1('RunningExtensions.disable', index);
+  await invoke$1('RunningExtensions', 'RunningExtensions.disable', index);
 };
 const disableWorkspace = async index => {
-  await invoke$1('RunningExtensions.disableWorkspace', index);
+  await invoke$1('RunningExtensions', 'RunningExtensions.disableWorkspace', index);
 };
 const reportIssue = async index => {
-  await invoke$1('RunningExtensions.reportIssue', index);
+  await invoke$1('RunningExtensions', 'RunningExtensions.reportIssue', index);
 };
 const startProfile = async () => {
-  await invoke$1('RunningExtensions.startProfile');
+  await invoke$1('RunningExtensions', 'RunningExtensions.startProfile');
 };
 const root = () => {
   return createLocator('.RunningExtensions');
@@ -5605,115 +5691,115 @@ const show$2 = async () => {
   await open$8('Search');
 };
 const setValue = async value => {
-  await invoke$1('Search.handleInput', value, Script);
+  await invoke$1('TextSearch', 'Search.handleInput', value, Script);
 };
 const setReplaceValue = async value => {
-  await invoke$1('Search.handleReplaceInput', value, Script);
+  await invoke$1('TextSearch', 'Search.handleReplaceInput', value, Script);
 };
 const setExcludeValue = async value => {
-  await invoke$1('Search.handleExcludeInput', value, Script);
+  await invoke$1('TextSearch', 'Search.handleExcludeInput', value, Script);
 };
 const replaceAll = async () => {
-  await invoke$1('Search.replaceAll');
+  await invoke$1('TextSearch', 'Search.replaceAll');
 };
 const setIncludeValue = async value => {
-  await invoke$1('Search.handleIncludeInput', value, Script);
+  await invoke$1('TextSearch', 'Search.handleIncludeInput', value, Script);
 };
 const clearSearchResults = async () => {
-  await invoke$1('Search.clearSearchResults');
+  await invoke$1('TextSearch', 'Search.clearSearchResults');
 };
 const openDetails = async () => {
-  await invoke$1('Search.openDetails');
+  await invoke$1('TextSearch', 'Search.openDetails');
 };
 const collapseDetails = async () => {
-  await invoke$1('Search.collapseDetails');
+  await invoke$1('TextSearch', 'Search.collapseDetails');
 };
 const dismissItem = async () => {
-  await invoke$1('Search.dismissItem');
+  await invoke$1('TextSearch', 'Search.dismissItem');
 };
 const focusFirst$1 = async () => {
-  await invoke$1('Search.focusFirst');
+  await invoke$1('TextSearch', 'Search.focusFirst');
 };
 const focusIndex$1 = async index => {
-  await invoke$1('Search.focusIndex', index);
+  await invoke$1('TextSearch', 'Search.focusIndex', index);
 };
 const selectIndex$1 = async index => {
-  await invoke$1('Search.selectIndex', index);
+  await invoke$1('TextSearch', 'Search.selectIndex', index);
 };
 const focusNext$1 = async () => {
-  await invoke$1('Search.focusNext');
+  await invoke$1('TextSearch', 'Search.focusNext');
 };
 const handleWheel = async (deltaMode, deltaY) => {
-  await invoke$1('Search.handleWheel', deltaMode, deltaY);
+  await invoke$1('TextSearch', 'Search.handleWheel', deltaMode, deltaY);
 };
 const focusNextPage = async () => {
-  await invoke$1('Search.focusPage');
+  await invoke$1('TextSearch', 'Search.focusPage');
 };
 const focusPreviousPage = async () => {
-  await invoke$1('Search.focusPreviousPage');
+  await invoke$1('TextSearch', 'Search.focusPreviousPage');
 };
 const focusPrevious$1 = async () => {
-  await invoke$1('Search.focusPrevious');
+  await invoke$1('TextSearch', 'Search.focusPrevious');
 };
 const toggleSearchDetails = async () => {
-  await invoke$1('Search.toggleSearchDetails');
+  await invoke$1('TextSearch', 'Search.toggleSearchDetails');
 };
 const toggleMatchCase = async () => {
-  await invoke$1('Search.toggleMatchCase');
+  await invoke$1('TextSearch', 'Search.toggleMatchCase');
 };
 const toggleMatchWholeWord = async () => {
-  await invoke$1('Search.toggleMatchWholeWord');
+  await invoke$1('TextSearch', 'Search.toggleMatchWholeWord');
 };
 const togglePreserveCase = async () => {
-  await invoke$1('Search.togglePreserveCase');
+  await invoke$1('TextSearch', 'Search.togglePreserveCase');
 };
 const toggleUseRegularExpression = async () => {
-  await invoke$1('Search.toggleUseRegularExpression');
+  await invoke$1('TextSearch', 'Search.toggleUseRegularExpression');
 };
 const toggleReplace = async () => {
-  await invoke$1('Search.toggleReplace');
+  await invoke$1('TextSearch', 'Search.toggleReplace');
 };
 const open = async () => {
-  await invoke$1('SideBar.openViewlet', 'Search');
+  await invoke$3('SideBar.openViewlet', 'Search');
 };
 const setLimit = async limit => {
-  await invoke$1('Search.setLimit', limit);
+  await invoke$1('TextSearch', 'Search.setLimit', limit);
 };
 const handleListBlur = async () => {
-  await invoke$1('Search.handleListBlur');
+  await invoke$1('TextSearch', 'Search.handleListBlur');
 };
 const collapseAll = async () => {
-  await invoke$1('Search.collapseAll');
+  await invoke$1('TextSearch', 'Search.collapseAll');
 };
 const copy = async () => {
-  await invoke$1('Search.copy');
+  await invoke$1('TextSearch', 'Search.copy');
 };
 const copyPath = async () => {
-  await invoke$1('Search.copyPath');
+  await invoke$1('TextSearch', 'Search.copyPath');
 };
 const handleInputCut = async name => {
-  await invoke$1('Search.handleInputCut', name);
+  await invoke$1('TextSearch', 'Search.handleInputCut', name);
 };
 const handleInputPaste = async name => {
-  await invoke$1('Search.handleInputPaste', name);
+  await invoke$1('TextSearch', 'Search.handleInputPaste', name);
 };
 const handleInputCopy = async name => {
-  await invoke$1('Search.handleInputCopy', name);
+  await invoke$1('TextSearch', 'Search.handleInputCopy', name);
 };
 const handleInputSelectionChange = async (name, start, end) => {
-  await invoke$1('Search.handleInputSelectionChange', name, start, end);
+  await invoke$1('TextSearch', 'Search.handleInputSelectionChange', name, start, end);
 };
 const handleInputContextMenu = async (name, button, x, y) => {
-  await invoke$1('Search.handleInputConextMenu', name, button, x, y);
+  await invoke$1('TextSearch', 'Search.handleInputConextMenu', name, button, x, y);
 };
 const handleContextMenu$2 = async (button, x, y) => {
-  await invoke$1('Search.handleContextMenu', button, x, y);
+  await invoke$1('TextSearch', 'Search.handleContextMenu', button, x, y);
 };
 const enableRenderFolderPaths = async () => {
-  await invoke$1('Search.enableRenderFolderPaths');
+  await invoke$1('TextSearch', 'Search.enableRenderFolderPaths');
 };
 const disableRenderFolderPaths = async () => {
-  await invoke$1('Search.disableRenderFolderPaths');
+  await invoke$1('TextSearch', 'Search.disableRenderFolderPaths');
 };
 
 const Search = {
@@ -5758,25 +5844,25 @@ const Search = {
 };
 
 const show$1 = async () => {
-  return invoke$1('Main.openUri', 'settings://');
+  return invoke$3('Main.openUri', 'settings://');
 };
 const handleInput$1 = async searchValue => {
-  return invoke$1('Settings.handleInput', searchValue, Script);
+  return invoke$1('Settings', 'Settings.handleInput', searchValue, Script);
 };
 const usePreviousSearchValue = async () => {
-  return invoke$1('Settings.usePreviousSearchValue');
+  return invoke$1('Settings', 'Settings.usePreviousSearchValue');
 };
 const useNextSearchValue = async () => {
-  return invoke$1('Settings.useNextSearchValue');
+  return invoke$1('Settings', 'Settings.useNextSearchValue');
 };
 const clear = async searchValue => {
-  return invoke$1('Settings.clear', searchValue, Script);
+  return invoke$1('Settings', 'Settings.clear', searchValue, Script);
 };
 const clearHistory = async () => {
-  return invoke$1('Settings.clearHistory');
+  return invoke$1('Settings', 'Settings.clearHistory');
 };
 const selectTab = async tabId => {
-  return invoke$1('Settings.handleClickTab', tabId);
+  return invoke$1('Settings', 'Settings.handleClickTab', tabId);
 };
 const selectWorkspace = async () => {
   await selectTab('workspace');
@@ -5791,10 +5877,10 @@ const selectWindow = async () => {
   await selectTab('window');
 };
 const handleScroll = async scrollTop => {
-  await invoke$1('Settings.handleScroll', scrollTop, Script);
+  await invoke$1('Settings', 'Settings.handleScroll', scrollTop, Script);
 };
 const handleClickFilterButton = async (x, y) => {
-  await invoke$1('Settings.handleClickFilterButton', x, y);
+  await invoke$1('Settings', 'Settings.handleClickFilterButton', x, y);
 };
 
 const SettingsView = {
@@ -5814,19 +5900,19 @@ const SettingsView = {
 };
 
 const selectIndex = async index => {
-  await invoke$1('Source Control.selectIndex', index);
+  await invoke$1('SourceControl', 'Source Control.selectIndex', index);
 };
 const acceptInput = async () => {
-  await invoke$1('Source Control.acceptInput');
+  await invoke$1('SourceControl', 'Source Control.acceptInput');
 };
 const handleInput = async text => {
-  await invoke$1('Source Control.handleInput', text, Script$1);
+  await invoke$1('SourceControl', 'Source Control.handleInput', text, Script$1);
 };
 const handleClickSourceControlButtons = async (index, name) => {
-  await invoke$1('Source Control.handleClickSourceControlButtons', index, name);
+  await invoke$1('SourceControl', 'Source Control.handleClickSourceControlButtons', index, name);
 };
 const handleContextMenu$1 = async (button, x, y) => {
-  await invoke$1('Source Control.handleContextMenu', button, x, y);
+  await invoke$1('SourceControl', 'Source Control.handleContextMenu', button, x, y);
 };
 const show = async () => {
   await open$8('Source Control');
@@ -5842,7 +5928,7 @@ const SourceControl = {
 };
 
 const update = async () => {
-  await invoke$1('StatusBar.updateStatusBarItems');
+  await invoke$1('StatusBar', 'StatusBar.updateStatusBarItems');
 };
 
 const StatusBar = {
@@ -5850,61 +5936,61 @@ const StatusBar = {
 };
 
 const closeMenu = async () => {
-  await invoke$1('TitleBar.closeMenu');
+  await invoke$1('TitleBar', 'TitleBar.closeMenu');
 };
 const focus = async () => {
-  await invoke$1('TitleBar.focus');
+  await invoke$1('TitleBar', 'TitleBar.focus');
 };
 const focusFirst = async () => {
-  await invoke$1('TitleBar.focusFirst');
+  await invoke$1('TitleBar', 'TitleBar.focusFirst');
 };
 const setTitleTemplate = async template => {
-  await invoke$1('TitleBar.setTitleTemplate', template);
+  await invoke$1('TitleBar', 'TitleBar.setTitleTemplate', template);
 };
 const focusIndex = async index => {
-  await invoke$1('TitleBar.focusIndex', index);
+  await invoke$1('TitleBar', 'TitleBar.focusIndex', index);
 };
 const focusLast = async () => {
-  await invoke$1('TitleBar.focusLast');
+  await invoke$1('TitleBar', 'TitleBar.focusLast');
 };
 const focusNext = async () => {
-  await invoke$1('TitleBar.focusNext');
+  await invoke$1('TitleBar', 'TitleBar.focusNext');
 };
 const focusPrevious = async () => {
-  await invoke$1('TitleBar.focusPrevious');
+  await invoke$1('TitleBar', 'TitleBar.focusPrevious');
 };
 const handleKeyArrowDown = async () => {
-  await invoke$1('TitleBar.handleKeyArrowDown');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyArrowDown');
 };
 const handleKeyArrowLeft = async () => {
-  await invoke$1('TitleBar.handleKeyArrowLeft');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyArrowLeft');
 };
 const handleKeyArrowRight = async () => {
-  await invoke$1('TitleBar.handleKeyArrowRight');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyArrowRight');
 };
 const handleKeyArrowUp = async () => {
-  await invoke$1('TitleBar.handleKeyArrowUp');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyArrowUp');
 };
 const handleKeyEnd = async () => {
-  await invoke$1('TitleBar.handleKeyEnd');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyEnd');
 };
 const handleKeyHome = async () => {
-  await invoke$1('TitleBar.handleKeyHome');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyHome');
 };
 const handleKeySpace = async () => {
-  await invoke$1('TitleBar.handleKeySpace');
+  await invoke$1('TitleBar', 'TitleBar.handleKeySpace');
 };
 const handleKeyEscape = async () => {
-  await invoke$1('TitleBar.handleKeyEscape');
+  await invoke$1('TitleBar', 'TitleBar.handleKeyEscape');
 };
 const toggleIndex = async index => {
-  await invoke$1('TitleBar.toggleIndex', index);
+  await invoke$1('TitleBar', 'TitleBar.toggleIndex', index);
 };
 const toggleMenu = async () => {
-  await invoke$1('TitleBar.toggleMenu');
+  await invoke$1('TitleBar', 'TitleBar.toggleMenu');
 };
 const handleContextMenu = async (button, x, y) => {
-  await invoke$1('TitleBar.handleContextMenu', button, x, y);
+  await invoke$1('TitleBar', 'TitleBar.handleContextMenu', button, x, y);
 };
 
 const TitleBarMenuBar = {
@@ -5958,7 +6044,7 @@ const getPortTuple = () => {
 
 // TODO ask webview worker directly
 const getWebViewInfo = async webViewId => {
-  const info = await invoke$1('WebView.getWebViewInfo2', webViewId);
+  const info = await invoke$3('WebView.getWebViewInfo2', webViewId);
   return info;
 };
 
@@ -6022,7 +6108,7 @@ const WebView = {
 };
 
 const setPath = async path => {
-  await invoke$1('Workspace.setPath', path);
+  await invoke$3('Workspace.setPath', path);
 };
 const openTmpDir = async () => {
   const tmpDir = await getTmpDir();
@@ -6030,7 +6116,7 @@ const openTmpDir = async () => {
   return tmpDir;
 };
 const close = async () => {
-  await invoke$1('Workspace.close');
+  await invoke$3('Workspace.close');
 };
 
 const Workspace = {
@@ -6040,13 +6126,13 @@ const Workspace = {
 };
 
 const load = async url => {
-  await invoke$1('Audio.load', url);
+  await invoke$3('Audio.load', url);
 };
 const play = async url => {
-  await invoke$1('Audio.play', url);
+  await invoke$3('Audio.play', url);
 };
 const pause = async () => {
-  await invoke$1('Audio.pause');
+  await invoke$3('Audio.pause');
 };
 
 const Audio = {
@@ -6163,7 +6249,11 @@ const getAutoFixProperties = error => {
 const executeTest2 = async (name, fn, globals, timestampGenerator) => {
   const getTimestamp = timestampGenerator;
   const start = getTimestamp();
-  const error = await callFunction(fn, globals);
+  let error = await callFunction(fn, globals);
+  if (isEnabled()) {
+    const cleanupError = await callFunction(disableMemoryClipBoard, undefined);
+    error ||= cleanupError;
+  }
   const end = getTimestamp();
   const duration = end - start;
   const formattedDuration = formatDuration(duration);
@@ -6211,7 +6301,7 @@ const formatPreparedError = preparedError => {
 };
 const printTestError = async error => {
   try {
-    const preparedError = await invoke$4(prepareError, error, {
+    const preparedError = await invoke$7(prepareError, error, {
       ignoredCodeFrameStackLines
     });
     const formatted = formatPreparedError(preparedError);
@@ -6243,10 +6333,10 @@ const executeTest = async (name, fn, globals = {}) => {
     console.info(`PASS ${name} in ${formattedDuration}`);
   }
   if (overlayActions && overlayActions.length > 0) {
-    await invoke('TestFrameWork.showOverlay', type, background, text, overlayActions);
+    await invoke$2('TestFrameWork.showOverlay', type, background, text, overlayActions);
     return;
   }
-  await invoke('TestFrameWork.showOverlay', type, background, text);
+  await invoke$2('TestFrameWork.showOverlay', type, background, text);
 };
 
 const hotReloadEnabled = async () => {
@@ -6343,7 +6433,7 @@ const watchForHotReload = async (platform, href) => {
   }
   const fileUrl = getFileUri(href);
   const callbackCommand = 'FileWatcher.handleEvent';
-  await invoke$1('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
+  await invoke$3('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
 };
 
 const toErrorMessage = error => {
@@ -6433,8 +6523,8 @@ const executeAllTest = async (importedTest, globals) => {
     if (!test) {
       return getMissingTestResult(item.name);
     }
-    await invoke$1('Layout.reset');
-    await execute$1('ActivityBar.resize', {
+    await invoke$3('Layout.reset');
+    await invoke$1('ActivityBar', 'ActivityBar.resize', {
       height: 336,
       width: 48,
       x: 0,
@@ -6484,7 +6574,7 @@ const showAllTestsOverlay = async (results, duration) => {
     background = 'red';
   }
   const text = `${getSummaryParts(results).join(', ')} in ${formatDuration(duration)}`;
-  await invoke('TestFrameWork.showOverlay', type, background, text);
+  await invoke$2('TestFrameWork.showOverlay', type, background, text);
 };
 
 // TODO move this into three steps:
@@ -6527,7 +6617,7 @@ const execute = async (href, platform, assetDir) => {
   } catch (error) {
     clear$3();
     await printTestError(error);
-    await invoke('TestFrameWork.showOverlay', Fail, 'red', `test failed: ${error}`);
+    await invoke$2('TestFrameWork.showOverlay', Fail, 'red', `test failed: ${error}`);
     return;
   } finally {
     push({
@@ -6564,7 +6654,7 @@ const executeAll = async (tests, href, platform, assetDir) => {
   }
   const end = now();
   await showAllTestsOverlay(results, end - start);
-  await invoke('TestFrameWork.showTestResults', JSON.stringify(roundTestResults(results)));
+  await invoke$2('TestFrameWork.showTestResults', JSON.stringify(roundTestResults(results)));
   push({
     assetDir,
     inProgress: false,
@@ -6993,7 +7083,7 @@ const initializeRendererWorker = async () => {
 };
 
 const listen = async () => {
-  await Promise.all([initializeEditorWorker(), initializeErrorWorker(), initializeExtensionManagementWorker(), initializeOpenerWorker(), initializeRendererWorker()]);
+  await Promise.all([initializeEditorWorker(), initializeErrorWorker(), initializeExtensionManagementWorker(), initializeMainAreaWorker(), initializeOpenerWorker(), initializeRendererWorker()]);
 };
 
 const main = async () => {