@lvce-editor/test-worker 13.18.0 → 13.19.0

package/dist/testWorkerMain.js

@@ -510,6 +510,27 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute$2 = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks$1 = Object.create(null);
 const get$2 = id => {
@@ -534,12 +555,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -695,56 +716,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$4 = (message, result) => {
+const create$9 = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$4(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -774,35 +795,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -825,36 +846,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute$2 = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$t = (method, params) => {
+
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$s = (id, method, params) => {
+
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -863,15 +865,14 @@ const create$s = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$r = () => {
+const create$6 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$r();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -883,13 +884,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$s(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -925,12 +925,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$t(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -945,6 +946,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute$2;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -953,6 +955,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -962,7 +965,40 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-/* eslint-disable @typescript-eslint/no-misused-promises */
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
 
 const createSharedLazyRpc = factory => {
   let rpcPromise;
@@ -991,23 +1027,22 @@ const createSharedLazyRpc = factory => {
     }
   };
 };
-const create$j = async ({
+
+const create$3 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$3({
+    return create$4({
       commandMap,
       isMessagePortOpen,
       send
     });
   });
 };
-const LazyTransferMessagePortRpcParent = {
-  create: create$j
-};
-const create$e = async ({
+
+const create$2 = async ({
   commandMap,
   isMessagePortOpen,
   messagePort
@@ -1023,43 +1058,8 @@ const create$e = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const MessagePortRpcParent = {
-  create: create$e
-};
-const create$5 = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
-};
-const create$3 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$5({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
-};
-const create$2 = async ({
+
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1069,9 +1069,7 @@ const create$2 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  create: create$2
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1092,18 +1090,6 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const Directory = 3;
-
-const Script$1 = 2;
-
-const Web = 1;
-const Remote = 3;
-
-const EditorWorker = 99;
-const OpenerWorker = 4561;
-const RendererWorker = 1;
-const TestWorker = 9001;
-
 const rpcs = Object.create(null);
 const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1152,6 +1138,18 @@ const create = rpcId => {
   };
 };
 
+const Directory = 3;
+
+const Script$1 = 2;
+
+const Web = 1;
+const Remote = 3;
+
+const EditorWorker = 99;
+const OpenerWorker = 4561;
+const RendererWorker = 1;
+const TestWorker = 9001;
+
 const {
   invoke: invoke$2,
   set: set$3
@@ -1159,8 +1157,13 @@ const {
 
 const {
   invoke: invoke$1,
-  invokeAndTransfer,
   set: set$2
+} = create(OpenerWorker);
+
+const {
+  invoke,
+  invokeAndTransfer,
+  set: set$1
 } = create(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
@@ -1171,22 +1174,17 @@ const sendMessagePortToOpenerWorker = async (port, rpcId) => {
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
 };
 const readFile$1 = async uri => {
-  return invoke$1('FileSystem.readFile', uri);
+  return invoke('FileSystem.readFile', uri);
 };
 const getPreference = async key => {
-  return await invoke$1('Preferences.get', key);
+  return await invoke('Preferences.get', key);
 };
 
-const {
-  invoke,
-  set: set$1
-} = create(OpenerWorker);
-
 const send$1 = async port => {
   await sendMessagePortToEditorWorker(port, TestWorker);
 };
 const initializeEditorWorker = async () => {
-  const rpc = await LazyTransferMessagePortRpcParent.create({
+  const rpc = await create$3({
     commandMap: {},
     send: send$1
   });
@@ -1197,11 +1195,11 @@ const send = async port => {
   await sendMessagePortToOpenerWorker(port, TestWorker);
 };
 const initializeOpenerWorker = async () => {
-  const rpc = await LazyTransferMessagePortRpcParent.create({
+  const rpc = await create$3({
     commandMap: {},
     send
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 class AssertionError extends Error {
@@ -1224,7 +1222,7 @@ const getLocatorInvoke = locator => {
     const module = get(locator.webViewId);
     return module.invoke;
   }
-  return invoke$1;
+  return invoke;
 };
 
 const locatorInvoke = async (locator, method, ...params) => {
@@ -1373,7 +1371,6 @@ const toHaveJSProperty = async (locator, options) => {
   return `expected ${locatorString} to have js property ${key} ${value} but was ${actual}`;
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const getFunction = fnName => {
   switch (fnName) {
     case 'toBeFocused':
@@ -1405,7 +1402,6 @@ const getFunction = fnName => {
   }
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const string = (value, message) => {
   if (typeof value !== 'string') {
     throw new TypeError(message);
@@ -1417,8 +1413,6 @@ const number = (value, message) => {
   }
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error, @typescript-eslint/prefer-readonly-parameter-types */
-
 const expect$1 = locator => {
   return new Expect(locator);
 };
@@ -1554,7 +1548,6 @@ const performAction = async (locator, action, options) => {
   return invoke('TestFrameWork.performAction', locator, action, options);
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const toButtonNumber = buttonType => {
   switch (buttonType) {
     case 'left':
@@ -1640,29 +1633,29 @@ const skipTest = async id => {
   const state = 'skip';
   const background = 'yellow';
   const text = `test skipped ${id}`;
-  await invoke$1('TestFrameWork.showOverlay', state, background, text);
+  await invoke('TestFrameWork.showOverlay', state, background, text);
 };
 const {
   expect
 } = Expect$1;
 
 const show$7 = async () => {
-  return invoke$1('About.showAbout');
+  return invoke('About.showAbout');
 };
 const handleClickOk = async () => {
-  return invoke$1('About.handleClickOk');
+  return invoke('About.handleClickOk');
 };
 const handleClickClose$1 = async () => {
-  return invoke$1('About.handleClickClose');
+  return invoke('About.handleClickClose');
 };
 const handleClickCopy = async () => {
-  return invoke$1('About.handleClickCopy');
+  return invoke('About.handleClickCopy');
 };
 const focusNext$9 = async () => {
-  return invoke$1('About.focusNext');
+  return invoke('About.focusNext');
 };
 const focusPrevious$8 = async () => {
-  return invoke$1('About.focusPrevious');
+  return invoke('About.focusPrevious');
 };
 
 const About = {
@@ -1674,42 +1667,41 @@ const About = {
   show: show$7
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const focus$2 = async () => {
-  await invoke$1('ActivityBar.focus');
+  await invoke('ActivityBar.focus');
 };
 const toggleActivityBarItem = async id => {
-  await invoke$1('ActivityBar.toggleActivityBarItem', id);
+  await invoke('ActivityBar.toggleActivityBarItem', id);
 };
 const focusFirst$7 = async () => {
-  await invoke$1('ActivityBar.focusFirst');
+  await invoke('ActivityBar.focusFirst');
 };
 const setAccountEnabled = async enabled => {
-  await invoke$1('ActivityBar.setAccountEnabled', enabled);
+  await invoke('ActivityBar.setAccountEnabled', enabled);
 };
 const focusLast$6 = async () => {
-  await invoke$1('ActivityBar.focusLast');
+  await invoke('ActivityBar.focusLast');
 };
 const focusNext$8 = async () => {
-  await invoke$1('ActivityBar.focusNext');
+  await invoke('ActivityBar.focusNext');
 };
 const focusPrevious$7 = async () => {
-  await invoke$1('ActivityBar.focusPrevious');
+  await invoke('ActivityBar.focusPrevious');
 };
 const handleClick$4 = async index => {
-  await invoke$1('ActivityBar.handleClick', index);
+  await invoke('ActivityBar.handleClick', index);
 };
 const handleContextMenu$5 = async () => {
-  await invoke$1('ActivityBar.handleContextMenu');
+  await invoke('ActivityBar.handleContextMenu');
 };
 const setUpdateState = async config => {
-  await invoke$1('ActivityBar.setUpdateState', config);
+  await invoke('ActivityBar.setUpdateState', config);
 };
 const selectCurrent = async () => {
-  await invoke$1('ActivityBar.selectCurrent');
+  await invoke('ActivityBar.selectCurrent');
 };
 const handleClickSettings$1 = async (x, y) => {
-  await invoke$1('ActivityBar.handleClickSettings', x, y);
+  await invoke('ActivityBar.handleClickSettings', x, y);
 };
 
 const ActivityBar = {
@@ -1728,62 +1720,61 @@ const ActivityBar = {
 };
 
 const execute$1 = async (id, ...args) => {
-  return invoke$1(id, ...args);
+  return invoke(id, ...args);
 };
 
 const Command = {
   execute: execute$1
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const setReasoningPickerEnabled = async enabled => {
-  await invoke$1('Chat.setReasoningPickerEnabled', enabled);
+  await invoke('Chat.setReasoningPickerEnabled', enabled);
 };
 const setReasoningEffort = async effort => {
-  await invoke$1('Chat.setReasoningEffort', effort);
+  await invoke('Chat.setReasoningEffort', effort);
 };
 const handleChatListContextMenu = async (eventX, eventY) => {
-  await invoke$1('Chat.handleChatListContextMenu', eventX, eventY);
+  await invoke('Chat.handleChatListContextMenu', eventX, eventY);
 };
 const setBackendUrl = async url => {
-  await invoke$1('Chat.setBackendUrl', url);
+  await invoke('Chat.setBackendUrl', url);
 };
 const handleClickBack = async () => {
-  await invoke$1('Chat.handleClickBack');
+  await invoke('Chat.handleClickBack');
 };
 const setNewChatModelPickerEnabled = async enabled => {
-  await invoke$1('Chat.setNewChatModelPickerEnabled', enabled);
+  await invoke('Chat.setNewChatModelPickerEnabled', enabled);
 };
 const openAgentModePicker = async () => {
-  await invoke$1('Chat.openAgentModePicker');
+  await invoke('Chat.openAgentModePicker');
 };
 const handleClickSettings = async () => {
-  await invoke$1('Chat.handleClickSettings');
+  await invoke('Chat.handleClickSettings');
 };
 const selectIndex$7 = async index => {
-  await invoke$1('Chat.selectIndex', index);
+  await invoke('Chat.selectIndex', index);
 };
 const handleClickClose = async () => {
-  await invoke$1('Chat.handleClickClose');
+  await invoke('Chat.handleClickClose');
 };
 const handleClickNew = async () => {
-  await invoke$1('Chat.handleClickNew');
+  await invoke('Chat.handleClickNew');
 };
 const enterNewLine = async () => {
-  await invoke$1('Chat.enterNewLine');
+  await invoke('Chat.enterNewLine');
 };
 const setScrollDownButtonEnabled = async enabled => {
-  await invoke$1('Chat.setScrollDownButtonEnabled', enabled);
+  await invoke('Chat.setScrollDownButtonEnabled', enabled);
 };
 const show$6 = async () => {
-  await invoke$1('Layout.showSecondarySideBar');
-  await invoke$1('Chat.reset');
+  await invoke('Layout.showSecondarySideBar');
+  await invoke('Chat.reset');
 };
 const getSelectedSessionId = async () => {
-  return invoke$1('Chat.getSelectedSessionId');
+  return invoke('Chat.getSelectedSessionId');
 };
 const handleInput$7 = async text => {
-  await invoke$1('Chat.handleInput', 'composer', text, 'script');
+  await invoke('Chat.handleInput', 'composer', text, 'script');
 };
 const handleDropFiles = async file => {
   await execute$1('Chat.handleDropFiles', 'composer-drop-target', [file]);
@@ -1798,94 +1789,94 @@ const handleChatHeaderContextMenu = async () => {
   await execute$1('Chat.handleChatHeaderContextMenu', 0, 0);
 };
 const reset = async () => {
-  await invoke$1('Chat.reset');
+  await invoke('Chat.reset');
 };
 const handleMessagesScroll = async (id, x, y) => {
-  await invoke$1('Chat.handleMessagesScroll', id, x, y);
+  await invoke('Chat.handleMessagesScroll', id, x, y);
 };
 const mockOpenApiStreamFinish = async () => {
-  await invoke$1('Chat.mockOpenApiStreamFinish');
+  await invoke('Chat.mockOpenApiStreamFinish');
 };
 const mockOpenApiStreamPushChunk = async chunk => {
-  await invoke$1('Chat.mockOpenApiStreamPushChunk', chunk);
+  await invoke('Chat.mockOpenApiStreamPushChunk', chunk);
 };
 const openMockSession = async (sessionId, messages) => {
-  await invoke$1('Chat.openMockSession', sessionId, messages);
+  await invoke('Chat.openMockSession', sessionId, messages);
 };
 const registerMockResponse = async options => {
-  await invoke$1('Chat.registerMockResponse', options);
+  await invoke('Chat.registerMockResponse', options);
 };
 const handleSubmit = async () => {
-  await invoke$1('Chat.handleSubmit');
+  await invoke('Chat.handleSubmit');
 };
 const setStreamingEnabled = async enabled => {
-  await invoke$1('Chat.setStreamingEnabled', enabled);
+  await invoke('Chat.setStreamingEnabled', enabled);
 };
 const useMockApi = async () => {
-  await invoke$1('Chat.useMockApi', true);
+  await invoke('Chat.useMockApi', true);
 };
 const openGitBranchPicker = async () => {
-  await invoke$1('Chat.openGitBranchPicker');
+  await invoke('Chat.openGitBranchPicker');
 };
 const closeGitBranchPicker = async () => {
-  await invoke$1('Chat.closeGitBranchPicker');
+  await invoke('Chat.closeGitBranchPicker');
 };
 const setAuthEnabled = async enabled => {
-  await invoke$1('Chat.setAuthEnabled', enabled);
+  await invoke('Chat.setAuthEnabled', enabled);
 };
 const mockBackendAuthResponse = async response => {
-  await invoke$1('Chat.mockBackendAuthResponse', response);
+  await invoke('Chat.mockBackendAuthResponse', response);
 };
 const mockOpenApiRequestGetAll = async () => {
-  return invoke$1('Chat.mockOpenApiRequestGetAll');
+  return invoke('Chat.mockOpenApiRequestGetAll');
 };
 const rerender = async () => {
-  await invoke$1('Chat.rerender');
+  await invoke('Chat.rerender');
 };
 const setSearchEnabled = async enabled => {
-  await invoke$1('Chat.setSearchEnabled', enabled);
+  await invoke('Chat.setSearchEnabled', enabled);
 };
 const mockOpenApiRequestReset = async () => {
-  await invoke$1('Chat.mockOpenApiRequestReset');
+  await invoke('Chat.mockOpenApiRequestReset');
 };
 const mockOpenApiStreamReset = async () => {
-  await invoke$1('Chat.mockOpenApiStreamReset');
+  await invoke('Chat.mockOpenApiStreamReset');
 };
 const openModelPicker = async () => {
-  await invoke$1('Chat.openModelPicker');
+  await invoke('Chat.openModelPicker');
 };
 const handleClickDelete = async () => {
-  await invoke$1('Chat.handleClickDelete');
+  await invoke('Chat.handleClickDelete');
 };
 const handleContextMenuChatImageAttachment = async (id, x, y) => {
-  await invoke$1('Chat.handleContextMenuChatImageAttachment', id, x, y);
+  await invoke('Chat.handleContextMenuChatImageAttachment', id, x, y);
 };
 const setAddContextButtonEnabled = async enabled => {
-  await invoke$1('Chat.setAddContextButtonEnabled', enabled);
+  await invoke('Chat.setAddContextButtonEnabled', enabled);
 };
 const deleteSessionAtIndex = async index => {
-  await invoke$1('Chat.deleteSessionAtIndex', index);
+  await invoke('Chat.deleteSessionAtIndex', index);
 };
 const handleModelChange = async modelId => {
-  await invoke$1('Chat.handleModelChange', modelId);
+  await invoke('Chat.handleModelChange', modelId);
 };
 const handleModelInputBlur = async () => {
   await execute$1('Chat.handleModelInputBlur');
 };
 const handleInputPaste$1 = async () => {
-  await invoke$1('Chat.handleInputPaste');
+  await invoke('Chat.handleInputPaste');
 };
 const setQuestionToolEnabled = async enabled => {
-  await invoke$1('Chat.setQuestionToolEnabled', enabled);
+  await invoke('Chat.setQuestionToolEnabled', enabled);
 };
 const handleInputCopy$1 = async () => {
-  await invoke$1('Chat.handleInputCopy');
+  await invoke('Chat.handleInputCopy');
 };
 const handleClickFileName = async fileName => {
-  await invoke$1('Chat.handleClickFileName', fileName);
+  await invoke('Chat.handleClickFileName', fileName);
 };
 const handleInputCut$1 = async () => {
-  await invoke$1('Chat.handleInputCut');
+  await invoke('Chat.handleInputCut');
 };
 const clearInput$1 = async () => {
   await execute$1('Chat.clearInput');
@@ -1894,16 +1885,16 @@ const handleProjectListContextMenu = async (id, x, y) => {
   await execute$1('Chat.handleProjectListContextMenu', id, x, y);
 };
 const mockOpenAiResponse = async options => {
-  return invoke$1('Chat.mockOpenAiResponse', options);
+  return invoke('Chat.mockOpenAiResponse', options);
 };
 const handleInputFocus = async () => {
   return execute$1('Chat.handleInputFocus', 'chat-list');
 };
 const getAuthState = async () => {
-  return invoke$1('Chat.getAuthState');
+  return invoke('Chat.getAuthState');
 };
 const handleAgentModeChange = async newAgentMode => {
-  return invoke$1('Chat.handleAgentModeChange', newAgentMode);
+  return invoke('Chat.handleAgentModeChange', newAgentMode);
 };
 
 const Chat = {
@@ -1965,18 +1956,17 @@ const Chat = {
   useMockApi
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error, @typescript-eslint/prefer-readonly-parameter-types */
 const readNativeFiles = async () => {
-  await invoke$1('ClipBoard.readNativeFiles');
+  await invoke('ClipBoard.readNativeFiles');
 };
 const writeNativeFiles = async uris => {
-  await invoke$1('ClipBoard.writeNativeFiles', uris);
+  await invoke('ClipBoard.writeNativeFiles', uris);
 };
 const enableMemoryClipBoard = async () => {
-  await invoke$1('ClipBoard.enableMemoryClipBoard');
+  await invoke('ClipBoard.enableMemoryClipBoard');
 };
 const disableMemoryClipBoard = async () => {
-  await invoke$1('ClipBoard.disableMemoryClipBoard');
+  await invoke('ClipBoard.disableMemoryClipBoard');
 };
 const matchesExpectedText$1 = (actualText, expectedText) => {
   if (typeof expectedText === 'string') {
@@ -1985,13 +1975,13 @@ 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('ClipBoard.readMemoryText');
   if (!matchesExpectedText$1(actualText, expectedText)) {
     throw new AssertionError(`expected clipboard to have text "${expectedText}" but was "${actualText}"`);
   }
 };
 const writeText = async text => {
-  await invoke$1('ClipBoard.writeText', text);
+  await invoke('ClipBoard.writeText', text);
 };
 
 const ClipBoard = {
@@ -2004,7 +1994,7 @@ const ClipBoard = {
 };
 
 const setRelativeX = async x => {
-  await invoke$1('ColorPicker.setRelativeX', x);
+  await invoke('ColorPicker.setRelativeX', x);
 };
 
 const ColorPicker = {
@@ -2012,7 +2002,7 @@ const ColorPicker = {
 };
 
 const selectItem$1 = async text => {
-  await invoke$1('Menu.selectItem', text);
+  await invoke('Menu.selectItem', text);
 };
 
 const ContextMenu = {
@@ -2020,28 +2010,28 @@ const ContextMenu = {
 };
 
 const openIframeInspector = async () => {
-  return invoke$1('Developer.openIframeInspector');
+  return invoke('Developer.openIframeInspector');
 };
 const openCacheFolder = async () => {
-  return invoke$1('Developer.openCacheFolder');
+  return invoke('Developer.openCacheFolder');
 };
 const openConfigFolder = async () => {
-  return invoke$1('Developer.openConfigFolder');
+  return invoke('Developer.openConfigFolder');
 };
 const openLogsFolder = async () => {
-  return invoke$1('Developer.openLogsFolder');
+  return invoke('Developer.openLogsFolder');
 };
 const openProcessExplorer = async () => {
-  return invoke$1('Developer.openProcessExplorer');
+  return invoke('Developer.openProcessExplorer');
 };
 const reloadColorTheme = async () => {
-  return invoke$1('Developer.reloadColorTheme');
+  return invoke('Developer.reloadColorTheme');
 };
 const reloadIconTheme = async () => {
-  return invoke$1('Developer.reloadIconTheme');
+  return invoke('Developer.reloadIconTheme');
 };
 const toggleDeveloperTools = async () => {
-  return invoke$1('Developer.toggleDeveloperTools');
+  return invoke('Developer.toggleDeveloperTools');
 };
 
 const Developer = {
@@ -2071,15 +2061,15 @@ const executeMock$1 = (id, ...args) => {
 };
 
 const showSaveFilePicker = async () => {
-  await invoke$1('FilePicker.showSaveFilePicker');
+  await invoke('FilePicker.showSaveFilePicker');
 };
 const mockSaveFilePicker = async fn => {
   const id = registerMock(fn);
-  await invoke$1('FilePicker.mockSaveFilePicker', id);
+  await invoke('FilePicker.mockSaveFilePicker', id);
 };
 const mockConfirm = async fn => {
   const id = registerMock(fn);
-  await invoke$1('ConfirmPrompt.mock', id);
+  await invoke('ConfirmPrompt.mock', id);
 };
 const executeMock = (id, ...args) => {
   return executeMock$1(id, ...args);
@@ -2120,7 +2110,6 @@ const areSelectionsEqual = (a, b) => {
   return true;
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const getEditorKey = async () => {
   const keys = await invoke$2('Editor.getKeys');
   if (keys.length === 0) {
@@ -2134,15 +2123,15 @@ const getEditorKey = async () => {
 const Script = 2;
 
 const update$1 = settings => {
-  return invoke$1('Preferences.update', settings);
+  return invoke('Preferences.update', settings);
 };
 const enableDiagnostics$1 = () => {
-  return invoke$1('Preferences.update', {
+  return invoke('Preferences.update', {
     'editor.diagnostics': true
   });
 };
 const disableDiagnostics$1 = () => {
-  return invoke$1('Preferences.update', {
+  return invoke('Preferences.update', {
     'editor.diagnostics': false
   });
 };
@@ -2153,239 +2142,238 @@ const Settings = {
   update: update$1
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 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 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('SideBar.show', 'References', /* focus */true);
 };
 const findAllImplementations = async () => {
-  await invoke$1('SideBar.show', 'Implementations', /* focus */true);
+  await invoke('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 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$1 = 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('Editor.getText');
 };
 const rename$1 = 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();
@@ -2559,19 +2547,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$2 = 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 = {
@@ -2583,10 +2571,10 @@ const EditorCompletion = {
 };
 
 const show$5 = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const close$1 = async () => {
-  await invoke$1('EditorHover.close');
+  await invoke('EditorHover.close');
 };
 
 const EditorHover = {
@@ -2595,13 +2583,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 = {
@@ -2611,10 +2599,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 = {
@@ -2622,129 +2610,128 @@ const EditorSourceAction = {
   selectIndex: selectIndex$5
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const openContextMenu = async index => {
-  await invoke$1('Explorer.handleContextMenuKeyboard', index);
+  await invoke('Explorer.handleContextMenuKeyboard', index);
 };
 const handleDragLeave = async () => {
-  await invoke$1('Explorer.handleDragLeave');
+  await invoke('Explorer.handleDragLeave');
 };
 const handleBlur = async () => {
-  await invoke$1('Explorer.handleBlur');
+  await invoke('Explorer.handleBlur');
 };
 const handleEscape = async () => {
-  await invoke$1('Explorer.handleEscape');
+  await invoke('Explorer.handleEscape');
 };
 const handleDropIndex = async (fileHandles, files, paths, index) => {
-  await invoke$1('Explorer.handleDropIndex', fileHandles, files, paths, index);
+  await invoke('Explorer.handleDropIndex', fileHandles, files, paths, index);
 };
 const handleInputBlur = async () => {
-  await invoke$1('Explorer.handleInputBlur');
+  await invoke('Explorer.handleInputBlur');
 };
 const focus$1 = async () => {
-  await invoke$1('Explorer.focusIndex', -1);
+  await invoke('Explorer.focusIndex', -1);
 };
 const setDeltaY = async deltaY => {
-  await invoke$1('Explorer.setDeltaY', deltaY);
+  await invoke('Explorer.setDeltaY', deltaY);
 };
 const focusNext$7 = async () => {
-  await invoke$1('Explorer.focusNext');
+  await invoke('Explorer.focusNext');
 };
 const selectUp = async () => {
-  await invoke$1('Explorer.selectUp');
+  await invoke('Explorer.selectUp');
 };
 const handleDragOverIndex = async index => {
-  await invoke$1('Explorer.handleDragOverIndex', index);
+  await invoke('Explorer.handleDragOverIndex', index);
 };
 const selectDown = async () => {
-  await invoke$1('Explorer.selectDown');
+  await invoke('Explorer.selectDown');
 };
 const collapseAll$2 = async () => {
-  await invoke$1('Explorer.collapseAll');
+  await invoke('Explorer.collapseAll');
 };
 const refresh$1 = async () => {
-  await invoke$1('Explorer.refresh');
+  await invoke('Explorer.refresh');
 };
 const focusIndex$5 = async index => {
-  await invoke$1('Explorer.focusIndex', index);
+  await invoke('Explorer.focusIndex', index);
 };
 const clickCurrent = async () => {
-  await invoke$1('Explorer.handleClickCurrent');
+  await invoke('Explorer.handleClickCurrent');
 };
 const handleArrowLeft$1 = async () => {
-  await invoke$1('Explorer.handleArrowLeft');
+  await invoke('Explorer.handleArrowLeft');
 };
 const focusLast$5 = async () => {
-  await invoke$1('Explorer.focusLast');
+  await invoke('Explorer.focusLast');
 };
 const focusFirst$6 = async () => {
-  await invoke$1('Explorer.focusFirst');
+  await invoke('Explorer.focusFirst');
 };
 const removeDirent = async () => {
-  await invoke$1('Explorer.removeDirent');
+  await invoke('Explorer.removeDirent');
 };
 const expandRecursively = async () => {
-  await invoke$1('Explorer.expandRecursively');
+  await invoke('Explorer.expandRecursively');
 };
 const newFile = async () => {
-  await invoke$1('Explorer.newFile');
+  await invoke('Explorer.newFile');
 };
 const newFolder = async () => {
-  await invoke$1('Explorer.newFolder');
+  await invoke('Explorer.newFolder');
 };
 const copyPath$2 = async () => {
-  await invoke$1('Explorer.copyPath');
+  await invoke('Explorer.copyPath');
 };
 const copyRelativePath$1 = async () => {
-  await invoke$1('Explorer.copyRelativePath');
+  await invoke('Explorer.copyRelativePath');
 };
 const handleClick$3 = async index => {
-  await invoke$1('Explorer.handleClick', index);
+  await invoke('Explorer.handleClick', index);
 };
 const handleClickAt$2 = async (preventDefault, button, ctrlKey, shiftKey, x, y) => {
-  await invoke$1('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
+  await invoke('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
 };
 const handleDrop = async (x, y, fileIds, fileList) => {
-  await invoke$1('Explorer.handleDrop', x, y, fileIds, fileIds);
+  await invoke('Explorer.handleDrop', x, y, fileIds, fileIds);
 };
 const rename = async () => {
-  await invoke$1('Explorer.renameDirent');
+  await invoke('Explorer.renameDirent');
 };
 const selectAll = async () => {
-  await invoke$1('Explorer.selectAll');
+  await invoke('Explorer.selectAll');
 };
 const renameDirent = async () => {
-  await invoke$1('Explorer.renameDirent');
+  await invoke('Explorer.renameDirent');
 };
 const cancelEdit = async () => {
-  await invoke$1('Explorer.cancelEdit');
+  await invoke('Explorer.cancelEdit');
 };
 const acceptEdit = async () => {
-  await invoke$1('Explorer.acceptEdit');
+  await invoke('Explorer.acceptEdit');
 };
 const updateEditingValue = async value => {
-  await invoke$1('Explorer.updateEditingValue', value);
+  await invoke('Explorer.updateEditingValue', value);
 };
 const expandAll = async () => {
-  await invoke$1('Explorer.expandAll');
+  await invoke('Explorer.expandAll');
 };
 const handleDragOver = async (x, y) => {
-  await invoke$1('Explorer.handleDragOver', x, y);
+  await invoke('Explorer.handleDragOver', x, y);
 };
 const handleCut = async () => {
-  await invoke$1('Explorer.handleCut');
+  await invoke('Explorer.handleCut');
 };
 const handleCopy = async () => {
-  await invoke$1('Explorer.handleCopy');
+  await invoke('Explorer.handleCopy');
 };
 const handlePaste = async () => {
-  await invoke$1('Explorer.handlePaste');
+  await invoke('Explorer.handlePaste');
 };
 const selectIndices = async indices => {
-  await invoke$1('Explorer.selectIndices', indices);
+  await invoke('Explorer.selectIndices', indices);
 };
 const toggleIndividualSelection = async index => {
-  await invoke$1('Explorer.toggleIndividualSelection', index);
+  await invoke('Explorer.toggleIndividualSelection', index);
 };
 
 const Explorer = {
@@ -2794,12 +2781,12 @@ const Explorer = {
 const addWebExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke$1('ExtensionMeta.addWebExtension', absolutePath);
+  await invoke('ExtensionMeta.addWebExtension', absolutePath);
 };
 const addNodeExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke$1('ExtensionMeta.addNodeExtension', absolutePath);
+  await invoke('ExtensionMeta.addNodeExtension', absolutePath);
 };
 
 const Extension = {
@@ -2808,28 +2795,28 @@ const Extension = {
 };
 
 const handleClickCategory = async categoryId => {
-  await invoke$1('ExtensionDetail.handleClickCategory', categoryId);
+  await invoke('ExtensionDetail.handleClickCategory', categoryId);
 };
 const handleReadmeContextMenu = async (x, y, nodeName, href) => {
-  await invoke$1('ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
+  await invoke('ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
 };
 const copyReadmeLink = async href => {
-  await invoke$1('ExtensionDetail.copyReadmeLink', href);
+  await invoke('ExtensionDetail.copyReadmeLink', href);
 };
 const handleClickEnable = async () => {
-  await invoke$1('ExtensionDetail.handleClickEnable');
+  await invoke('ExtensionDetail.handleClickEnable');
 };
 const handleClickDisable = async () => {
-  await invoke$1('ExtensionDetail.handleClickDisable');
+  await invoke('ExtensionDetail.handleClickDisable');
 };
 const handleClickSetColorTheme = async () => {
-  await invoke$1('ExtensionDetail.handleClickSetColorTheme');
+  await invoke('ExtensionDetail.handleClickSetColorTheme');
 };
 const selectFeature = name => {
-  return invoke$1('ExtensionDetail.selectFeature', name);
+  return invoke('ExtensionDetail.selectFeature', name);
 };
 const selectTab$2 = name => {
-  return invoke$1('ExtensionDetail.selectTab', name);
+  return invoke('ExtensionDetail.selectTab', name);
 };
 const selectDetails = async () => {
   await selectTab$2('Details');
@@ -2841,23 +2828,23 @@ const selectChangelog = async () => {
   await selectTab$2('Changelog');
 };
 const focusNextTab = async () => {
-  await invoke$1('ExtensionDetail.focusNextTab');
+  await invoke('ExtensionDetail.focusNextTab');
 };
 const focusPreviousTab = async () => {
-  await invoke$1('ExtensionDetail.focusPreviousTab');
+  await invoke('ExtensionDetail.focusPreviousTab');
 };
 const open$8 = extensionId => {
   const uri = `extension-detail://${extensionId}`;
-  return invoke$1('Main.openUri', uri);
+  return invoke('Main.openUri', uri);
 };
 const handleClickUninstall = () => {
-  return invoke$1('ExtensionDetail.handleClickUninstall');
+  return invoke('ExtensionDetail.handleClickUninstall');
 };
 const handleImageContextMenu = () => {
-  return invoke$1('ExtensionDetail.handleImageContextMenu');
+  return invoke('ExtensionDetail.handleImageContextMenu');
 };
 const openFeature = featureName => {
-  return invoke$1('ExtensionDetail.handleFeaturesClick', featureName);
+  return invoke('ExtensionDetail.handleFeaturesClick', featureName);
 };
 const openThemes = async () => {
   await openFeature('Theme');
@@ -2878,13 +2865,13 @@ const openSettings = async () => {
   await openFeature('Settings');
 };
 const handleScroll$1 = async scrollTop => {
-  return invoke$1('ExtensionDetail.handleScroll', scrollTop);
+  return invoke('ExtensionDetail.handleScroll', scrollTop);
 };
 const hideSizeLink = async () => {
-  return invoke$1('ExtensionDetail.hideSizeLink');
+  return invoke('ExtensionDetail.hideSizeLink');
 };
 const handleTabFocus = async tabName => {
-  return invoke$1('ExtensionDetail.handleTabFocus', tabName);
+  return invoke('ExtensionDetail.handleTabFocus', tabName);
 };
 
 const ExtensionDetail = {
@@ -2917,10 +2904,10 @@ const ExtensionDetail = {
 };
 
 const open$7 = async id => {
-  await invoke$1('SideBar.openViewlet', id);
+  await invoke('SideBar.openViewlet', id);
 };
 const hide = async () => {
-  await invoke$1('Layout.hideSideBar');
+  await invoke('Layout.hideSideBar');
 };
 
 const SideBar = {
@@ -2932,25 +2919,25 @@ const open$6 = async () => {
   await open$7('Extensions');
 };
 const handleInput$5 = async value => {
-  await invoke$1('Extensions.handleInput', value, Script$1);
+  await invoke('Extensions.handleInput', value, Script$1);
 };
 const handleClick$2 = async index => {
-  await invoke$1('Extensions.handleClick', index);
+  await invoke('Extensions.handleClick', index);
 };
 const handleClickFilter = async () => {
-  await invoke$1('Extensions.handleClickFilter');
+  await invoke('Extensions.handleClickFilter');
 };
 const handleContextMenu$4 = async (button, x, y) => {
-  await invoke$1('Extensions.handleContextMenu', button, x, y);
+  await invoke('Extensions.handleContextMenu', button, x, y);
 };
 const copyExtensionInfo = async () => {
-  await invoke$1('Extensions.copyExtensionInfo');
+  await invoke('Extensions.copyExtensionInfo');
 };
 const copyExtensionId = async () => {
-  await invoke$1('Extensions.copyExtensionId');
+  await invoke('Extensions.copyExtensionId');
 };
 const clearSearchResults$1 = async () => {
-  await invoke$1('Extensions.clearSearchResults');
+  await invoke('Extensions.clearSearchResults');
 };
 
 const ExtensionSearch = {
@@ -2966,7 +2953,6 @@ const ExtensionSearch = {
 
 const Memfs = 'memfs';
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const toFileUrl = url => {
   const urlObject = new URL(url);
   const pathName = urlObject.pathname;
@@ -2979,7 +2965,7 @@ const toFileUrl = url => {
 
 const getDirents = async fileUrl => {
   const allDirents = [];
-  const dirents = await invoke$1('FileSystem.readDirWithFileTypes', fileUrl);
+  const dirents = await invoke('FileSystem.readDirWithFileTypes', fileUrl);
   for (const dirent of dirents) {
     if (dirent.type === Directory) {
       const subDirents = await getDirents(`${fileUrl}/${dirent.name}`);
@@ -3017,8 +3003,6 @@ const isValidFileMap = value => {
   return true;
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
-
 const loadFileMap = async fileMapUrl => {
   try {
     const response = await fetch(fileMapUrl);
@@ -3044,7 +3028,7 @@ const getFileMapWeb = async url => {
 const loadFixtureToMemFs = async fileMap => {
   for (const [path, content] of Object.entries(fileMap)) {
     const memfsPath = `memfs:///fixture/${path}`;
-    await invoke$1('FileSystem.writeFile', memfsPath, content);
+    await invoke('FileSystem.writeFile', memfsPath, content);
   }
   return `memfs:///fixture`;
 };
@@ -3063,22 +3047,21 @@ const stringifyJson = data => {
   return JSON.stringify(data, null, 2) + '\n';
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const writeFile = async (uri, content) => {
-  await invoke$1('FileSystem.writeFile', uri, content);
+  await invoke('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('FileSystem.readFile', uri);
 };
 const addFileHandle = async file => {
-  await invoke$1('FileSystem.addFileHandle', file);
+  await invoke('FileSystem.addFileHandle', file);
 };
 const mkdir = async uri => {
-  await invoke$1('FileSystem.mkdir', uri);
+  await invoke('FileSystem.mkdir', uri);
 };
 const setFiles = async files => {
   // TODO maybe have a method to send all the files to file system worker directly
@@ -3087,10 +3070,10 @@ const setFiles = async files => {
   }));
 };
 const readDir = async uri => {
-  return invoke$1('FileSystem.readDirWithFileTypes', uri);
+  return invoke('FileSystem.readDirWithFileTypes', uri);
 };
 const remove = async uri => {
-  await invoke$1('FileSystem.remove', uri);
+  await invoke('FileSystem.remove', uri);
 };
 const getTmpDir = async ({
   scheme = Memfs
@@ -3099,17 +3082,17 @@ const getTmpDir = async ({
     case Memfs:
       return 'memfs:///workspace';
     default:
-      return invoke$1('PlatformPaths.getTmpDir');
+      return invoke('PlatformPaths.getTmpDir');
   }
 };
 const chmod = async (uri, permissions) => {
-  await invoke$1('FileSystem.chmod', uri, permissions);
+  await invoke('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('PlatformPaths.getNodePath');
   const gitPath = `${tmpDir}/git`;
   await writeFile(gitPath, `#!${nodePath}
   ${content}`);
@@ -3117,9 +3100,9 @@ const createExecutable = async content => {
   return gitPath;
 };
 const createExecutableFrom = async uri => {
-  const testPath = await invoke$1('PlatformPaths.getTestPath');
+  const testPath = await invoke('PlatformPaths.getTestPath');
   const absolutePath = testPath + Slash + uri;
-  const content = await invoke$1('Ajax.getText', absolutePath);
+  const content = await invoke('Ajax.getText', absolutePath);
   return createExecutable(content);
 };
 const createDroppedFileHandle = async () => {
@@ -3128,7 +3111,7 @@ const createDroppedFileHandle = async () => {
     create: true
   });
   const file = await fileHandle.getFile();
-  const id = await invoke$1('FileSystemHandle.addFileHandle', fileHandle);
+  const id = await invoke('FileSystemHandle.addFileHandle', fileHandle);
   return {
     file,
     id
@@ -3162,49 +3145,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 = 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 = {
@@ -3226,7 +3209,7 @@ const FindWidget = {
 };
 
 const setIconTheme = async id => {
-  await invoke$1('IconTheme.setIconTheme', id);
+  await invoke('IconTheme.setIconTheme', id);
 };
 
 const IconTheme = {
@@ -3234,19 +3217,19 @@ const IconTheme = {
 };
 
 const selectIndex$4 = async index => {
-  return invoke$1('IframeInspector.selectIndex', index);
+  return invoke('IframeInspector.selectIndex', index);
 };
 const focusNext$5 = async () => {
-  return invoke$1('IframeInspector.focusNext');
+  return invoke('IframeInspector.focusNext');
 };
 const focusPrevious$5 = async () => {
-  return invoke$1('IframeInspector.focusPrevious');
+  return invoke('IframeInspector.focusPrevious');
 };
 const focusFirst$5 = async () => {
-  return invoke$1('IframeInspector.focusFirst');
+  return invoke('IframeInspector.focusFirst');
 };
 const focusLast$4 = async () => {
-  return invoke$1('IframeInspector.focusLast');
+  return invoke('IframeInspector.focusLast');
 };
 
 const IframeInspector = {
@@ -3258,73 +3241,73 @@ const IframeInspector = {
 };
 
 const open$5 = async () => {
-  await invoke$1('Main.openUri', 'app://keybindings');
+  await invoke('Main.openUri', 'app://keybindings');
 };
 const handleInput$4 = value => {
-  return invoke$1('KeyBindings.handleInput', value);
+  return invoke('KeyBindings.handleInput', value);
 };
 const handleClick$1 = (x, y) => {
-  return invoke$1('KeyBindings.handleClick', x, y);
+  return invoke('KeyBindings.handleClick', x, y);
 };
 const handleWheel$1 = (deltaMode, deltaY) => {
-  return invoke$1('KeyBindings.handleWheel', deltaMode, deltaY);
+  return invoke('KeyBindings.handleWheel', deltaMode, deltaY);
 };
 const handleDoubleClick = (x, y) => {
-  return invoke$1('KeyBindings.handleDoubleClick', x, y);
+  return invoke('KeyBindings.handleDoubleClick', x, y);
 };
 const focusNext$4 = () => {
-  return invoke$1('KeyBindings.focusNext');
+  return invoke('KeyBindings.focusNext');
 };
 const focusPrevious$4 = () => {
-  return invoke$1('KeyBindings.focusPrevious');
+  return invoke('KeyBindings.focusPrevious');
 };
 const focusFirst$4 = () => {
-  return invoke$1('KeyBindings.focusFirst');
+  return invoke('KeyBindings.focusFirst');
 };
 const focusIndex$4 = index => {
-  return invoke$1('KeyBindings.focusIndex', index);
+  return invoke('KeyBindings.focusIndex', index);
 };
 const focusLast$3 = () => {
-  return invoke$1('KeyBindings.focusLast');
+  return invoke('KeyBindings.focusLast');
 };
 const toggleRecordingKeys = () => {
-  return invoke$1('KeyBindings.toggleRecordingKeys');
+  return invoke('KeyBindings.toggleRecordingKeys');
 };
 const startRecordingKeys = () => {
-  return invoke$1('KeyBindings.startRecordingKeys');
+  return invoke('KeyBindings.startRecordingKeys');
 };
 const clearInput = () => {
-  return invoke$1('KeyBindings.clearInput');
+  return invoke('KeyBindings.clearInput');
 };
 const sortByPrecedence = () => {
-  return invoke$1('KeyBindings.sortByPrecedence');
+  return invoke('KeyBindings.sortByPrecedence');
 };
 const stopRecordingKeys = () => {
-  return invoke$1('KeyBindings.stopRecordingKeys');
+  return invoke('KeyBindings.stopRecordingKeys');
 };
 const handleContextMenu$3 = (button, x, y) => {
-  return invoke$1('KeyBindings.handleContextMenu', button, x, y);
+  return invoke('KeyBindings.handleContextMenu', button, x, y);
 };
 const copyCommandId = () => {
-  return invoke$1('KeyBindings.copyCommandId');
+  return invoke('KeyBindings.copyCommandId');
 };
 const copyCommandTitle = () => {
-  return invoke$1('KeyBindings.copyCommandTitle');
+  return invoke('KeyBindings.copyCommandTitle');
 };
 const addKeyBinding = () => {
-  return invoke$1('KeyBindings.addKeyBinding');
+  return invoke('KeyBindings.addKeyBinding');
 };
 const removeKeyBinding = () => {
-  return invoke$1('KeyBindings.removeKeyBinding');
+  return invoke('KeyBindings.removeKeyBinding');
 };
 const changeWhenExpression = () => {
-  return invoke$1('KeyBindings.changeWhenExpression');
+  return invoke('KeyBindings.changeWhenExpression');
 };
 const showSameKeyBindings = () => {
-  return invoke$1('KeyBindings.showSameKeyBindings');
+  return invoke('KeyBindings.showSameKeyBindings');
 };
 const resetKeyBinding = () => {
-  return invoke$1('KeyBindings.resetKeyBinding');
+  return invoke('KeyBindings.resetKeyBinding');
 };
 
 const KeyBindingsEditor = {
@@ -3399,7 +3382,7 @@ const press = async key => {
     cancelable: true,
     ...keyOptions
   };
-  await invoke$1('TestFrameWork.performKeyBoardAction', 'press', options);
+  await invoke('TestFrameWork.performKeyBoardAction', 'press', options);
 };
 
 const KeyBoard = {
@@ -3410,7 +3393,7 @@ const showSideBar = async () => {
   await execute$1('Layout.showSideBar');
 };
 const handleWorkspaceRefresh = async () => {
-  await invoke$1('Layout.handleWorkspaceRefresh');
+  await invoke('Layout.handleWorkspaceRefresh');
 };
 
 const Layout = {
@@ -3419,19 +3402,19 @@ const Layout = {
 };
 
 const open$4 = async () => {
-  await invoke$1('Main.openUri', 'language-models:///1');
+  await invoke('Main.openUri', 'language-models:///1');
 };
 const handleFilterInput$2 = async value => {
-  await invoke$1('LanguageModels.handleFilterInput', value);
+  await invoke('LanguageModels.handleFilterInput', value);
 };
 const clearFilterInput = async () => {
-  await invoke$1('LanguageModels.clearFilterInput');
+  await invoke('LanguageModels.clearFilterInput');
 };
 const addModel = async () => {
-  await invoke$1('LanguageModels.addModel');
+  await invoke('LanguageModels.addModel');
 };
 const removeModel = async id => {
-  await invoke$1('LanguageModels.removeModel', id);
+  await invoke('LanguageModels.removeModel', id);
 };
 
 const LanguageModels = {
@@ -3442,69 +3425,68 @@ const LanguageModels = {
   removeModel
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const openUri = async uri => {
-  await invoke$1('Main.openUri', uri);
+  await invoke('Main.openUri', uri);
 };
 const splitRight = async () => {
-  await invoke$1('Main.splitRight');
+  await invoke('Main.splitRight');
 };
 const splitDown = async () => {
-  await invoke$1('Main.splitDown');
+  await invoke('Main.splitDown');
 };
 const openKeyBindings = async () => {
-  await invoke$1('Main.openKeyBindings');
+  await invoke('Main.openKeyBindings');
 };
 const handleClickTogglePreview = async () => {
-  await invoke$1('Main.handleClickTogglePreview');
+  await invoke('Main.handleClickTogglePreview');
 };
 const closeAllEditors = async () => {
-  await invoke$1('Main.closeAllEditors');
+  await invoke('Main.closeAllEditors');
 };
 const closeTabsLeft = async () => {
-  await invoke$1('Main.closeTabsLeft');
+  await invoke('Main.closeTabsLeft');
 };
 const handleModifiedStatusChange = async (uri, newStatus) => {
-  await invoke$1('Main.handleModifiedStatusChange', uri, newStatus);
+  await invoke('Main.handleModifiedStatusChange', uri, newStatus);
 };
 const closeTabsRight = async () => {
-  await invoke$1('Main.closeTabsRight');
+  await invoke('Main.closeTabsRight');
 };
 const selectTab$1 = async (groupIndex, tabIndex) => {
-  await invoke$1('Main.selectTab', groupIndex, tabIndex);
+  await invoke('Main.selectTab', groupIndex, tabIndex);
 };
 const closeOthers = async () => {
-  await invoke$1('Main.closeOthers');
+  await invoke('Main.closeOthers');
 };
 const closeActiveEditor = async () => {
-  await invoke$1('Main.closeActiveEditor');
+  await invoke('Main.closeActiveEditor');
 };
 const save = async () => {
-  await invoke$1('Main.save');
+  await invoke('Main.save');
 };
 const saveAll = async () => {
-  await invoke$1('Main.saveAll');
+  await invoke('Main.saveAll');
 };
 const focusFirst$3 = async () => {
-  await invoke$1('Main.focusFirst');
+  await invoke('Main.focusFirst');
 };
 const focusNext$3 = async () => {
-  await invoke$1('Main.focusNext');
+  await invoke('Main.focusNext');
 };
 const focusPrevious$3 = async () => {
-  await invoke$1('Main.focusPrevious');
+  await invoke('Main.focusPrevious');
 };
 const focusLast$2 = async () => {
-  await invoke$1('Main.focusLast');
+  await invoke('Main.focusLast');
 };
 const handleTabContextMenu = async (button, x, y) => {
-  await invoke$1('Main.handleTabContextMenu', button, x, y);
+  await invoke('Main.handleTabContextMenu', button, x, y);
 };
 const copyPath$1 = async () => {
-  await invoke$1('Main.copyPath');
+  await invoke('Main.copyPath');
 };
 const copyRelativePath = async () => {
-  await invoke$1('Main.copyRelativePath');
+  await invoke('Main.copyRelativePath');
 };
 
 const Main = {
@@ -3531,12 +3513,11 @@ const Main = {
   splitRight
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error, @typescript-eslint/prefer-readonly-parameter-types */
 const enableMemoryOpener = async () => {
-  await invoke('Open.enableMemoryOpener');
+  await invoke$1('Open.enableMemoryOpener');
 };
 const disableMemoryOpener = async () => {
-  await invoke('Open.disableMemoryOpener');
+  await invoke$1('Open.disableMemoryOpener');
 };
 const matchesExpectedText = (actualText, expectedText) => {
   if (typeof expectedText === 'string') {
@@ -3545,7 +3526,7 @@ const matchesExpectedText = (actualText, expectedText) => {
   return expectedText.test(actualText);
 };
 const shouldHaveUrl = async expectedText => {
-  const actualText = await invoke('Open.readOpenedUrl');
+  const actualText = await invoke$1('Open.readOpenedUrl');
   if (!matchesExpectedText(actualText, expectedText)) {
     throw new AssertionError(`expected opened url to be "${expectedText}" but was "${actualText}"`);
   }
@@ -3558,11 +3539,11 @@ const Open = {
 };
 
 const open$3 = async id => {
-  await invoke$1('Layout.showPanel', id);
+  await invoke('Layout.showPanel', id);
 };
 const openProblems = async () => {
   await open$3('Problems');
-  await invoke$1('Panel.selectIndex', 0);
+  await invoke('Panel.selectIndex', 0);
 };
 
 const Panel = {
@@ -3572,19 +3553,19 @@ const Panel = {
 
 const show$4 = async () => {
   await open$3('Output');
-  await invoke$1('Panel.selectIndex', 1);
+  await invoke('Panel.selectIndex', 1);
 };
 const handleFilterInput$1 = async text => {
-  await invoke$1('Output.handleFilterInput', text, Script);
+  await invoke('Output.handleFilterInput', text, Script);
 };
 const selectChannel = async channelId => {
-  await invoke$1('Output.selectChannel', channelId);
+  await invoke('Output.selectChannel', channelId);
 };
 const clear$2 = async () => {
-  await invoke$1('Output.clear');
+  await invoke('Output.clear');
 };
 const saveAs = async () => {
-  await invoke$1('Output.saveAs');
+  await invoke('Output.saveAs');
 };
 
 const Output = {
@@ -3609,7 +3590,7 @@ const getIsFirefox = () => {
 };
 
 const getNodePath$1 = () => {
-  return invoke$1(/* Platform.getNodePath */'Platform.getNodePath');
+  return invoke(/* Platform.getNodePath */'Platform.getNodePath');
 };
 
 const getNodePath = () => {
@@ -3625,38 +3606,38 @@ const Platform = {
 };
 
 const open$2 = async uri => {
-  await invoke$1('Layout.showPreview', uri);
+  await invoke('Layout.showPreview', uri);
 };
 const handleClick = async hdId => {
-  await invoke$1('Preview.handleClick', hdId);
+  await invoke('Preview.handleClick', hdId);
 };
 const handleInput$3 = async (hdId, value) => {
-  await invoke$1('Preview.handleInput', hdId, value);
+  await invoke('Preview.handleInput', hdId, value);
 };
 const handleMouseDown = async (hdId, clientX, clientY) => {
-  await invoke$1('Preview.handleMouseDown', hdId, clientX, clientY);
+  await invoke('Preview.handleMouseDown', hdId, clientX, clientY);
 };
 const handleMouseUp = async (hdId, value, clientX, clientY) => {
-  await invoke$1('Preview.handleMouseUp', hdId, value, clientX, clientY);
+  await invoke('Preview.handleMouseUp', hdId, value, clientX, clientY);
 };
 const handleMouseMove = async (hdId, value, clientX, clientY) => {
-  await invoke$1('Preview.handleMouseMove', hdId, value, clientX, clientY);
+  await invoke('Preview.handleMouseMove', hdId, value, clientX, clientY);
 };
 const handleKeyDown = async (hdId, key, code) => {
-  await invoke$1('Preview.handleKeyDown', hdId, key, code);
+  await invoke('Preview.handleKeyDown', hdId, key, code);
 };
 const setUri = async uri => {
-  await invoke$1('Preview.setUri', uri);
+  await invoke('Preview.setUri', uri);
 };
 
 /**
  * @deprecated use waitForMutation instead
  */
 const waitForClick = async () => {
-  await invoke$1('Preview.waitForClick');
+  await invoke('Preview.waitForClick');
 };
 const waitForMutation = async () => {
-  await invoke$1('Preview.waitForMutation');
+  await invoke('Preview.waitForMutation');
 };
 
 const Preview = {
@@ -3673,34 +3654,34 @@ const Preview = {
 };
 
 const show$3 = async () => {
-  await invoke$1('Panel.selectIndex', 0);
+  await invoke('Panel.selectIndex', 0);
 };
 const handleFilterInput = async text => {
-  await invoke$1('Problems.handleFilterInput', text, Script);
+  await invoke('Problems.handleFilterInput', text, Script);
 };
 const copyMessage = async () => {
-  await invoke$1('Problems.copyMessage');
+  await invoke('Problems.copyMessage');
 };
 const focusIndex$3 = async index => {
-  await invoke$1('Problems.focusIndex', index);
+  await invoke('Problems.focusIndex', index);
 };
 const handleArrowLeft = async () => {
-  await invoke$1('Problems.handleArrowLeft');
+  await invoke('Problems.handleArrowLeft');
 };
 const handleArrowRight = async () => {
-  await invoke$1('Problems.handleArrowRight');
+  await invoke('Problems.handleArrowRight');
 };
 const handleClickAt$1 = async (x, y) => {
-  await invoke$1('Problems.handleClickAt', x, y);
+  await invoke('Problems.handleClickAt', x, y);
 };
 const handleIconThemeChange = async () => {
-  await invoke$1('Problems.handleIconThemeChange');
+  await invoke('Problems.handleIconThemeChange');
 };
 const viewAsList = async () => {
-  await invoke$1('Problems.viewAsList');
+  await invoke('Problems.viewAsList');
 };
 const viewAsTable = async () => {
-  await invoke$1('Problems.viewAsTable');
+  await invoke('Problems.viewAsTable');
 };
 
 const Problems = {
@@ -3724,7 +3705,7 @@ const registerCallbackCommand = async commandId => {
     resolve
   } = Promise.withResolvers();
   callbacks[id] = resolve;
-  await invoke$1(`Test.registerTestCommand`, commandId);
+  await invoke(`Test.registerTestCommand`, commandId);
   return {
     promise
   };
@@ -3733,45 +3714,45 @@ const registerCallbackCommand = async commandId => {
 const QuickPick$1 = 'QuickPick';
 
 const open$1 = async () => {
-  await invoke$1('Viewlet.openWidget', QuickPick$1, 'everything');
+  await invoke('Viewlet.openWidget', QuickPick$1, 'everything');
 };
 const handleInput$2 = async value => {
-  await invoke$1('QuickPick.handleInput', value, 0);
+  await invoke('QuickPick.handleInput', value, 0);
 };
 const handleClickAt = async (x, y) => {
-  await invoke$1('QuickPick.handleClickAt', x, y);
+  await invoke('QuickPick.handleClickAt', x, y);
 };
 const setValue$1 = async value => {
-  await invoke$1('QuickPick.setValue', value);
+  await invoke('QuickPick.setValue', value);
 };
 const focusNext$2 = async () => {
-  await invoke$1('QuickPick.focusNext');
+  await invoke('QuickPick.focusNext');
 };
 const focusFirst$2 = async () => {
-  await invoke$1('QuickPick.focusFirst');
+  await invoke('QuickPick.focusFirst');
 };
 const focusLast$1 = async () => {
-  await invoke$1('QuickPick.focusLast');
+  await invoke('QuickPick.focusLast');
 };
 const focusIndex$2 = async index => {
-  await invoke$1('QuickPick.focusIndex', index);
+  await invoke('QuickPick.focusIndex', index);
 };
 const focusPrevious$2 = async () => {
-  await invoke$1('QuickPick.focusPrevious');
+  await invoke('QuickPick.focusPrevious');
 };
 const selectItem = async label => {
-  await invoke$1('QuickPick.selectItem', label);
+  await invoke('QuickPick.selectItem', label);
 };
 const selectIndex$3 = async index => {
-  await invoke$1('QuickPick.selectIndex', index);
+  await invoke('QuickPick.selectIndex', index);
 };
 const selectCurrentIndex = async () => {
-  await invoke$1('QuickPick.selectCurrentIndex');
+  await invoke('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('QuickPick.showCommands');
+  await invoke('QuickPick.handleInput', label, 0);
+  await invoke('QuickPick.selectItem', label);
 };
 const selectItem2 = async ({
   callbackCommand,
@@ -3782,7 +3763,7 @@ const selectItem2 = async ({
   } = await registerCallbackCommand(callbackCommand);
 
   // @ts-ignore
-  invoke$1('QuickPick.selectItem', label);
+  invoke('QuickPick.selectItem', label);
   await promise;
 };
 
@@ -3804,13 +3785,13 @@ const QuickPick = {
 };
 
 const clear$1 = async () => {
-  return invoke$1('References.clear');
+  return invoke('References.clear');
 };
 const collapseAll$1 = async () => {
-  return invoke$1('References.collapseAll');
+  return invoke('References.collapseAll');
 };
 const refresh = async () => {
-  return invoke$1('References.refresh');
+  return invoke('References.refresh');
 };
 
 const References = {
@@ -3823,31 +3804,31 @@ const show$2 = async () => {
   await open$7('Run And Debug');
 };
 const handleClickSectionBreakPoints = async () => {
-  await invoke$1('Run And Debug.handleClickSectionBreakPoints');
+  await invoke('Run And Debug.handleClickSectionBreakPoints');
 };
 const handleClickSectionWatch = async () => {
-  await invoke$1('Run And Debug.handleClickSectionWatch');
+  await invoke('Run And Debug.handleClickSectionWatch');
 };
 const addWatchExpression = async expression => {
-  await invoke$1('Run And Debug.addWatchExpression', expression);
+  await invoke('Run And Debug.addWatchExpression', expression);
 };
 const handleWatchValueChange = async () => {
-  await invoke$1('Run And Debug.handleWatchValueChange');
+  await invoke('Run And Debug.handleWatchValueChange');
 };
 const acceptWatchExpressionEdit = async () => {
-  await invoke$1('Run And Debug.acceptWatchExpressionEdit');
+  await invoke('Run And Debug.acceptWatchExpressionEdit');
 };
 const selectIndex$2 = async index => {
-  await invoke$1('Run And Debug.selectIndex', index);
+  await invoke('Run And Debug.selectIndex', index);
 };
 const setPauseOnExceptions = async value => {
-  await invoke$1('Run And Debug.setPauseOnExceptions', value);
+  await invoke('Run And Debug.setPauseOnExceptions', value);
 };
 const handleRename = async () => {
-  await invoke$1('Run And Debug.handleRename');
+  await invoke('Run And Debug.handleRename');
 };
 const handleSpace = async () => {
-  await invoke$1('Run And Debug.handleSpace');
+  await invoke('Run And Debug.handleSpace');
 };
 
 const RunAndDebug = {
@@ -3863,117 +3844,116 @@ const RunAndDebug = {
   show: show$2
 };
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const setValue = async value => {
-  await invoke$1('Search.handleInput', value, Script);
+  await invoke('Search.handleInput', value, Script);
 };
 const setReplaceValue = async value => {
-  await invoke$1('Search.handleReplaceInput', value, Script);
+  await invoke('Search.handleReplaceInput', value, Script);
 };
 const setExcludeValue = async value => {
-  await invoke$1('Search.handleExcludeInput', value, Script);
+  await invoke('Search.handleExcludeInput', value, Script);
 };
 const replaceAll = async () => {
-  await invoke$1('Search.replaceAll');
+  await invoke('Search.replaceAll');
 };
 const setIncludeValue = async value => {
-  await invoke$1('Search.handleIncludeInput', value, Script);
+  await invoke('Search.handleIncludeInput', value, Script);
 };
 const clearSearchResults = async () => {
-  await invoke$1('Search.clearSearchResults');
+  await invoke('Search.clearSearchResults');
 };
 const openDetails = async () => {
-  await invoke$1('Search.openDetails');
+  await invoke('Search.openDetails');
 };
 const collapseDetails = async () => {
-  await invoke$1('Search.collapseDetails');
+  await invoke('Search.collapseDetails');
 };
 const dismissItem = async () => {
-  await invoke$1('Search.dismissItem');
+  await invoke('Search.dismissItem');
 };
 const focusFirst$1 = async () => {
-  await invoke$1('Search.focusFirst');
+  await invoke('Search.focusFirst');
 };
 const focusIndex$1 = async index => {
-  await invoke$1('Search.focusIndex', index);
+  await invoke('Search.focusIndex', index);
 };
 const selectIndex$1 = async index => {
-  await invoke$1('Search.selectIndex', index);
+  await invoke('Search.selectIndex', index);
 };
 const focusNext$1 = async () => {
-  await invoke$1('Search.focusNext');
+  await invoke('Search.focusNext');
 };
 const handleWheel = async (deltaMode, deltaY) => {
-  await invoke$1('Search.handleWheel', deltaMode, deltaY);
+  await invoke('Search.handleWheel', deltaMode, deltaY);
 };
 const focusNextPage = async () => {
-  await invoke$1('Search.focusPage');
+  await invoke('Search.focusPage');
 };
 const focusPreviousPage = async () => {
-  await invoke$1('Search.focusPreviousPage');
+  await invoke('Search.focusPreviousPage');
 };
 const focusPrevious$1 = async () => {
-  await invoke$1('Search.focusPrevious');
+  await invoke('Search.focusPrevious');
 };
 const toggleSearchDetails = async () => {
-  await invoke$1('Search.toggleSearchDetails');
+  await invoke('Search.toggleSearchDetails');
 };
 const toggleMatchCase = async () => {
-  await invoke$1('Search.toggleMatchCase');
+  await invoke('Search.toggleMatchCase');
 };
 const toggleMatchWholeWord = async () => {
-  await invoke$1('Search.toggleMatchWholeWord');
+  await invoke('Search.toggleMatchWholeWord');
 };
 const togglePreserveCase = async () => {
-  await invoke$1('Search.togglePreserveCase');
+  await invoke('Search.togglePreserveCase');
 };
 const toggleUseRegularExpression = async () => {
-  await invoke$1('Search.toggleUseRegularExpression');
+  await invoke('Search.toggleUseRegularExpression');
 };
 const toggleReplace = async () => {
-  await invoke$1('Search.toggleReplace');
+  await invoke('Search.toggleReplace');
 };
 const open = async () => {
-  await invoke$1('SideBar.openViewlet', 'Search');
+  await invoke('SideBar.openViewlet', 'Search');
 };
 const setLimit = async limit => {
-  await invoke$1('Search.setLimit', limit);
+  await invoke('Search.setLimit', limit);
 };
 const handleListBlur = async () => {
-  await invoke$1('Search.handleListBlur');
+  await invoke('Search.handleListBlur');
 };
 const collapseAll = async () => {
-  await invoke$1('Search.collapseAll');
+  await invoke('Search.collapseAll');
 };
 const copy = async () => {
-  await invoke$1('Search.copy');
+  await invoke('Search.copy');
 };
 const copyPath = async () => {
-  await invoke$1('Search.copyPath');
+  await invoke('Search.copyPath');
 };
 const handleInputCut = async name => {
-  await invoke$1('Search.handleInputCut', name);
+  await invoke('Search.handleInputCut', name);
 };
 const handleInputPaste = async name => {
-  await invoke$1('Search.handleInputPaste', name);
+  await invoke('Search.handleInputPaste', name);
 };
 const handleInputCopy = async name => {
-  await invoke$1('Search.handleInputCopy', name);
+  await invoke('Search.handleInputCopy', name);
 };
 const handleInputSelectionChange = async (name, start, end) => {
-  await invoke$1('Search.handleInputSelectionChange', name, start, end);
+  await invoke('Search.handleInputSelectionChange', name, start, end);
 };
 const handleInputContextMenu = async (name, button, x, y) => {
-  await invoke$1('Search.handleInputConextMenu', name, button, x, y);
+  await invoke('Search.handleInputConextMenu', name, button, x, y);
 };
 const handleContextMenu$2 = async (button, x, y) => {
-  await invoke$1('Search.handleContextMenu', button, x, y);
+  await invoke('Search.handleContextMenu', button, x, y);
 };
 const enableRenderFolderPaths = async () => {
-  await invoke$1('Search.enableRenderFolderPaths');
+  await invoke('Search.enableRenderFolderPaths');
 };
 const disableRenderFolderPaths = async () => {
-  await invoke$1('Search.disableRenderFolderPaths');
+  await invoke('Search.disableRenderFolderPaths');
 };
 
 const Search = {
@@ -4017,25 +3997,25 @@ const Search = {
 };
 
 const show$1 = async () => {
-  return invoke$1('Main.openUri', 'settings://');
+  return invoke('Main.openUri', 'settings://');
 };
 const handleInput$1 = async searchValue => {
-  return invoke$1('Settings.handleInput', searchValue, Script);
+  return invoke('Settings.handleInput', searchValue, Script);
 };
 const usePreviousSearchValue = async () => {
-  return invoke$1('Settings.usePreviousSearchValue');
+  return invoke('Settings.usePreviousSearchValue');
 };
 const useNextSearchValue = async () => {
-  return invoke$1('Settings.useNextSearchValue');
+  return invoke('Settings.useNextSearchValue');
 };
 const clear = async searchValue => {
-  return invoke$1('Settings.clear', searchValue, Script);
+  return invoke('Settings.clear', searchValue, Script);
 };
 const clearHistory = async () => {
-  return invoke$1('Settings.clearHistory');
+  return invoke('Settings.clearHistory');
 };
 const selectTab = async tabId => {
-  return invoke$1('Settings.handleClickTab', tabId);
+  return invoke('Settings.handleClickTab', tabId);
 };
 const selectWorkspace = async () => {
   await selectTab('workspace');
@@ -4050,10 +4030,10 @@ const selectWindow = async () => {
   await selectTab('window');
 };
 const handleScroll = async scrollTop => {
-  await invoke$1('Settings.handleScroll', scrollTop, Script);
+  await invoke('Settings.handleScroll', scrollTop, Script);
 };
 const handleClickFilterButton = async (x, y) => {
-  await invoke$1('Settings.handleClickFilterButton', x, y);
+  await invoke('Settings.handleClickFilterButton', x, y);
 };
 
 const SettingsView = {
@@ -4073,19 +4053,19 @@ const SettingsView = {
 };
 
 const selectIndex = async index => {
-  await invoke$1('Source Control.selectIndex', index);
+  await invoke('Source Control.selectIndex', index);
 };
 const acceptInput = async () => {
-  await invoke$1('Source Control.acceptInput');
+  await invoke('Source Control.acceptInput');
 };
 const handleInput = async text => {
-  await invoke$1('Source Control.handleInput', text, Script$1);
+  await invoke('Source Control.handleInput', text, Script$1);
 };
 const handleClickSourceControlButtons = async (index, name) => {
-  await invoke$1('Source Control.handleClickSourceControlButtons', index, name);
+  await invoke('Source Control.handleClickSourceControlButtons', index, name);
 };
 const handleContextMenu$1 = async (button, x, y) => {
-  await invoke$1('Source Control.handleContextMenu', button, x, y);
+  await invoke('Source Control.handleContextMenu', button, x, y);
 };
 const show = async () => {
   await open$7('Source Control');
@@ -4101,7 +4081,7 @@ const SourceControl = {
 };
 
 const update = async () => {
-  await invoke$1('StatusBar.updateStatusBarItems');
+  await invoke('StatusBar.updateStatusBarItems');
 };
 
 const StatusBar = {
@@ -4109,61 +4089,61 @@ const StatusBar = {
 };
 
 const closeMenu = async () => {
-  await invoke$1('TitleBar.closeMenu');
+  await invoke('TitleBar.closeMenu');
 };
 const focus = async () => {
-  await invoke$1('TitleBar.focus');
+  await invoke('TitleBar.focus');
 };
 const focusFirst = async () => {
-  await invoke$1('TitleBar.focusFirst');
+  await invoke('TitleBar.focusFirst');
 };
 const setTitleTemplate = async template => {
-  await invoke$1('TitleBar.setTitleTemplate', template);
+  await invoke('TitleBar.setTitleTemplate', template);
 };
 const focusIndex = async index => {
-  await invoke$1('TitleBar.focusIndex', index);
+  await invoke('TitleBar.focusIndex', index);
 };
 const focusLast = async () => {
-  await invoke$1('TitleBar.focusLast');
+  await invoke('TitleBar.focusLast');
 };
 const focusNext = async () => {
-  await invoke$1('TitleBar.focusNext');
+  await invoke('TitleBar.focusNext');
 };
 const focusPrevious = async () => {
-  await invoke$1('TitleBar.focusPrevious');
+  await invoke('TitleBar.focusPrevious');
 };
 const handleKeyArrowDown = async () => {
-  await invoke$1('TitleBar.handleKeyArrowDown');
+  await invoke('TitleBar.handleKeyArrowDown');
 };
 const handleKeyArrowLeft = async () => {
-  await invoke$1('TitleBar.handleKeyArrowLeft');
+  await invoke('TitleBar.handleKeyArrowLeft');
 };
 const handleKeyArrowRight = async () => {
-  await invoke$1('TitleBar.handleKeyArrowRight');
+  await invoke('TitleBar.handleKeyArrowRight');
 };
 const handleKeyArrowUp = async () => {
-  await invoke$1('TitleBar.handleKeyArrowUp');
+  await invoke('TitleBar.handleKeyArrowUp');
 };
 const handleKeyEnd = async () => {
-  await invoke$1('TitleBar.handleKeyEnd');
+  await invoke('TitleBar.handleKeyEnd');
 };
 const handleKeyHome = async () => {
-  await invoke$1('TitleBar.handleKeyHome');
+  await invoke('TitleBar.handleKeyHome');
 };
 const handleKeySpace = async () => {
-  await invoke$1('TitleBar.handleKeySpace');
+  await invoke('TitleBar.handleKeySpace');
 };
 const handleKeyEscape = async () => {
-  await invoke$1('TitleBar.handleKeyEscape');
+  await invoke('TitleBar.handleKeyEscape');
 };
 const toggleIndex = async index => {
-  await invoke$1('TitleBar.toggleIndex', index);
+  await invoke('TitleBar.toggleIndex', index);
 };
 const toggleMenu = async () => {
-  await invoke$1('TitleBar.toggleMenu');
+  await invoke('TitleBar.toggleMenu');
 };
 const handleContextMenu = async (button, x, y) => {
-  await invoke$1('TitleBar.handleContextMenu', button, x, y);
+  await invoke('TitleBar.handleContextMenu', button, x, y);
 };
 
 const TitleBarMenuBar = {
@@ -4214,7 +4194,7 @@ const getPortTuple = () => {
 
 // TODO ask webview worker directly
 const getWebViewInfo = async webViewId => {
-  const info = await invoke$1('WebView.getWebViewInfo2', webViewId);
+  const info = await invoke('WebView.getWebViewInfo2', webViewId);
   return info;
 };
 
@@ -4238,8 +4218,6 @@ const waitForFirstEventEvent = async port => {
   return firstEvent;
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
-
 const createPortRpc = async webViewId => {
   // TODO use transforpemssageportrpc
   const {
@@ -4253,7 +4231,7 @@ const createPortRpc = async webViewId => {
   if (firstEvent.data !== 'ready') {
     throw new Error('unexpected first message');
   }
-  const rpc = await MessagePortRpcParent.create({
+  const rpc = await create$2({
     commandMap: {},
     isMessagePortOpen: true,
     messagePort: port1
@@ -4280,7 +4258,7 @@ const WebView = {
 };
 
 const setPath = async path => {
-  await invoke$1('Workspace.setPath', path);
+  await invoke('Workspace.setPath', path);
 };
 const openTmpDir = async () => {
   const tmpDir = await getTmpDir();
@@ -4294,13 +4272,13 @@ const Workspace = {
 };
 
 const load = async url => {
-  await invoke$1('Audio.load', url);
+  await invoke('Audio.load', url);
 };
 const play = async url => {
-  await invoke$1('Audio.play', url);
+  await invoke('Audio.play', url);
 };
 const pause = async () => {
-  await invoke$1('Audio.pause');
+  await invoke('Audio.pause');
 };
 
 const Audio = {
@@ -4456,7 +4434,7 @@ const executeTest = async (name, fn, globals = {}) => {
     // eslint-disable-next-line no-console
     console.info(`PASS ${name} in ${formattedDuration}`);
   }
-  await invoke$1('TestFrameWork.showOverlay', type, background, text);
+  await invoke('TestFrameWork.showOverlay', type, background, text);
 };
 
 const hotReloadEnabled = async () => {
@@ -4475,7 +4453,6 @@ const importScript = async url => {
   }
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
 const importTest = async url => {
   try {
     return await importScript(url);
@@ -4484,8 +4461,6 @@ const importTest = async url => {
   }
 };
 
-/* eslint-disable @typescript-eslint/only-throw-error */
-
 let items = [];
 const push = item => {
   items = [...items, item];
@@ -4509,7 +4484,7 @@ const watchForHotReload = async (platform, href) => {
   }
   const fileUrl = getFileUri(href);
   const callbackCommand = 'FileWatcher.handleEvent';
-  await invoke$1('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
+  await invoke('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
 };
 
 // TODO move this into three steps:
@@ -4634,10 +4609,10 @@ const commandMap = {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$1({
     commandMap: commandMap
   });
-  set$2(rpc);
+  set$1(rpc);
 };
 
 const listen = async () => {