@lvce-editor/static-server 0.57.1 → 0.57.3

package/static/{87d512e → f6bb00e}/packages/output-view/dist/outputViewWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -472,13 +515,13 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -491,7 +534,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$5(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -663,7 +706,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -836,7 +879,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
@@ -875,7 +918,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
@@ -965,7 +1008,7 @@ const WebWorkerRpcClient = {
   create: create$4
 };
 
-const toCommandId$1 = key => {
+const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
 };
@@ -1037,7 +1080,7 @@ const create$2 = () => {
     },
     getCommandIds() {
       const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId$1);
+      const ids = keys.map(toCommandId);
       return ids;
     },
     registerCommands(commandMap) {
@@ -1049,6 +1092,275 @@ const terminate = () => {
   globalThis.close();
 };
 
+const rpcs = Object.create(null);
+const set$g = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+
+const create$1 = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$g(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+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);
+const ExtensionHost = {
+  __proto__: null,
+  invoke: invoke$9,
+  set: set$9
+};
+const {
+  invoke: invoke$7,
+  invokeAndTransfer: invokeAndTransfer$7,
+  set: set$7,
+  dispose: dispose$7
+} = create$1(FileSystemWorker$1);
+const remove = async dirent => {
+  return invoke$7('FileSystem.remove', dirent);
+};
+const readDirWithFileTypes = async uri => {
+  return invoke$7('FileSystem.readDirWithFileTypes', uri);
+};
+const getPathSeparator = async root => {
+  // @ts-ignore
+  return invoke$7('FileSystem.getPathSeparator', root);
+};
+const getRealPath = async path => {
+  return invoke$7('FileSystem.getRealPath', path);
+};
+const stat = async dirent => {
+  return invoke$7('FileSystem.stat', dirent);
+};
+const createFile = async uri => {
+  return invoke$7('FileSystem.writeFile', uri, '');
+};
+const readFile$1 = async uri => {
+  return invoke$7('FileSystem.readFile', uri);
+};
+const writeFile$1 = async (uri, content) => {
+  return invoke$7('FileSystem.writeFile', uri, content);
+};
+const mkdir = async uri => {
+  return invoke$7('FileSystem.mkdir', uri);
+};
+const rename = async (oldUri, newUri) => {
+  return invoke$7('FileSystem.rename', oldUri, newUri);
+};
+const copy = async (oldUri, newUri) => {
+  return invoke$7('FileSystem.copy', oldUri, newUri);
+};
+const exists = async uri => {
+  // @ts-ignore
+  return invoke$7('FileSystem.exists', uri);
+};
+const getFolderSize$1 = async uri => {
+  // @ts-ignore
+  return invoke$7('FileSystem.getFolderSize', uri);
+};
+const readFileAsBlob = async uri => {
+  // @ts-ignore
+  return invoke$7('FileSystem.readFileAsBlob', uri);
+};
+const appendFile = async (uri, text) => {
+  // @ts-ignore
+  return invoke$7('FileSystem.appendFile', uri, text);
+};
+const FileSystemWorker = {
+  __proto__: null,
+  appendFile,
+  copy,
+  createFile,
+  dispose: dispose$7,
+  exists,
+  getFolderSize: getFolderSize$1,
+  getPathSeparator,
+  getRealPath,
+  invoke: invoke$7,
+  invokeAndTransfer: invokeAndTransfer$7,
+  mkdir,
+  readDirWithFileTypes,
+  readFile: readFile$1,
+  readFileAsBlob,
+  remove,
+  rename,
+  set: set$7,
+  stat,
+  writeFile: writeFile$1
+};
+const {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$3$1} = create$1(RendererWorker$1);
+const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const activateByEvent$1 = event => {
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+};
+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,
+  writeFile
+} = FileSystemWorker;
+
+const filterItems = (items, filterValue) => {
+  if (!filterValue) {
+    return items;
+  }
+  return items.filter(item => item.includes(filterValue));
+};
+
+const isFileNotFoundError = error => {
+  return error?.message?.includes('File not found') ?? false;
+};
+
+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');
+    return {
+      error: '',
+      lines,
+      code: 0
+    };
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      return {
+        error: `log file not found`,
+        lines: [],
+        code: 1
+      };
+    }
+    return {
+      error: `${error}`,
+      lines: [],
+      code: 2
+    };
+  }
+};
+
+const clear = async state => {
+  const {
+    selectedOption,
+    options,
+    filterValue
+  } = state;
+  // TODO make uri a property of state to make the code simpler
+  const option = options.find(option => option.id === selectedOption);
+  if (!option) {
+    return state;
+  }
+  const {
+    uri
+  } = option;
+  await writeFile(uri, '');
+  const {
+    lines,
+    code,
+    error
+  } = await loadLines(uri);
+  const filteredItems = filterItems(lines, filterValue);
+  return {
+    ...state,
+    listItems: lines,
+    error,
+    errorCode: code,
+    filteredItems
+  };
+};
+
 const closeFindWidget = async state => {
   // TODO
   return {
@@ -1060,55 +1372,67 @@ const User = 1;
 const Script = 2;
 
 const {
-  get: get$1,
-  set: set$4,
+  get,
+  set: set$2,
   wrapCommand,
-  wrapGetter
-} = create$2();
+  wrapGetter,
+  getKeys,
+  getCommandIds,
+  registerCommands} = create$2();
 
-const create$1 = (id, uri, x, y, width, height, platform) => {
+const create = (id, uri, x, y, width, height, platform, parentId) => {
+  number(parentId);
   const state = {
-    uid: id,
-    uri,
+    buttons: [],
+    collapsedUris: [],
+    error: '',
+    errorCode: 0,
+    filteredItems: [],
+    filterValue: '',
     focusedIndex: -2,
-    message: '',
-    itemHeight: 22,
-    x,
-    y,
-    width,
     height,
-    filterValue: '',
     inputSource: User,
-    minLineY: 0,
-    maxLineY: 0,
+    itemHeight: 22,
     listItems: [],
-    collapsedUris: [],
+    logLevel: 0,
+    maxLineY: 0,
+    message: '',
+    minLineY: 0,
+    options: [],
+    parentId,
+    platform,
+    scrollLockEnabled: false,
     selectedOption: '',
     smallWidthBreakPoint: 650,
+    uid: id,
+    uri,
+    watchId: 0,
+    width,
     workspaceUri: '',
-    options: [],
-    error: '',
-    errorCode: 0,
-    buttons: [],
-    filteredItems: [],
-    platform
+    x,
+    y
   };
-  set$4(id, state, state);
+  set$2(id, state, state);
 };
 
-const isEqual$1 = (oldState, newState) => {
+const isEqual$2 = (oldState, newState) => {
   return newState.inputSource === User || oldState.filterValue === newState.filterValue;
 };
 
+const isEqual$1 = (oldState, newState) => {
+  return oldState.selectedOption === newState.selectedOption && oldState.listItems === newState.listItems && oldState.filteredItems === newState.filteredItems;
+};
+
 const isEqual = (oldState, newState) => {
-  return oldState.filterValue === newState.filterValue && oldState.message === newState.message && oldState.options === newState.options && oldState.listItems === newState.listItems;
+  return oldState.selectedOption === newState.selectedOption;
 };
 
 const RenderItems = 1;
 const RenderFilterValue = 2;
+const RenderSelectedItem = 3;
 
-const modules = [isEqual, isEqual$1];
-const numbers = [RenderItems, RenderFilterValue];
+const modules = [isEqual$1, isEqual$2, isEqual];
+const numbers = [RenderItems, RenderFilterValue, RenderSelectedItem];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1125,28 +1449,42 @@ const diff2 = uid => {
   const {
     oldState,
     newState
-  } = get$1(uid);
+  } = get(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
 };
 
-const focusIndex = (state, index) => {
+const disableScrollLock = async state => {
+  const {
+    scrollLockEnabled
+  } = state;
+  if (!scrollLockEnabled) {
+    return state;
+  }
   return {
     ...state,
-    focusedIndex: index
+    scrollLockEnabled: false
   };
 };
 
-const commandMapRef = {};
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
+const enableScrollLock = async state => {
+  const {
+    scrollLockEnabled
+  } = state;
+  if (scrollLockEnabled) {
+    return state;
+  }
+  return {
+    ...state,
+    scrollLockEnabled: true
+  };
 };
-const getCommandIds = () => {
-  const keys = Object.keys(commandMapRef);
-  const ids = keys.map(toCommandId);
-  return ids;
+
+const focusIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index
+  };
 };
 
 const ToolBar = 'toolbar';
@@ -1177,19 +1515,19 @@ const KeyCode = {
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
-const Button$1 = 1;
+const Button = 1;
 const Div = 4;
 const Input = 6;
 const Text = 12;
-const Select$2 = 63;
+const Select$1 = 63;
 const Option$1 = 64;
 const VirtualDomElements = {
   __proto__: null,
-  Button: Button$1,
+  Button,
   Div,
   Input,
   Option: Option$1,
-  Select: Select$2};
+  Select: Select$1};
 const text = data => {
   return {
     type: Text,
@@ -1248,169 +1586,35 @@ const getKeyBindings = () => {
   }];
 };
 
-const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
-  rpcs[id] = rpc;
+const Filter$1 = 'filter';
+const Output$1 = 'output';
+const MainProcess = 'MainProcess';
+const SharedProcess = 'SharedProcess';
+const Clear = 'Clear';
+const Settings$1 = 'Settings';
+const ScrollLock = 'ScrollLock';
+
+const noop = async state => {
+  return state;
 };
-const get = id => {
-  return rpcs[id];
+const getClickHandler = name => {
+  switch (name) {
+    case Clear:
+      return clear;
+    default:
+      return noop;
+  }
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const handleButtonClick = async (state, name) => {
+  const fn = getClickHandler(name);
+  return fn(state);
+};
 
-const create = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$g(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-const ExtensionHostWorker = 44;
-const RendererWorker$1 = 1;
-const FileSystemWorker$1 = 209;
-const {
-  invoke: invoke$9,
-  set: set$9} = create(ExtensionHostWorker);
-const ExtensionHost = {
-  __proto__: null,
-  invoke: invoke$9,
-  set: set$9
-};
-const {
-  invoke: invoke$7,
-  set: set$7} = create(FileSystemWorker$1);
-const readFile$1 = async uri => {
-  return invoke$7('FileSystem.readFile', uri);
-};
-const writeFile$1 = async (uri, content) => {
-  return invoke$7('FileSystem.writeFile', uri, content);
-};
-const FileSystemWorker = {
-  __proto__: null,
-  readFile: readFile$1,
-  set: set$7,
-  writeFile: writeFile$1
-};
-const {
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3} = create(RendererWorker$1);
-const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const RendererWorker = {
-  __proto__: null,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$2,
-  set: set$3};
-
-const {
-  set: set$2,
-  readFile,
-  writeFile
-} = FileSystemWorker;
-
-const isFileNotFoundError = error => {
-  return error.message.includes('File not found');
-};
-
-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');
-    return {
-      error: '',
-      lines,
-      code: 0
-    };
-  } catch (error) {
-    if (isFileNotFoundError(error)) {
-      return {
-        error: `log file not found`,
-        lines: [],
-        code: 1
-      };
-    }
-    return {
-      error: `${error}`,
-      lines: [],
-      code: 2
-    };
-  }
-};
-
-const clear = async state => {
-  const {
-    selectedOption,
-    options
-  } = state;
-  const option = options.find(option => option.id === selectedOption);
-  if (!option) {
-    return state;
-  }
-  const {
-    uri
-  } = option;
-  await writeFile(uri, '');
-  const {
-    lines,
-    code,
-    error
-  } = await loadLines(uri);
-  return {
-    ...state,
-    listItems: lines,
-    error,
-    errorCode: code
-  };
-};
-
-const Filter = 'filter';
-const Output$2 = 'output';
-const MainProcess = 'MainProcess';
-const SharedProcess = 'SharedProcess';
-const Clear = 'Clear';
-const Settings = 'Settings';
-const ScrollLock = 'ScrollLock';
-
-const noop = async state => {
+const handleContextMenu = async (state, x, y, button) => {
+  // TODO open context menu
   return state;
 };
-const getClickHandler = name => {
-  switch (name) {
-    case Clear:
-      return clear;
-    default:
-      return noop;
-  }
-};
-
-const handleButtonClick = async (state, name) => {
-  const fn = getClickHandler(name);
-  return fn(state);
-};
 
 const handleData = async state => {
   // TODO
@@ -1426,14 +1630,7 @@ const handleError = async state => {
   };
 };
 
-const filterItems = (items, filterValue) => {
-  if (!filterValue) {
-    return items;
-  }
-  return items.filter(item => item.includes(filterValue));
-};
-
-const handleFilterInput = async (state, value) => {
+const handleFilterInput = async (state, value, inputSource = User) => {
   const {
     listItems
   } = state;
@@ -1441,13 +1638,68 @@ const handleFilterInput = async (state, value) => {
   return {
     ...state,
     filterValue: value,
-    filteredItems: filteredItems
+    filteredItems: filteredItems,
+    inputSource
   };
 };
 
-const handleSelect = async (state, id) => {
+const createWatchId = () => {
+  const watchId = Math.random();
+  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) {
+    const instance = get(key);
+    if (instance.newState.watchId === watchId) {
+      // @ts-ignore
+      await invoke$1('Output.refresh');
+    }
+  }
+};
+
+const watchCallbacks = Object.create(null);
+const registerWatchCallback = (id, fn) => {
+  watchCallbacks[id] = fn;
+};
+const executeWatchCallBack = id => {
+  watchCallbacks[id](id);
+};
+const unregisterWatchCallback = id => {
+  delete watchCallbacks[id];
+};
+
+const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
+  try {
+    if (oldWatchId) {
+      unregisterWatchCallback(oldWatchId);
+      // @ts-ignore
+      await FileSystemWorker.invoke('FileSystem.unwatchFile', oldWatchId);
+    }
+    // TODO dispose old watcher
+    const rpcId = RpcId.OutputWorker;
+    registerWatchCallback(newWatchId, handleFileChange);
+    // @ts-ignore
+    await FileSystemWorker.invoke('FileSystem.watchFile', newWatchId, /* path */uri, rpcId);
+  } catch {
+    // ignore
+  }
+};
+
+const selectChannel = async (state, id) => {
   const {
-    options
+    options,
+    filterValue,
+    watchId
   } = state;
   const matchingOption = options.find(option => option.id === id);
   if (!matchingOption) {
@@ -1459,18 +1711,25 @@ const handleSelect = async (state, id) => {
     error,
     code
   } = await loadLines(matchingOption.uri);
+
+  // TODO memory leak and race condition, need to dispose file watcher of previous uri
+  const newWatchId = createWatchId();
+  await setupChangeListener(watchId, newWatchId, matchingOption.uri);
+  const filteredItems = filterItems(lines, filterValue);
   return {
     ...state,
-    listItems: lines,
     error,
-    errorCode: code
+    errorCode: code,
+    listItems: lines,
+    filteredItems,
+    selectedOption: id,
+    watchId: newWatchId
   };
 };
 
-const {
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$1,
-  set: set$1} = RendererWorker;
+const handleSelect = async (state, id) => {
+  return selectChannel(state, id);
+};
 
 const sendMessagePortToExtensionHostWorker2 = async port => {
   await sendMessagePortToExtensionHostWorker(port);
@@ -1490,7 +1749,8 @@ const createExtensionHostRpc = async () => {
 
 const {
   set,
-  invoke} = ExtensionHost;
+  invoke
+} = ExtensionHost;
 
 const initializeExtensionHost = async () => {
   const extensionHostRpc = await createExtensionHostRpc();
@@ -1498,7 +1758,7 @@ const initializeExtensionHost = async () => {
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
-  await sendMessagePortToFileSystemWorker$1(port, 0);
+  await sendMessagePortToFileSystemWorker$1(port, RpcId.OutputWorker);
 };
 
 const createFileSystemWorkerRpc = async () => {
@@ -1515,7 +1775,7 @@ const createFileSystemWorkerRpc = async () => {
 
 const initializeFileSystemWorker = async () => {
   const rpc = await createFileSystemWorkerRpc();
-  set$2(rpc);
+  set$3(rpc);
 };
 
 const initialize = async () => {
@@ -1524,40 +1784,81 @@ const initialize = async () => {
 
 const Web = 1;
 
-const getSelectedItem = platform => {
+const getSelectedItem = (selectedOption, platform) => {
+  if (selectedOption) {
+    return selectedOption;
+  }
   if (platform === Web) {
     return '';
   }
   return MainProcess;
 };
 
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+const ClearOutput = 'clear output';
+const LogFileNotFound$1 = 'The log file was not found.';
+const Settings = 'Settings';
+const TurnOffAutoScroll = 'Turn auto scrolling off';
+
+const clearOutput = () => {
+  return i18nString(ClearOutput);
+};
+const turnOffAutoScroll = () => {
+  return i18nString(TurnOffAutoScroll);
+};
+const settings = () => {
+  return i18nString(Settings);
+};
+const logFileNotFound = () => {
+  return i18nString(LogFileNotFound$1);
+};
+
 const loadButtons = () => {
   return [{
     id: Clear,
-    label: 'Clear',
+    label: clearOutput(),
     icon: 'MaskIconClearAll'
   }, {
     id: ScrollLock,
-    label: 'Scroll Lock',
+    label: turnOffAutoScroll(),
     icon: 'MaskIconListFlat'
   }, {
-    id: Settings,
-    label: 'Settings',
-    icon: 'MaskIconListFlat'
+    id: Settings$1,
+    label: settings(),
+    icon: 'MaskIconSettingsGear'
   }];
 };
 
+const error = error => {
+  console.error(error);
+};
+
 const getExtensionOptions = async () => {
   try {
+    // TODO make api more declarative:
+    // output channels are registered in extension manifest
+    // only downside: it might show channels for extensions that are not active
+    await activateByEvent('onOutput');
     // @ts-ignore
-    const channels = await invoke('ExtensionHost.getOutputChannels');
+    const channels = await invoke('Output.getEnabledProviders');
     return channels;
-  } catch {
+  } catch (error$1) {
+    error(error$1);
     return [];
   }
 };
 
-// TODO load options from extensions
 const loadOptions = async platform => {
   const extensionOptions = await getExtensionOptions();
   if (platform === Web) {
@@ -1574,6 +1875,35 @@ const loadOptions = async platform => {
   }, ...extensionOptions];
 };
 
+const getSavedFilterValue = savedState => {
+  if (savedState && typeof savedState.filterValue === 'string') {
+    return savedState.filterValue;
+  }
+  return '';
+};
+const getSavedSelectedOption = savedState => {
+  if (savedState && typeof savedState.selectedOption === 'string') {
+    return savedState.selectedOption;
+  }
+  return '';
+};
+const getSavedScrollLockEnabled = savedState => {
+  if (savedState && typeof savedState.scrollLockEnabled === 'boolean') {
+    return savedState.scrollLockEnabled;
+  }
+  return false;
+};
+const restoreState = savedState => {
+  const filterValue = getSavedFilterValue(savedState);
+  const selectedOption = getSavedSelectedOption(savedState);
+  const scrollLockEnabled = getSavedScrollLockEnabled(savedState);
+  return {
+    filterValue,
+    selectedOption,
+    scrollLockEnabled
+  };
+};
+
 const isString = value => {
   return typeof value === 'string';
 };
@@ -1588,10 +1918,16 @@ const getMatchingOpen = (options, id) => {
 };
 const loadContent = async (state, savedState) => {
   const {
-    platform
+    platform,
+    watchId
   } = state;
   const collapsedUris = getSavedCollapsedUris(savedState);
-  const selectedId = getSelectedItem(platform);
+  const {
+    selectedOption,
+    filterValue,
+    scrollLockEnabled
+  } = restoreState(savedState);
+  const selectedId = getSelectedItem(selectedOption, platform);
   const options = await loadOptions(platform);
   const option = getMatchingOpen(options, selectedId);
   if (!option) {
@@ -1605,18 +1941,24 @@ const loadContent = async (state, savedState) => {
     error,
     code
   } = await loadLines(uri);
+  const filteredItems = filterItems(lines, filterValue);
+  const newWatchId = createWatchId();
+  await setupChangeListener(watchId, newWatchId, uri);
   const buttons = loadButtons();
   return {
     ...state,
+    buttons,
     collapsedUris,
     error,
     errorCode: code,
+    filteredItems,
+    filterValue,
     inputSource: Script,
     listItems: lines,
-    filteredItems: lines,
     options,
+    scrollLockEnabled,
     selectedOption: selectedId,
-    buttons
+    watchId: newWatchId
   };
 };
 
@@ -1627,90 +1969,57 @@ const openFindWidget = async state => {
   };
 };
 
-const Button = 1;
-const Select$1 = 2;
-
-const Blank = 'Blank';
-const ClearAll = 'ClearAll';
-
-const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
-const i18nString = (key, placeholders = emptyObject) => {
-  if (placeholders === emptyObject) {
-    return key;
-  }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
-};
-
-const Output$1 = 'output';
-const ClearOutput = 'clear output';
-const TurnOffAutoScroll = 'Turn auto scrolling off';
-const OpenLogFile = 'open output log file';
-const LogFileNotFound$1 = 'The log file was not found.';
-
-const output = () => {
-  return i18nString(Output$1);
-};
-const clearOutput = () => {
-  return i18nString(ClearOutput);
-};
-const turnOffAutoScroll = () => {
-  return i18nString(TurnOffAutoScroll);
-};
-const openLogFile = () => {
-  return i18nString(OpenLogFile);
-};
-const logFileNotFound = () => {
-  return i18nString(LogFileNotFound$1);
+const getActions = state => {
+  return [];
 };
 
-const toSelectOption = option => {
-  return option.name;
-};
-const toSelectOptions = options => {
-  return options.map(toSelectOption);
-};
-const getActions = state => {
+const refresh = async state => {
   const {
-    options
+    filterValue,
+    options,
+    selectedOption
   } = state;
-  return [{
-    type: Select$1,
-    id: output(),
-    options: toSelectOptions(options)
-  }, {
-    type: Button,
-    id: clearOutput(),
-    icon: ClearAll
-  }, {
-    type: Button,
-    id: turnOffAutoScroll(),
-    icon: Blank
-  }, {
-    type: Button,
-    id: openLogFile(),
-    icon: Blank
-  }];
+  const matchingOption = options.find(option => option.id === selectedOption);
+  if (!matchingOption) {
+    return state;
+  }
+  const {
+    lines,
+    error,
+    code
+  } = await loadLines(matchingOption.uri);
+  const filteredItems = filterItems(lines, filterValue);
+  return {
+    ...state,
+    listItems: lines,
+    filteredItems,
+    error,
+    errorCode: code
+  };
 };
 
 const renderFilterValue = (oldState, newState) => {
-  return ['Viewlet.setValueByName', Filter, newState.filterValue];
+  return ['Viewlet.setValueByName', newState.parentId, Filter$1, newState.filterValue];
 };
 
+const Filter = 'Filter';
 const IconButton = 'IconButton';
+const InputBox = 'InputBox';
 const MaskIcon = 'MaskIcon';
+const FilterInput = 'FilterInput';
+const OutputContent = 'OutputContent';
 const Actions = 'Actions';
+const Message = 'Message';
 const Viewlet = 'Viewlet';
 const Output = 'Output';
 const Option = 'Option';
 const Select = 'Select';
+const Error$1 = 'Error';
+const Line = 'Line';
 
 const parentNode = {
   type: VirtualDomElements.Div,
-  className: 'Line',
+  className: Line,
   childCount: 1
 };
 const getLineDom = line => {
@@ -1723,7 +2032,7 @@ const getContentDom = (lines, error) => {
   }
   return [{
     type: VirtualDomElements.Div,
-    className: 'OutputContent',
+    className: OutputContent,
     role: 'log',
     tabIndex: 0,
     childCount: lines.length
@@ -1735,7 +2044,7 @@ const LogFileNotFound = 1;
 const getLogFileNotFoundDom = () => {
   return [{
     type: VirtualDomElements.Div,
-    className: 'Message',
+    className: Message,
     tabIndex: 0,
     childCount: 1
   }, text(logFileNotFound())];
@@ -1750,7 +2059,7 @@ const getErrorDom = (errorCode, error) => {
   }
   return [{
     type: VirtualDomElements.Div,
-    className: 'Error',
+    className: Error$1,
     tabIndex: 0,
     childCount: 1
   }, text(error)];
@@ -1769,12 +2078,20 @@ const renderItems = (oldState, newState) => {
   return ['Viewlet.setDom2', dom];
 };
 
+const renderSelectedItem = (oldState, newState) => {
+  const value = newState.selectedOption;
+  const name = Output$1;
+  return ['Viewlet.setValueByName', newState.parentId, name, value];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderItems:
       return renderItems;
     case RenderFilterValue:
       return renderFilterValue;
+    case RenderSelectedItem:
+      return renderSelectedItem;
     default:
       throw new Error('unknown renderer');
   }
@@ -1793,8 +2110,8 @@ const render2 = (uid, diffResult) => {
   const {
     oldState,
     newState
-  } = get$1(uid);
-  set$4(uid, newState, newState);
+  } = get(uid);
+  set$2(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -1834,14 +2151,15 @@ const getFilterVirtualDom = () => {
   const placeholder = 'Filter';
   return [{
     type: VirtualDomElements.Div,
-    className: 'Filter',
+    className: Filter,
     childCount: 1
   }, {
     type: VirtualDomElements.Input,
-    className: 'InputBox FilterInput',
+    className: mergeClassNames(InputBox, FilterInput),
     childCount: 0,
     placeholder,
-    onInput: HandleFilterInput
+    onInput: HandleFilterInput,
+    name: Filter$1
   }];
 };
 
@@ -1863,7 +2181,7 @@ const getSelectVirtualDom = options => {
     type: VirtualDomElements.Select,
     className: Select,
     childCount: options.length,
-    name: Output$2,
+    name: Output$1,
     onChange: HandleSelect
   }, ...options.flatMap(getOptionVirtualDom)];
 };
@@ -1926,14 +2244,32 @@ const resize = (state, dimensions) => {
   };
 };
 
+const saveOutputAs = async state => {
+  // TODO show open file picker
+  // TODO write to file
+  // TODO if error occurs, show error dialog
+  return state;
+};
+
 const saveState = state => {
   const {
     filterValue,
-    collapsedUris
+    collapsedUris,
+    selectedOption,
+    scrollLockEnabled
   } = state;
   return {
     filterValue,
-    collapsedUris
+    collapsedUris,
+    selectedOption,
+    scrollLockEnabled
+  };
+};
+
+const setLogLevel = async (state, logLevel) => {
+  return {
+    ...state,
+    logLevel
   };
 };
 
@@ -1945,31 +2281,43 @@ const setOutputChannel = async state => {
 };
 
 const commandMap = {
+  'Output.clear': wrapCommand(clear),
   'Output.closeFindWidget': wrapCommand(closeFindWidget),
-  'Output.create': create$1,
+  'Output.create': create,
   'Output.diff2': diff2,
+  'Output.disableScrollLock': wrapCommand(disableScrollLock),
+  'Output.enableScrollLock': wrapCommand(enableScrollLock),
+  'Output.executeWatchCallback': executeWatchCallBack,
   'Output.focusIndex': wrapCommand(focusIndex),
+  'Output.getActions': getActions,
   'Output.getCommandIds': getCommandIds,
   'Output.getKeyBindings': getKeyBindings,
+  'Output.handleButtonClick': wrapCommand(handleButtonClick),
+  'Output.handleContextMenu': wrapCommand(handleContextMenu),
   'Output.handleData': wrapCommand(handleData),
   'Output.handleError': wrapCommand(handleError),
+  'Output.handleFilterInput': wrapCommand(handleFilterInput),
+  'Output.handleSelect': wrapCommand(handleSelect),
   'Output.initialize': initialize,
   'Output.loadContent2': wrapCommand(loadContent),
   'Output.openFindWidget': wrapCommand(openFindWidget),
+  'Output.refresh': wrapCommand(refresh),
   'Output.render2': render2,
   'Output.renderActions': wrapGetter(renderActions),
   'Output.renderEventListeners': renderEventListeners,
   'Output.resize': resize,
-  'Output.saveState': saveState,
+  'Output.saveOutputAs': wrapCommand(saveOutputAs),
+  'Output.saveState': wrapGetter(saveState),
+  'Output.selectChannel': wrapCommand(selectChannel),
+  'Output.setLogLevel': setLogLevel,
   'Output.setOutputChannel': wrapCommand(setOutputChannel),
-  'Output.getActions': getActions,
-  'Output.terminate': terminate,
-  'Output.handleSelect': wrapCommand(handleSelect),
-  'Output.handleFilterInput': wrapCommand(handleFilterInput),
-  'Output.handleButtonClick': wrapCommand(handleButtonClick)
+  'Output.terminate': terminate
 };
 
+const commandMapRef = {};
+
 const listen = async () => {
+  registerCommands(commandMap);
   Object.assign(commandMapRef, commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMapRef