@lvce-editor/output-view 1.19.0 → 2.1.0

package/dist/outputViewWorkerMain.js

@@ -225,8 +225,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -249,14 +249,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -275,8 +275,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -286,8 +286,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -348,8 +348,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -369,8 +369,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -427,8 +427,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -440,8 +440,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -450,9 +450,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+const create$5 = async ({
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -465,8 +465,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -501,61 +501,19 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$1,
+  create: create$5,
   signal: signal$1,
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$2 = id => {
   return callbacks[id];
 };
 const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$4(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -749,9 +707,9 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (id, error) => {
+const create$1$2 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -760,22 +718,22 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+  return create$1$2(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$3 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$3(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -862,29 +820,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -907,24 +842,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -941,7 +939,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -959,15 +957,16 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+const create$4 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -975,8 +974,9 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+const create$2$1 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -984,16 +984,17 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$4({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3
+  create: create$2$1
 };
-const create$4 = async ({
+const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1005,105 +1006,67 @@ const create$4 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$1$1
 };
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$2 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    get(uid) {
-      return states[uid];
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseInt(key);
-      });
-    },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
-          return;
-        }
-        const latest = states[uid];
-        states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
     }
+    return command(...params);
   };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
 };
-const terminate = () => {
-  globalThis.close();
-};
+
+const ToolBar = 'toolbar';
+
+const Button = 1;
+const Div = 4;
+const Input = 6;
+const Text$1 = 12;
+const A = 53;
+const Select$1 = 63;
+const Option$1 = 64;
+
+const Space = 9;
+const PageUp = 10;
+const PageDown = 11;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+
+const ExtensionHostWorker = 44;
+const FileSystemWorker$1 = 209;
+const OutputWorker = 7001;
+const RendererWorker = 1;
 
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
-const create$1 = rpcId => {
+const create$2 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -1117,225 +1080,351 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
+      set$6(rpcId, rpc);
     }
   };
 };
-const DebugWorker$1 = 55;
-const EditorWorker$1 = 99;
-const ExtensionHostWorker = 44;
-const MainProcess$1 = -5;
-const RendererWorker$1 = 1;
-const RendererProcess$1 = 1670;
-const SearchProcess$1 = 77;
-const SearchProcessElectron = 2;
-const SharedProcess$1 = 1;
-const SourceControlWorker = 66;
-const EmbedsProcess$1 = 207;
-const EmbedsWorker = 208;
-const FileSystemWorker$1 = 209;
-const FileSystemProcess$1 = 210;
-const MarkdownWorker$1 = 300;
-const CompletionWorker = 301;
-const ColorPickerWorker = 302;
-const SourceActionWorker = 303;
-const ErrorWorker$1 = 3308;
-const SyntaxHighlightingWorker$1 = 3309;
-const ClipBoardWorker$1 = 3400;
-const ClipBoardProcess$1 = 3401;
-const ExtensionDetailWorker = 3402;
-const ProblemsWorker = 3403;
-const OutputWorker = 7001;
-const RpcId = {
-  __proto__: null,
-  ClipBoardProcess: ClipBoardProcess$1,
-  ClipBoardWorker: ClipBoardWorker$1,
-  ColorPickerWorker,
-  CompletionWorker,
-  DebugWorker: DebugWorker$1,
-  EditorWorker: EditorWorker$1,
-  EmbedsProcess: EmbedsProcess$1,
-  EmbedsWorker,
-  ErrorWorker: ErrorWorker$1,
-  ExtensionDetailWorker,
-  ExtensionHostWorker,
-  FileSystemProcess: FileSystemProcess$1,
-  FileSystemWorker: FileSystemWorker$1,
-  MainProcess: MainProcess$1,
-  MarkdownWorker: MarkdownWorker$1,
-  OutputWorker,
-  ProblemsWorker,
-  RendererProcess: RendererProcess$1,
-  RendererWorker: RendererWorker$1,
-  SearchProcess: SearchProcess$1,
-  SearchProcessElectron,
-  SharedProcess: SharedProcess$1,
-  SourceActionWorker,
-  SourceControlWorker,
-  SyntaxHighlightingWorker: SyntaxHighlightingWorker$1
-};
+
 const {
-  invoke: invoke$9,
-  set: set$9} = create$1(ExtensionHostWorker);
+  dispose: dispose$1,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$5
+} = create$2(ExtensionHostWorker);
+const executeReferenceProvider = async (id, offset) => {
+  // @ts-ignore
+  return invoke$3('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+const executeFileReferenceProvider = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+const getRuntimeStatus = async extensionId => {
+  // @ts-ignore
+  return invoke$3('ExtensionHost.getRuntimeStatus', extensionId);
+};
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$5(mockRpc);
+  return mockRpc;
+};
+
 const ExtensionHost = {
   __proto__: null,
-  invoke: invoke$9,
-  set: set$9
+  dispose: dispose$1,
+  executeFileReferenceProvider,
+  executeReferenceProvider,
+  getRuntimeStatus,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  registerMockRpc: registerMockRpc$1,
+  set: set$5
 };
+
 const {
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$7,
-  set: set$7,
-  dispose: dispose$7
-} = create$1(FileSystemWorker$1);
+  dispose,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$4
+} = create$2(FileSystemWorker$1);
 const remove = async dirent => {
-  return invoke$7('FileSystem.remove', dirent);
+  return invoke$2('FileSystem.remove', dirent);
 };
 const readDirWithFileTypes = async uri => {
-  return invoke$7('FileSystem.readDirWithFileTypes', uri);
+  return invoke$2('FileSystem.readDirWithFileTypes', uri);
 };
 const getPathSeparator = async root => {
-  // @ts-ignore
-  return invoke$7('FileSystem.getPathSeparator', root);
+  return invoke$2('FileSystem.getPathSeparator', root);
 };
 const getRealPath = async path => {
-  return invoke$7('FileSystem.getRealPath', path);
+  return invoke$2('FileSystem.getRealPath', path);
 };
 const stat = async dirent => {
-  return invoke$7('FileSystem.stat', dirent);
+  return invoke$2('FileSystem.stat', dirent);
 };
 const createFile = async uri => {
-  return invoke$7('FileSystem.writeFile', uri, '');
+  return invoke$2('FileSystem.writeFile', uri, '');
 };
 const readFile$1 = async uri => {
-  return invoke$7('FileSystem.readFile', uri);
+  return invoke$2('FileSystem.readFile', uri);
 };
 const writeFile$1 = async (uri, content) => {
-  return invoke$7('FileSystem.writeFile', uri, content);
+  return invoke$2('FileSystem.writeFile', uri, content);
 };
 const mkdir = async uri => {
-  return invoke$7('FileSystem.mkdir', uri);
+  return invoke$2('FileSystem.mkdir', uri);
 };
 const rename = async (oldUri, newUri) => {
-  return invoke$7('FileSystem.rename', oldUri, newUri);
+  return invoke$2('FileSystem.rename', oldUri, newUri);
 };
 const copy = async (oldUri, newUri) => {
-  return invoke$7('FileSystem.copy', oldUri, newUri);
+  return invoke$2('FileSystem.copy', oldUri, newUri);
 };
 const exists = async uri => {
-  // @ts-ignore
-  return invoke$7('FileSystem.exists', uri);
+  return invoke$2('FileSystem.exists', uri);
 };
-const getFolderSize$1 = async uri => {
-  // @ts-ignore
-  return invoke$7('FileSystem.getFolderSize', uri);
+const getFolderSize = async uri => {
+  return invoke$2('FileSystem.getFolderSize', uri);
 };
 const readFileAsBlob = async uri => {
-  // @ts-ignore
-  return invoke$7('FileSystem.readFileAsBlob', uri);
+  return invoke$2('FileSystem.readFileAsBlob', uri);
 };
 const appendFile = async (uri, text) => {
-  // @ts-ignore
-  return invoke$7('FileSystem.appendFile', uri, text);
+  return invoke$2('FileSystem.appendFile', uri, text);
+};
+const watchFile = async (watchId, uri, rpcId) => {
+  await invoke$2('FileSystem.watchFile', watchId, uri, rpcId);
+};
+const unwatchFile = async watchId => {
+  await invoke$2('FileSystem.unwatchFile', watchId);
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$4(mockRpc);
+  return mockRpc;
 };
+
 const FileSystemWorker = {
   __proto__: null,
   appendFile,
   copy,
   createFile,
-  dispose: dispose$7,
+  dispose,
   exists,
-  getFolderSize: getFolderSize$1,
+  getFolderSize,
   getPathSeparator,
   getRealPath,
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$7,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
   mkdir,
   readDirWithFileTypes,
   readFile: readFile$1,
   readFileAsBlob,
+  registerMockRpc,
   remove,
   rename,
-  set: set$7,
+  set: set$4,
   stat,
+  unwatchFile,
+  watchFile,
   writeFile: writeFile$1
 };
+
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3$1} = create$1(RendererWorker$1);
-const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$3
+} = create$2(RendererWorker);
+const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
-const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
-const activateByEvent$1 = event => {
-  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+const activateByEvent = (event, assetDir, platform) => {
+  return invoke$1('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$1('FilePicker.showSaveFilePicker');
+};
+const getLogsDir$1 = async () => {
+  // @ts-ignore
+  return invoke$1('PlatformPaths.getLogsDir');
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$1 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    get(uid) {
+      return states[uid];
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        oldState,
+        newState
+      };
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseInt(key);
+      });
+    },
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          oldState,
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latest = states[uid];
+        states[uid] = {
+          oldState: latest.oldState,
+          newState: newerState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        newState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
 };
-const RendererWorker = {
-  __proto__: null,
-  activateByEvent: activateByEvent$1,
-  invoke: invoke$3,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$2,
-  set: set$3$1};
 
 const {
-  set: set$3,
   readFile,
+  set: set$2,
   writeFile
 } = FileSystemWorker;
 
+const getTextFromParts = parts => {
+  let result = '';
+  for (const part of parts) {
+    result += part.value;
+  }
+  return result;
+};
 const filterItems = (items, filterValue) => {
   if (!filterValue) {
     return items;
   }
-  return items.filter(item => item.includes(filterValue));
+  return items.filter(parts => getTextFromParts(parts).includes(filterValue));
 };
 
 const isFileNotFoundError = error => {
   return error?.message?.includes('File not found') ?? false;
 };
 
+const RE_URL = /(?:https?:\/\/\S+|file:\/\/\S+)/;
+const getLinkMatch = text => {
+  const match = text.match(RE_URL);
+  return match ? match[0] : null;
+};
+
+const Text = 1;
+const Link = 2;
+
+const parseLine = line => {
+  const parts = [];
+  let rest = line;
+  while (rest.length > 0) {
+    const match = getLinkMatch(rest);
+    if (!match) {
+      if (rest) {
+        parts.push({
+          type: Text,
+          value: rest
+        });
+      }
+      break;
+    }
+    const index = rest.indexOf(match);
+    if (index > 0) {
+      parts.push({
+        type: Text,
+        value: rest.slice(0, index)
+      });
+    }
+    parts.push({
+      type: Link,
+      value: match
+    });
+    rest = rest.slice(index + match.length);
+  }
+  if (parts.length === 0) {
+    return [{
+      type: Text,
+      value: ''
+    }];
+  }
+  return parts;
+};
+
 const loadLines = async uri => {
   try {
     // TODO use log stream, updating the output when the file is changed
     const content = await readFile(uri);
-    const lines = content.split('\n');
+    const lines = content.split('\n').map(parseLine);
     return {
+      code: 0,
       error: '',
-      lines,
-      code: 0
+      lines
     };
   } catch (error) {
     if (isFileNotFoundError(error)) {
       return {
+        code: 1,
         error: `log file not found`,
-        lines: [],
-        code: 1
+        lines: []
       };
     }
     return {
+      code: 2,
       error: `${error}`,
-      lines: [],
-      code: 2
+      lines: []
     };
   }
 };
 
 const clear = async state => {
   const {
-    selectedOption,
+    filterValue,
     options,
-    filterValue
+    selectedOption
   } = state;
   // TODO make uri a property of state to make the code simpler
   const option = options.find(option => option.id === selectedOption);
@@ -1347,17 +1436,17 @@ const clear = async state => {
   } = option;
   await writeFile(uri, '');
   const {
-    lines,
     code,
-    error
+    error,
+    lines
   } = await loadLines(uri);
   const filteredItems = filterItems(lines, filterValue);
   return {
     ...state,
-    listItems: lines,
     error,
     errorCode: code,
-    filteredItems
+    filteredItems,
+    listItems: lines
   };
 };
 
@@ -1373,12 +1462,13 @@ const Script = 2;
 
 const {
   get,
-  set: set$2,
-  wrapCommand,
-  wrapGetter,
-  getKeys,
   getCommandIds,
-  registerCommands} = create$2();
+  getKeys,
+  registerCommands,
+  set: set$1,
+  wrapCommand,
+  wrapGetter
+} = create$1();
 
 const create = (id, uri, x, y, width, height, platform, parentId) => {
   number(parentId);
@@ -1412,7 +1502,7 @@ const create = (id, uri, x, y, width, height, platform, parentId) => {
     x,
     y
   };
-  set$2(id, state, state);
+  set$1(id, state, state);
 };
 
 const isEqual$2 = (oldState, newState) => {
@@ -1447,8 +1537,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
@@ -1487,52 +1577,15 @@ const focusIndex = (state, index) => {
   };
 };
 
-const ToolBar = 'toolbar';
-const AriaRoles = {
-  __proto__: null,
-  ToolBar};
-const Space = 9;
-const PageUp = 10;
-const PageDown = 11;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-const KeyCode = {
-  __proto__: null,
-  DownArrow,
-  End,
-  Home,
-  LeftArrow,
-  PageDown,
-  PageUp,
-  RightArrow,
-  Space,
-  UpArrow
-};
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
-const Button = 1;
-const Div = 4;
-const Input = 6;
-const Text = 12;
-const Select$1 = 63;
-const Option$1 = 64;
-const VirtualDomElements = {
-  __proto__: null,
-  Button,
-  Div,
-  Input,
-  Option: Option$1,
-  Select: Select$1};
+
 const text = data => {
   return {
-    type: Text,
+    childCount: 0,
     text: data,
-    childCount: 0
+    type: Text$1
   };
 };
 
@@ -1540,53 +1593,53 @@ const FocusProblems = 19;
 
 const getKeyBindings = () => {
   return [{
-    key: KeyCode.DownArrow,
     command: 'Problems.focusNext',
+    key: DownArrow,
     when: FocusProblems
   }, {
-    key: KeyCode.UpArrow,
     command: 'Problems.focusPrevious',
+    key: UpArrow,
     when: FocusProblems
   }, {
-    key: KeyCode.Home,
     command: 'Problems.focusFirst',
+    key: Home,
     when: FocusProblems
   }, {
-    key: KeyCode.PageUp,
     command: 'Problems.focusFirst',
+    key: PageUp,
     when: FocusProblems
   }, {
-    key: KeyCode.PageDown,
     command: 'Problems.focusLast',
+    key: PageDown,
     when: FocusProblems
   }, {
-    key: KeyCode.End,
     command: 'Problems.focusLast',
+    key: End,
     when: FocusProblems
   }, {
-    key: KeyCode.Space,
     command: 'Problems.selectCurrent',
+    key: Space,
     when: FocusProblems
   }, {
-    key: KeyCode.Home,
     command: 'Problems.focusFirst',
+    key: Home,
     when: FocusProblems
   }, {
-    key: KeyCode.End,
     command: 'Problems.focusLast',
+    key: End,
     when: FocusProblems
   }, {
-    key: KeyCode.LeftArrow,
     command: 'Problems.handleArrowLeft',
+    key: LeftArrow,
     when: FocusProblems
   }, {
-    key: KeyCode.RightArrow,
     command: 'Problems.handleArrowRight',
+    key: RightArrow,
     when: FocusProblems
   }];
 };
 
-const Filter$1 = 'filter';
+const Filter$2 = 'filter';
 const Output$1 = 'output';
 const MainProcess = 'MainProcess';
 const SharedProcess = 'SharedProcess';
@@ -1637,8 +1690,8 @@ const handleFilterInput = async (state, value, inputSource = User) => {
   const filteredItems = filterItems(listItems, value);
   return {
     ...state,
-    filterValue: value,
     filteredItems: filteredItems,
+    filterValue: value,
     inputSource
   };
 };
@@ -1648,14 +1701,6 @@ const createWatchId = () => {
   return watchId;
 };
 
-const {
-  invoke: invoke$1,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$1,
-  set: set$1,
-  activateByEvent
-} = RendererWorker;
-
 const handleFileChange = async watchId => {
   const keys = getKeys();
   for (const key of keys) {
@@ -1682,14 +1727,12 @@ const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
   try {
     if (oldWatchId) {
       unregisterWatchCallback(oldWatchId);
-      // @ts-ignore
-      await FileSystemWorker.invoke('FileSystem.unwatchFile', oldWatchId);
+      await unwatchFile(oldWatchId);
     }
     // TODO dispose old watcher
-    const rpcId = RpcId.OutputWorker;
+    const rpcId = OutputWorker;
     registerWatchCallback(newWatchId, handleFileChange);
-    // @ts-ignore
-    await FileSystemWorker.invoke('FileSystem.watchFile', newWatchId, /* path */uri, rpcId);
+    await watchFile(newWatchId, uri, rpcId);
   } catch {
     // ignore
   }
@@ -1697,8 +1740,8 @@ const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
 
 const selectChannel = async (state, id) => {
   const {
-    options,
     filterValue,
+    options,
     watchId
   } = state;
   const matchingOption = options.find(option => option.id === id);
@@ -1707,9 +1750,9 @@ const selectChannel = async (state, id) => {
   }
   // TODO potential race condtion when switching output channels fast
   const {
-    lines,
+    code,
     error,
-    code
+    lines
   } = await loadLines(matchingOption.uri);
 
   // TODO memory leak and race condition, need to dispose file watcher of previous uri
@@ -1720,8 +1763,8 @@ const selectChannel = async (state, id) => {
     ...state,
     error,
     errorCode: code,
-    listItems: lines,
     filteredItems,
+    listItems: lines,
     selectedOption: id,
     watchId: newWatchId
   };
@@ -1748,8 +1791,8 @@ const createExtensionHostRpc = async () => {
 };
 
 const {
-  set,
-  invoke
+  invoke,
+  set
 } = ExtensionHost;
 
 const initializeExtensionHost = async () => {
@@ -1758,7 +1801,7 @@ const initializeExtensionHost = async () => {
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
-  await sendMessagePortToFileSystemWorker$1(port, RpcId.OutputWorker);
+  await sendMessagePortToFileSystemWorker$1(port, OutputWorker);
 };
 
 const createFileSystemWorkerRpc = async () => {
@@ -1775,13 +1818,21 @@ const createFileSystemWorkerRpc = async () => {
 
 const initializeFileSystemWorker = async () => {
   const rpc = await createFileSystemWorkerRpc();
-  set$3(rpc);
+  set$2(rpc);
 };
 
 const initialize = async () => {
   await Promise.all([initializeFileSystemWorker(), initializeExtensionHost()]);
 };
 
+const getLogsDir = async () => {
+  try {
+    return await getLogsDir$1();
+  } catch {
+    return `file:///tmp`;
+  }
+};
+
 const Web = 1;
 
 const getSelectedItem = (selectedOption, platform) => {
@@ -1807,6 +1858,7 @@ const i18nString = (key, placeholders = emptyObject) => {
 };
 
 const ClearOutput = 'clear output';
+const Filter$1 = 'Filter';
 const LogFileNotFound$1 = 'The log file was not found.';
 const Settings = 'Settings';
 const TurnOffAutoScroll = 'Turn auto scrolling off';
@@ -1823,20 +1875,23 @@ const settings = () => {
 const logFileNotFound = () => {
   return i18nString(LogFileNotFound$1);
 };
+const filter = () => {
+  return i18nString(Filter$1);
+};
 
 const loadButtons = () => {
   return [{
+    icon: 'MaskIconClearAll',
     id: Clear,
-    label: clearOutput(),
-    icon: 'MaskIconClearAll'
+    label: clearOutput()
   }, {
+    icon: 'MaskIconListFlat',
     id: ScrollLock,
-    label: turnOffAutoScroll(),
-    icon: 'MaskIconListFlat'
+    label: turnOffAutoScroll()
   }, {
+    icon: 'MaskIconSettingsGear',
     id: Settings$1,
-    label: settings(),
-    icon: 'MaskIconSettingsGear'
+    label: settings()
   }];
 };
 
@@ -1849,6 +1904,7 @@ const getExtensionOptions = async () => {
     // TODO make api more declarative:
     // output channels are registered in extension manifest
     // only downside: it might show channels for extensions that are not active
+    // @ts-ignore
     await activateByEvent('onOutput');
     // @ts-ignore
     const channels = await invoke('Output.getEnabledProviders');
@@ -1859,7 +1915,7 @@ const getExtensionOptions = async () => {
   }
 };
 
-const loadOptions = async platform => {
+const loadOptions = async (platform, logsFolderPath) => {
   const extensionOptions = await getExtensionOptions();
   if (platform === Web) {
     return extensionOptions;
@@ -1867,11 +1923,11 @@ const loadOptions = async platform => {
   return [{
     id: MainProcess,
     label: 'Main Process',
-    uri: 'file:///tmp/log-main-process.txt'
+    uri: `${logsFolderPath}/log-main-process.txt`
   }, {
     id: SharedProcess,
     label: 'Shared Process',
-    uri: 'file:///tmp/log-shared-process.txt'
+    uri: `${logsFolderPath}/log-shared-process.txt`
   }, ...extensionOptions];
 };
 
@@ -1899,8 +1955,8 @@ const restoreState = savedState => {
   const scrollLockEnabled = getSavedScrollLockEnabled(savedState);
   return {
     filterValue,
-    selectedOption,
-    scrollLockEnabled
+    scrollLockEnabled,
+    selectedOption
   };
 };
 
@@ -1922,13 +1978,14 @@ const loadContent = async (state, savedState) => {
     watchId
   } = state;
   const collapsedUris = getSavedCollapsedUris(savedState);
+  const logsFolderPath = await getLogsDir();
   const {
-    selectedOption,
     filterValue,
-    scrollLockEnabled
+    scrollLockEnabled,
+    selectedOption
   } = restoreState(savedState);
   const selectedId = getSelectedItem(selectedOption, platform);
-  const options = await loadOptions(platform);
+  const options = await loadOptions(platform, logsFolderPath);
   const option = getMatchingOpen(options, selectedId);
   if (!option) {
     throw new Error('option not found');
@@ -1937,9 +1994,9 @@ const loadContent = async (state, savedState) => {
     uri
   } = option;
   const {
-    lines,
+    code,
     error,
-    code
+    lines
   } = await loadLines(uri);
   const filteredItems = filterItems(lines, filterValue);
   const newWatchId = createWatchId();
@@ -1984,22 +2041,22 @@ const refresh = async state => {
     return state;
   }
   const {
-    lines,
+    code,
     error,
-    code
+    lines
   } = await loadLines(matchingOption.uri);
   const filteredItems = filterItems(lines, filterValue);
   return {
     ...state,
-    listItems: lines,
-    filteredItems,
     error,
-    errorCode: code
+    errorCode: code,
+    filteredItems,
+    listItems: lines
   };
 };
 
 const renderFilterValue = (oldState, newState) => {
-  return ['Viewlet.setValueByName', newState.parentId, Filter$1, newState.filterValue];
+  return ['Viewlet.setValueByName', newState.parentId, Filter$2, newState.filterValue];
 };
 
 const Filter = 'Filter';
@@ -2018,12 +2075,30 @@ const Error$1 = 'Error';
 const Line = 'Line';
 
 const parentNode = {
-  type: VirtualDomElements.Div,
+  childCount: 1,
   className: Line,
-  childCount: 1
+  type: Div
 };
-const getLineDom = line => {
-  return [parentNode, text(line)];
+const getLineDom = parts => {
+  const children = [];
+  for (const part of parts) {
+    if (part.type === Text) {
+      children.push(text(part.value));
+    } else {
+      children.push({
+        childCount: 1,
+        href: part.value,
+        rel: 'noopener noreferrer',
+        target: '_blank',
+        type: A
+      }, text(part.value));
+    }
+  }
+  const lineNode = {
+    ...parentNode,
+    childCount: children.length
+  };
+  return [lineNode, ...children];
 };
 
 const getContentDom = (lines, error) => {
@@ -2031,11 +2106,11 @@ const getContentDom = (lines, error) => {
     return [];
   }
   return [{
-    type: VirtualDomElements.Div,
+    childCount: lines.length,
     className: OutputContent,
     role: 'log',
     tabIndex: 0,
-    childCount: lines.length
+    type: Div
   }, ...lines.flatMap(getLineDom)];
 };
 
@@ -2043,10 +2118,10 @@ const LogFileNotFound = 1;
 
 const getLogFileNotFoundDom = () => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: Message,
     tabIndex: 0,
-    childCount: 1
+    type: Div
   }, text(logFileNotFound())];
 };
 
@@ -2058,18 +2133,18 @@ const getErrorDom = (errorCode, error) => {
     return getLogFileNotFoundDom();
   }
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: Error$1,
     tabIndex: 0,
-    childCount: 1
+    type: Div
   }, text(error)];
 };
 
 const getOutputVirtualDom = (lines, errorCode, error) => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: mergeClassNames(Viewlet, Output),
-    childCount: 1
+    type: Div
   }, ...getContentDom(lines, error), ...getErrorDom(errorCode, error)];
 };
 
@@ -2086,10 +2161,10 @@ const renderSelectedItem = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
-    case RenderItems:
-      return renderItems;
     case RenderFilterValue:
       return renderFilterValue;
+    case RenderItems:
+      return renderItems;
     case RenderSelectedItem:
       return renderSelectedItem;
     default:
@@ -2108,10 +2183,10 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
-  set$2(uid, newState, newState);
+  set$1(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2126,20 +2201,20 @@ const HandleButtonClick = 'handleButtonClick';
 
 const getActionButtonVirtualDom = button => {
   const {
+    icon,
     id,
-    label,
-    icon
+    label
   } = button;
   return [{
-    type: VirtualDomElements.Button,
+    childCount: 1,
     className: IconButton,
     name: id,
+    onClick: HandleButtonClick,
     title: label,
-    childCount: 1,
-    onClick: HandleButtonClick
+    type: Button
   }, {
-    type: VirtualDomElements.Div,
-    className: mergeClassNames(MaskIcon, icon)
+    className: mergeClassNames(MaskIcon, icon),
+    type: Div
   }];
 };
 
@@ -2148,18 +2223,18 @@ const getActionButtonsVirtualDom = buttons => {
 };
 
 const getFilterVirtualDom = () => {
-  const placeholder = 'Filter';
+  const placeholder = filter();
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: Filter,
-    childCount: 1
+    type: Div
   }, {
-    type: VirtualDomElements.Input,
-    className: mergeClassNames(InputBox, FilterInput),
     childCount: 0,
-    placeholder,
+    className: mergeClassNames(InputBox, FilterInput),
+    name: Filter$2,
     onInput: HandleFilterInput,
-    name: Filter$1
+    placeholder,
+    type: Input
   }];
 };
 
@@ -2169,20 +2244,20 @@ const getOptionVirtualDom = option => {
     label
   } = option;
   return [{
-    type: VirtualDomElements.Option,
-    className: Option,
     childCount: 1,
+    className: Option,
+    type: Option$1,
     value: id
   }, text(label)];
 };
 
 const getSelectVirtualDom = options => {
   return [{
-    type: VirtualDomElements.Select,
-    className: Select,
     childCount: options.length,
+    className: Select,
     name: Output$1,
-    onChange: HandleSelect
+    onChange: HandleSelect,
+    type: Select$1
   }, ...options.flatMap(getOptionVirtualDom)];
 };
 
@@ -2194,17 +2269,17 @@ const getChildCount = buttonsLength => {
 const getActionsVirtualDom = (options, buttons) => {
   const childCount = getChildCount(buttons.length);
   return [{
-    type: VirtualDomElements.Div,
+    childCount,
     className: Actions,
-    role: AriaRoles.ToolBar,
-    childCount
+    role: ToolBar,
+    type: Div
   }, ...getFilterVirtualDom(), ...getSelectVirtualDom(options), ...getActionButtonsVirtualDom(buttons)];
 };
 
 const renderActions = state => {
   const {
-    options,
-    buttons
+    buttons,
+    options
   } = state;
   const dom = getActionsVirtualDom(options, buttons);
   return dom;
@@ -2244,25 +2319,42 @@ const resize = (state, dimensions) => {
   };
 };
 
+const serializeLinePart = part => {
+  return part.value;
+};
+const serializeLineParts = parts => {
+  return parts.map(serializeLinePart).join('');
+};
+const serializeLines = lines => {
+  return lines.map(serializeLineParts).join('\n');
+};
+
 const saveOutputAs = async state => {
-  // TODO show open file picker
-  // TODO write to file
+  const uri = await showSaveFilePicker();
+  if (!uri) {
+    return state;
+  }
+  const {
+    listItems
+  } = state;
+  const content = serializeLines(listItems);
+  await writeFile(uri, content);
   // TODO if error occurs, show error dialog
   return state;
 };
 
 const saveState = state => {
   const {
-    filterValue,
     collapsedUris,
-    selectedOption,
-    scrollLockEnabled
+    filterValue,
+    scrollLockEnabled,
+    selectedOption
   } = state;
   return {
-    filterValue,
     collapsedUris,
-    selectedOption,
-    scrollLockEnabled
+    filterValue,
+    scrollLockEnabled,
+    selectedOption
   };
 };
 
@@ -2306,7 +2398,7 @@ const commandMap = {
   'Output.renderActions': wrapGetter(renderActions),
   'Output.renderEventListeners': renderEventListeners,
   'Output.resize': resize,
-  'Output.saveOutputAs': wrapCommand(saveOutputAs),
+  'Output.saveAs': wrapCommand(saveOutputAs),
   'Output.saveState': wrapGetter(saveState),
   'Output.selectChannel': wrapCommand(selectChannel),
   'Output.setLogLevel': setLogLevel,
@@ -2322,7 +2414,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMapRef
   });
-  set$1(rpc);
+  set$3(rpc);
 };
 
 const main = async () => {