@lvce-editor/static-server 0.79.2 → 0.79.3

package/static/{76c4b79 → 62bf877}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -108,7 +108,7 @@ const getAssetDir$1 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/76c4b79';
+    return '/62bf877';
   }
 };
 const assetDir = getAssetDir$1();
@@ -1822,7 +1822,7 @@ const getProtocol = uri => {
   return Disk;
 };
 const PROTOCOL_POST_FIX_LENGTH = 3;
-const getPath$1 = (protocol, uri) => {
+const getPath$5 = (protocol, uri) => {
   if (!uri) {
     return '';
   }
@@ -1840,70 +1840,59 @@ const readFile$f = async (uri, encoding = Utf8) => {
   if (protocol === 'untitled') {
     return '';
   }
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.readFile(path, encoding);
+  return fileSystem.readFile(uri, encoding);
 };
 const readJson$6 = async (uri, encoding) => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.readJson(path, encoding);
+  return fileSystem.readJson(uri, encoding);
 };
 const remove$b = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  await fileSystem.remove(path);
+  await fileSystem.remove(uri);
 };
 const rename$7 = async (oldUri, newUri) => {
   const protocol = getProtocol(oldUri);
-  const oldPath = getPath$1(protocol, oldUri);
-  const newPath = getPath$1(protocol, newUri);
   const fileSystem = await getFileSystem(protocol);
-  await fileSystem.rename(oldPath, newPath);
+  await fileSystem.rename(oldUri, newUri);
 };
 const mkdir$9 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  await fileSystem.mkdir(path);
+  await fileSystem.mkdir(uri);
 };
 const writeFile$f = async (uri, content, encoding = Utf8) => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  await fileSystem.writeFile(path, content, encoding);
+  await fileSystem.writeFile(uri, content, encoding);
 };
 const writeBlob$1 = async (uri, blob) => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  await fileSystem.writeBlob(path, blob);
+  await fileSystem.writeBlob(uri, blob);
 };
 const readDirWithFileTypes$9 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.readDirWithFileTypes(path);
+  return fileSystem.readDirWithFileTypes(uri);
 };
 const getBlobUrl$4 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
   if (fileSystem.getBlobSrc) {
-    return fileSystem.getBlobSrc(path);
+    return fileSystem.getBlobSrc(uri);
   }
   if (fileSystem.getBlobUrl) {
-    return fileSystem.getBlobUrl(path);
+    return fileSystem.getBlobUrl(uri);
   }
   throw new Error(`Filesystem doesn't support the getBlobUrl function`);
 };
 const getBlob$6 = async (uri, type) => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.getBlob(path, type);
+  return fileSystem.getBlob(uri, type);
 };
 const copy$4 = async (sourceUri, targetUri) => {
   string(sourceUri);
@@ -1911,45 +1900,37 @@ const copy$4 = async (sourceUri, targetUri) => {
   // TODO what if it is not the same file system?
   const protocol = getProtocol(sourceUri);
   const fileSystem = await getFileSystem(protocol);
-  const sourcePath = getPath$1(protocol, sourceUri);
-  const targetPath = getPath$1(protocol, targetUri);
-  return fileSystem.copy(sourcePath, targetPath);
+  return fileSystem.copy(sourceUri, targetUri);
 };
 const getPathSeparator$9 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.getPathSeparator(path);
+  return fileSystem.getPathSeparator(uri);
 };
 const getRealPath$1 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.getRealPath(path);
+  return fileSystem.getRealPath(uri);
 };
 const stat$2 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.stat(path);
+  return fileSystem.stat(uri);
 };
 const getFolderSize$1 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.getFolderSize(path);
+  return fileSystem.getFolderSize(uri);
 };
 const chmod$4 = async (uri, permissions) => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.chmod(path, permissions);
+  return fileSystem.chmod(uri, permissions);
 };
 const exists$3 = async uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
   const fileSystem = await getFileSystem(protocol);
-  return fileSystem.exists(path);
+  return fileSystem.exists(uri);
 };
 const canBeRestored$5 = async uri => {
   const protocol = getProtocol(uri);
@@ -3210,7 +3191,7 @@ const setUri = async uri => {
   state$o.workspaceUri = uri;
   await onWorkspaceChange();
 };
-const getPath = () => {
+const getPath$4 = () => {
   return state$o.workspacePath;
 };
 const getUri$1 = () => {
@@ -3641,8 +3622,7 @@ const launchQuickPickWorker = async () => {
 };
 
 const {
-  invoke: invoke$z,
-  invokeAndTransfer: invokeAndTransfer$l} = getOrCreateWorker(launchQuickPickWorker);
+  invoke: invoke$z} = getOrCreateWorker(launchQuickPickWorker);
 
 const state$m = {
   /**
@@ -4946,7 +4926,7 @@ const launchIconThemeWorker = async () => {
 
 const {
   invoke: invoke$y,
-  invokeAndTransfer: invokeAndTransfer$k
+  invokeAndTransfer: invokeAndTransfer$l
 } = getOrCreateWorker(launchIconThemeWorker);
 
 const getFileIcon$1 = file => {
@@ -6091,7 +6071,7 @@ const launchAuthWorker = async () => {
 
 const {
   invoke: invoke$x,
-  invokeAndTransfer: invokeAndTransfer$j} = getOrCreateWorker(launchAuthWorker);
+  invokeAndTransfer: invokeAndTransfer$k} = getOrCreateWorker(launchAuthWorker);
 const initialize = (backendUrl, platform, href) => {
   return invoke$x('Auth.initialize', {
     backendUrl,
@@ -7816,7 +7796,7 @@ const executeProvider = async ({
 
 const readFile$e = uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   // TODO there shouldn't be multiple file system providers for the same protocol
   return executeProvider({
     event: `onFileSystem:${protocol}`,
@@ -7827,7 +7807,7 @@ const readFile$e = uri => {
 };
 const remove$8 = uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemRemove,
@@ -7843,8 +7823,8 @@ const remove$8 = uri => {
  */
 const rename$6 = (oldUri, newUri) => {
   const protocol = getProtocol(oldUri);
-  const oldPath = getPath$1(protocol, oldUri);
-  const newPath = getPath$1(protocol, newUri);
+  const oldPath = getPath$5(protocol, oldUri);
+  const newPath = getPath$5(protocol, newUri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemRename,
@@ -7854,7 +7834,7 @@ const rename$6 = (oldUri, newUri) => {
 };
 const mkdir$8 = uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemMkdir,
@@ -7864,7 +7844,7 @@ const mkdir$8 = uri => {
 };
 const createFile$1 = uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemWriteFile,
@@ -7874,7 +7854,7 @@ const createFile$1 = uri => {
 };
 const createFolder$1 = uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemCreateFolder,
@@ -7884,7 +7864,7 @@ const createFolder$1 = uri => {
 };
 const writeFile$e = (uri, content) => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemWriteFile,
@@ -7894,7 +7874,7 @@ const writeFile$e = (uri, content) => {
 };
 const readDirWithFileTypes$8 = uri => {
   const protocol = getProtocol(uri);
-  const path = getPath$1(protocol, uri);
+  const path = getPath$5(protocol, uri);
   return executeProvider({
     event: `onFileSystem:${protocol}`,
     method: FileSystemReadDirWithFileTypes,
@@ -7928,6 +7908,13 @@ const ExtensionHostFileSystem = {
 };
 
 const name$2p = 'App';
+const appPrefix = 'app://';
+const getPath$3 = uri => {
+  if (uri.startsWith(appPrefix)) {
+    return uri.slice(appPrefix.length);
+  }
+  return uri;
+};
 const getModule$3 = uri => {
   switch (uri) {
     case 'startup-performance':
@@ -7947,16 +7934,16 @@ const getModule$3 = uri => {
   }
 };
 const readFile$d = async uri => {
-  const module = await getModule$3(uri);
+  const module = await getModule$3(getPath$3(uri));
   return module.readFile();
 };
 const readJson$5 = async uri => {
-  const module = await getModule$3(uri);
+  const module = await getModule$3(getPath$3(uri));
   // @ts-ignore
   return module.readJson();
 };
 const writeFile$d = async (uri, content) => {
-  const module = await getModule$3(uri);
+  const module = await getModule$3(getPath$3(uri));
   return module.writeFile(content);
 };
 const readDirWithFileTypes$7 = () => {
@@ -7991,11 +7978,18 @@ const FileSystemApp = {
 };
 
 const name$2o = 'Data';
+const dataPrefix = 'data://';
+const getPath$2 = uri => {
+  if (uri.startsWith(dataPrefix)) {
+    return uri.slice(dataPrefix.length);
+  }
+  return uri;
+};
 const copy$3 = (source, target) => {
   throw new Error('not implemented');
 };
 const readFile$c = path => {
-  return path;
+  return getPath$2(path);
 };
 const remove$6 = path => {
   throw new Error('not implemented');
@@ -8036,44 +8030,51 @@ const FileSystemData = {
 };
 
 const name$2n = 'Memory';
+const memfsPrefix = 'memfs://';
+const getPath$1 = uri => {
+  if (uri.startsWith(memfsPrefix)) {
+    return uri.slice(memfsPrefix.length);
+  }
+  return uri;
+};
 const readFile$b = uri => {
-  return invoke$A('FileSystemMemory.readFile', uri);
+  return invoke$A('FileSystemMemory.readFile', getPath$1(uri));
 };
 const exists$2 = uri => {
-  return invoke$A('FileSystemMemory.exists', uri);
+  return invoke$A('FileSystemMemory.exists', getPath$1(uri));
 };
 const writeFile$b = (uri, content) => {
-  return invoke$A('FileSystemMemory.writeFile', uri, content);
+  return invoke$A('FileSystemMemory.writeFile', getPath$1(uri), content);
 };
 const mkdir$5 = uri => {
-  return invoke$A('FileSystemMemory.mkdir', uri);
+  return invoke$A('FileSystemMemory.mkdir', getPath$1(uri));
 };
 const getPathSeparator$5 = () => {
   return Slash;
 };
 const remove$5 = uri => {
-  return invoke$A('FileSystemMemory.remove', uri);
+  return invoke$A('FileSystemMemory.remove', getPath$1(uri));
 };
 const readDirWithFileTypes$5 = uri => {
-  return invoke$A('FileSystemMemory.readDirWithFileTypes', uri);
+  return invoke$A('FileSystemMemory.readDirWithFileTypes', getPath$1(uri));
 };
 const getBlobUrl$2 = uri => {
-  return invoke$A('FileSystemMemory.getBlobUrl', uri);
+  return invoke$A('FileSystemMemory.getBlobUrl', getPath$1(uri));
 };
 const getBlob$5 = async uri => {
-  return invoke$A('FileSystemMemory.getBlob', uri);
+  return invoke$A('FileSystemMemory.getBlob', getPath$1(uri));
 };
 const chmod$3 = (path, permissions) => {
-  return invoke$A('FileSystemMemory.chmod', path, permissions);
+  return invoke$A('FileSystemMemory.chmod', getPath$1(path), permissions);
 };
 const rename$3 = (oldPath, newPath) => {
-  return invoke$A('FileSystemMemory.rename', oldPath, newPath);
+  return invoke$A('FileSystemMemory.rename', getPath$1(oldPath), getPath$1(newPath));
 };
 const copy$2 = (oldPath, newPath) => {
-  return invoke$A('FileSystemMemory.copy', oldPath, newPath);
+  return invoke$A('FileSystemMemory.copy', getPath$1(oldPath), getPath$1(newPath));
 };
 const stat$1 = uri => {
-  return invoke$A('FileSystemMemory.stat', uri);
+  return invoke$A('FileSystemMemory.stat', getPath$1(uri));
 };
 const getFiles$1 = () => {
   return invoke$A('FileSystemMemory.getFiles');
@@ -8111,6 +8112,13 @@ const state$d = {
   saveListeners: [],
   files: Object.create(null)
 };
+const webPrefix = 'web://';
+const getPath = uri => {
+  if (uri.startsWith(webPrefix)) {
+    return uri.slice(webPrefix.length);
+  }
+  return uri;
+};
 state$d.files['/languages/index.dart'] = `void main() {
   print('Hello, World!');
 }`;
@@ -8308,6 +8316,7 @@ state$d.files['/sample-folder/c.txt'] = '';
 // }
 
 const readFile$a = async path => {
+  path = getPath(path);
   const file = state$d.files[path];
   if (file === undefined) {
     throw new Error(`file not found ${path}`);
@@ -8330,6 +8339,7 @@ const createFolder = async path => {
   throw new Error('not implemented');
 };
 const writeFile$a = async (path, content) => {
+  path = getPath(path);
   state$d.files[path] = content;
 };
 const getDirent$1 = (path, relativePath) => {
@@ -8346,6 +8356,7 @@ const getDirent$1 = (path, relativePath) => {
   };
 };
 const readDirWithFileTypes$4 = path => {
+  path = getPath(path);
   const dirents = [];
   for (const key in state$d.files) {
     if (key.startsWith(path)) {
@@ -8412,7 +8423,7 @@ const launchFileSystemWorker = async () => {
 
 const {
   invoke: invoke$w,
-  invokeAndTransfer: invokeAndTransfer$i} = getOrCreateWorker(launchFileSystemWorker);
+  invokeAndTransfer: invokeAndTransfer$j} = getOrCreateWorker(launchFileSystemWorker);
 
 // TODO move all of this to an extension
 
@@ -8421,7 +8432,15 @@ const name$2l = 'Fetch';
 const state$c = {
   files: Object.create(null)
 };
+const fetchPrefix = 'fetch://';
+const normalizeUri = uri => {
+  if (uri.startsWith(fetchPrefix)) {
+    return uri.slice(fetchPrefix.length);
+  }
+  return uri;
+};
 const readFile$9 = async uri => {
+  uri = normalizeUri(uri);
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
     return invoke$w('FileSystem.readFile', `${location.protocol}//${uri}`);
   }
@@ -8439,6 +8458,7 @@ const exists$1 = async uri => {
   }
 };
 const readJson$4 = async uri => {
+  uri = normalizeUri(uri);
   if (uri.startsWith('localhost:') || uri.startsWith(location.host)) {
     return invoke$w('FileSystem.readJson', `${location.protocol}//${uri}`);
   }
@@ -8448,24 +8468,30 @@ const readJson$4 = async uri => {
   return invoke$A('FileSystemFetch.readJson', uri);
 };
 const writeFile$9 = (uri, content) => {
+  uri = normalizeUri(uri);
   return invoke$A('FileSystemFetch.writeFile', uri);
 };
 const mkdir$3 = uri => {
+  uri = normalizeUri(uri);
   return invoke$A('FileSystemFetch.mkdir', uri);
 };
 const getPathSeparator$3 = () => {
   return Slash;
 };
 const remove$3 = uri => {
+  uri = normalizeUri(uri);
   return invoke$A('FileSystemFetch.remove', uri);
 };
 const readDirWithFileTypes$3 = async uri => {
+  uri = normalizeUri(uri);
   return invoke$A('FileSystemFetch.readDirWithFileTypes', uri);
 };
 const chmod$2 = (path, permissions) => {
+  path = normalizeUri(path);
   return invoke$A('FileSystemFetch.chmod', path, permissions);
 };
 const getBlob$4 = async (uri, type) => {
+  uri = normalizeUri(uri);
   return invoke$A('FileSystemFetch.getBlob', uri, type);
 };
 
@@ -8669,10 +8695,11 @@ const getChildHandles$1 = async handle => {
  *
  * @param {FileSystemDirectoryHandle} handle
  * @param {string} name
+ * @param {FileSystemGetFileOptions=} options
  * @returns
  */
-const getFileHandle$1 = (handle, name) => {
-  return handle.getFileHandle(name);
+const getFileHandle$1 = (handle, name, options) => {
+  return handle.getFileHandle(name, options);
 };
 
 /**
@@ -8735,6 +8762,21 @@ const getBaseName = (pathSeparator, path) => {
 };
 
 const handles = Object.create(null);
+const getLegacyHtmlKeys = uri => {
+  if (!uri.startsWith('html://')) {
+    return [];
+  }
+  const protocol = getProtocol(uri);
+  const strippedUri = getPath$5(protocol, uri);
+  const legacyKeys = [];
+  if (strippedUri) {
+    legacyKeys.push(strippedUri);
+  }
+  if (strippedUri.startsWith('/')) {
+    legacyKeys.push(strippedUri.slice(1));
+  }
+  return legacyKeys.filter((value, index, array) => value && array.indexOf(value) === index);
+};
 const addHandle = async (uri, handle) => {
   try {
     // TODO save handle in indexeddb
@@ -8772,7 +8814,18 @@ const getHandle = async uri => {
     if (uri in handles) {
       return handles[uri];
     }
-    const handle = await execute$3('IndexedDb.getHandle', uri);
+    let handle = await execute$3('IndexedDb.getHandle', uri);
+    if (!handle) {
+      const legacyKeys = getLegacyHtmlKeys(uri);
+      for (const legacyKey of legacyKeys) {
+        handle = await execute$3('IndexedDb.getHandle', legacyKey);
+        if (handle) {
+          await addHandle(uri, handle);
+          handles[legacyKey] = handle;
+          break;
+        }
+      }
+    }
     if (handle) {
       handles[uri] = handle;
     }
@@ -8796,7 +8849,7 @@ const getDirectoryHandle = async uri => {
 };
 
 const pathSeparator$1 = '/';
-const getFileHandle = async uri => {
+const getFileHandle = async (uri, options) => {
   const handle = await getHandle(uri);
   if (handle) {
     return handle;
@@ -8807,7 +8860,7 @@ const getFileHandle = async uri => {
     return undefined;
   }
   const baseName = getBaseName(pathSeparator$1, uri);
-  const fileHandle = await getFileHandle$1(parentHandle, baseName);
+  const fileHandle = await getFileHandle$1(parentHandle, baseName, options);
   return fileHandle;
 };
 
@@ -8903,7 +8956,9 @@ const readFile$7 = async uri => {
 };
 const writeFile$7 = async (uri, content) => {
   try {
-    const handle = await getFileHandle(uri);
+    const handle = await getFileHandle(uri, {
+      create: true
+    });
     if (!handle) {
       throw new VError(`File not found ${uri}`);
     }
@@ -9743,7 +9798,7 @@ const launchClipBoardWorker = async () => {
 
 const {
   invoke: invoke$s,
-  invokeAndTransfer: invokeAndTransfer$h} = getOrCreateWorker(launchClipBoardWorker);
+  invokeAndTransfer: invokeAndTransfer$i} = getOrCreateWorker(launchClipBoardWorker);
 
 const readText = async () => {
   return await invoke$s('ClipBoard.readText');
@@ -10101,8 +10156,8 @@ const attachDebugger = async pid => {
   await invoke$C('AttachDebugger.attachDebugger', pid);
 };
 
-const version = '0.79.2';
-const commit$1 = '76c4b79';
+const version = '0.79.3';
+const commit$1 = '62bf877';
 const productNameLong = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$C('Process.getPid');
@@ -12216,7 +12271,7 @@ const Window_ipc = {
 const name$1e = 'Workspace';
 const Commands$1g = {
   close: close$3,
-  getPath: getPath,
+  getPath: getPath$4,
   getUri: getUri$1,
   hydrate: hydrate$5,
   setPath: setPath,
@@ -12431,7 +12486,7 @@ const launchTerminalWorker = async () => {
 
 const {
   invoke: invoke$q,
-  invokeAndTransfer: invokeAndTransfer$g
+  invokeAndTransfer: invokeAndTransfer$h
 } = getOrCreateWorker(launchTerminalWorker);
 
 const previewWorkerUrl = `${assetDir}/packages/preview-worker/dist/previewWorkerMain.js`;
@@ -12449,7 +12504,7 @@ const launchPreviewWorker = async () => {
 
 const {
   invoke: invoke$p,
-  invokeAndTransfer: invokeAndTransfer$f,
+  invokeAndTransfer: invokeAndTransfer$g,
   restart: restart$g
 } = getOrCreateWorker(launchPreviewWorker);
 
@@ -12469,12 +12524,12 @@ const create2 = async (canvasId, width, height) => {
 };
 const createForTerminal = async (canvasId, callbackId) => {
   const canvas = await create$U(canvasId);
-  await invokeAndTransfer$g('OffscreenCanvas.handleResult', callbackId, canvas);
+  await invokeAndTransfer$h('OffscreenCanvas.handleResult', callbackId, canvas);
 };
 const createForPreview = async (callbackId, width, height) => {
   const canvasId = create$16();
   const canvas = await create2(canvasId, width, height);
-  await invokeAndTransfer$f('Preview.executeCallback', callbackId, canvas, canvasId);
+  await invokeAndTransfer$g('Preview.executeCallback', callbackId, canvas, canvasId);
 };
 
 const name$16 = 'OffscreenCanvas';
@@ -12799,266 +12854,288 @@ const ExtensionHostHover_ipc = {
   name: name$V
 };
 
-const editorWorkerUrl = `${assetDir}/packages/editor-worker/dist/editorWorkerMain.js`;
+const chatCoordinatorWorkerUrl = `${assetDir}/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js`;
 
-const launchEditorWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$1('developer.editorWorkerPath', editorWorkerUrl);
-  const id = create$16();
-  let ipc = await create$17({
+const launchChatCoordinatorWorker = async () => {
+  const name = 'Chat Coordinator Worker';
+  const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: configuredWorkerUrl,
-    name: 'Editor Worker',
-    id
+    name,
+    url: getConfiguredWorkerUrl$1('develop.chatCoordinatorWorkerPath', chatCoordinatorWorkerUrl)
   });
-  if (getConfig()) {
-    // TODO should renderer process send port to renderer worker or vice versa?
-    const port = acquire(id);
-    // TODO wrap port to create ipc
-    ipc = wrap$7(port);
-  }
   handleIpc(ipc);
-  const syntaxHighlightingWorker = true;
-  const syncIncremental = true;
-  await invoke$E(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
 const {
-  invoke: invoke$o,
-  invokeAndTransfer: invokeAndTransfer$e} = getOrCreateWorker(launchEditorWorker);
-const actualInvoke = invoke$o;
+  invokeAndTransfer: invokeAndTransfer$f} = getOrCreateWorker(launchChatCoordinatorWorker);
 
-const openerWorkerUrl = `${assetDir}/packages/opener-worker/dist/openerWorkerMain.js`;
+const chatMathWorkerUrl = `${assetDir}/packages/chat-math-worker/dist/chatMathWorkerMain.js`;
 
-const launchOpenerWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.openerWorkerPath', openerWorkerUrl);
+const launchChatMathWorker = async () => {
+  const name = 'Chat Math Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: configuredWorkerUrl,
-    name: 'Opener Worker'
+    name,
+    url: getConfiguredWorkerUrl$1('develop.chatMathWorkerPath', chatMathWorkerUrl)
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$d
-} = getOrCreateWorker(launchOpenerWorker);
+  invokeAndTransfer: invokeAndTransfer$e} = getOrCreateWorker(launchChatMathWorker);
 
-const previewSandBoxWorkerUrl = `${assetDir}/packages/preview-sandbox-worker/dist/previewSandBoxWorkerMain.js`;
+const chatMessageParsingWorkerUrl = `${assetDir}/packages/chat-message-parsing-worker/dist/chatMessageParsingWorkerMain.js`;
 
-const launchPreviewSandBoxWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.previewSandboxWorkerPath', previewSandBoxWorkerUrl);
+const launchChatMessageParsingWorker = async () => {
+  const name = 'Chat Message Parsing Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: configuredWorkerUrl,
-    name: 'Preview Sandbox Worker'
+    name,
+    url: getConfiguredWorkerUrl$1('develop.chatMessageParsingWorkerPath', chatMessageParsingWorkerUrl)
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$c} = getOrCreateWorker(launchPreviewSandBoxWorker);
+  invokeAndTransfer: invokeAndTransfer$d} = getOrCreateWorker(launchChatMessageParsingWorker);
 
-const iframeWorkerUrl = `${assetDir}/packages/iframe-worker/dist/iframeWorkerMain.js`;
+const chatNetworkWorkerUrl = `${assetDir}/packages/chat-network-worker/dist/chatNetworkWorkerMain.js`;
 
-const launchIframeWorker = async () => {
-  const name = 'Iframe Worker';
+const launchChatNetworkWorker = async () => {
+  const name = 'Chat Network Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.iframeWorkerPath', iframeWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.chatNetworkWorkerPath', chatNetworkWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$E(ipc, 'Iframes.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invoke: invoke$n,
-  invokeAndTransfer: invokeAndTransfer$b
-} = getOrCreateWorker(launchIframeWorker);
+  invokeAndTransfer: invokeAndTransfer$c} = getOrCreateWorker(launchChatNetworkWorker);
 
-const markdownWorkerUrl = `${assetDir}/packages/markdown-worker/dist/markdownWorkerMain.js`;
+const chatStorageWorkerUrl = `${assetDir}/packages/chat-storage-worker/dist/chatStorageWorkerMain.js`;
 
-const launchMarkdownWorker = async () => {
-  const name = 'Markdown Worker';
+const launchChatStorageWorker = async () => {
+  const name = 'Chat Storage Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.markdownWorkerPath', markdownWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.chatStorageWorkerPath', chatStorageWorkerUrl)
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$m,
-  invokeAndTransfer: invokeAndTransfer$a
-} = getOrCreateWorker(launchMarkdownWorker);
+  invokeAndTransfer: invokeAndTransfer$b} = getOrCreateWorker(launchChatStorageWorker);
 
-const sourceControlWorkerUrl = `${assetDir}/packages/source-control-worker/dist/sourceControlWorkerMain.js`;
+const chatToolWorkerUrl = `${assetDir}/packages/chat-tool-worker/dist/chatToolWorkerMain.js`;
 
-const launchSourceControlWorker = async () => {
-  const name = 'Source Control Worker';
+const launchChatToolWorker = async () => {
+  const name = 'Chat Tool Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.sourceControlWorkerPath', sourceControlWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.chatToolWorkerPath', chatToolWorkerUrl)
   });
   handleIpc(ipc);
-  await invoke$E(ipc, 'Initialize.initialize');
+  try {
+    await invoke$E(ipc, 'ChatTool.initialize', getPlatform$1());
+  } catch {
+    // ignore
+  }
   return ipc;
 };
 
 const {
-  invoke: invoke$l,
-  invokeAndTransfer: invokeAndTransfer$9,
-  restart: restart$f
-} = getOrCreateWorker(launchSourceControlWorker);
+  invokeAndTransfer: invokeAndTransfer$a} = getOrCreateWorker(launchChatToolWorker);
 
-const textMeasurementWorkerUrl = `${assetDir}/packages/text-measurement-worker/dist/textMeasurementWorkerMain.js`;
+const editorWorkerUrl = `${assetDir}/packages/editor-worker/dist/editorWorkerMain.js`;
 
-const launchTextMeasurementWorker = async () => {
-  const name = 'Text Measurement Worker';
-  const ipc = await create$17({
+const launchEditorWorker = async () => {
+  const configuredWorkerUrl = getConfiguredWorkerUrl$1('developer.editorWorkerPath', editorWorkerUrl);
+  const id = create$16();
+  let ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name,
-    url: getConfiguredWorkerUrl$1('develop.textMeasurementWorkerPath', textMeasurementWorkerUrl)
+    url: configuredWorkerUrl,
+    name: 'Editor Worker',
+    id
   });
+  if (getConfig()) {
+    // TODO should renderer process send port to renderer worker or vice versa?
+    const port = acquire(id);
+    // TODO wrap port to create ipc
+    ipc = wrap$7(port);
+  }
   handleIpc(ipc);
+  const syntaxHighlightingWorker = true;
+  const syncIncremental = true;
+  await invoke$E(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$8
-} = getOrCreateWorker(launchTextMeasurementWorker);
+  invoke: invoke$o,
+  invokeAndTransfer: invokeAndTransfer$9} = getOrCreateWorker(launchEditorWorker);
+const actualInvoke = invoke$o;
 
-const textSearchWorkerUrl = `${assetDir}/packages/text-search-worker/dist/textSearchWorkerMain.js`;
+const fileSearchWorkerUrl = `${assetDir}/packages/file-search-worker/dist/fileSearchWorkerMain.js`;
 
-const launchTextSearchWorker = async () => {
-  const name = 'Text Search Worker';
+const launchFileSearchWorker = async () => {
+  const name = 'File Search Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.textSearchWorkerPath', textSearchWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.fileSearchWorkerPath', fileSearchWorkerUrl)
   });
   handleIpc(ipc);
   try {
-    await invoke$E(ipc, 'TextSearch.initialize', getPlatform$1());
-  } catch (error) {
+    await invoke$E(ipc, 'QuickPick.initialize');
+  } catch {
     // ignore
   }
   return ipc;
 };
 
 const {
-  invoke: invoke$k,
-  invokeAndTransfer: invokeAndTransfer$7,
-  restart: restart$e
-} = getOrCreateWorker(launchTextSearchWorker);
+  invokeAndTransfer: invokeAndTransfer$8
+} = getOrCreateWorker(launchFileSearchWorker);
 
-const chatCoordinatorWorkerUrl = `${assetDir}/packages/chat-coordinator-worker/dist/chatCoordinatorWorkerMain.js`;
+const iframeWorkerUrl = `${assetDir}/packages/iframe-worker/dist/iframeWorkerMain.js`;
 
-const launchChatCoordinatorWorker = async () => {
-  const name = 'Chat Coordinator Worker';
+const launchIframeWorker = async () => {
+  const name = 'Iframe Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.chatCoordinatorWorkerPath', chatCoordinatorWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.iframeWorkerPath', iframeWorkerUrl)
   });
   handleIpc(ipc);
+  await invoke$E(ipc, 'Iframes.initialize', getPlatform$1());
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$6} = getOrCreateWorker(launchChatCoordinatorWorker);
+  invoke: invoke$n,
+  invokeAndTransfer: invokeAndTransfer$7
+} = getOrCreateWorker(launchIframeWorker);
 
-const chatMathWorkerUrl = `${assetDir}/packages/chat-math-worker/dist/chatMathWorkerMain.js`;
+const markdownWorkerUrl = `${assetDir}/packages/markdown-worker/dist/markdownWorkerMain.js`;
 
-const launchChatMathWorker = async () => {
-  const name = 'Chat Math Worker';
+const launchMarkdownWorker = async () => {
+  const name = 'Markdown Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.chatMathWorkerPath', chatMathWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.markdownWorkerPath', markdownWorkerUrl)
+  });
+  handleIpc(ipc);
+  return ipc;
+};
+
+const {
+  invoke: invoke$m,
+  invokeAndTransfer: invokeAndTransfer$6
+} = getOrCreateWorker(launchMarkdownWorker);
+
+const openerWorkerUrl = `${assetDir}/packages/opener-worker/dist/openerWorkerMain.js`;
+
+const launchOpenerWorker = async () => {
+  const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.openerWorkerPath', openerWorkerUrl);
+  const ipc = await create$17({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url: configuredWorkerUrl,
+    name: 'Opener Worker'
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$5} = getOrCreateWorker(launchChatMathWorker);
+  invokeAndTransfer: invokeAndTransfer$5
+} = getOrCreateWorker(launchOpenerWorker);
 
-const chatMessageParsingWorkerUrl = `${assetDir}/packages/chat-message-parsing-worker/dist/chatMessageParsingWorkerMain.js`;
+const previewSandBoxWorkerUrl = `${assetDir}/packages/preview-sandbox-worker/dist/previewSandBoxWorkerMain.js`;
 
-const launchChatMessageParsingWorker = async () => {
-  const name = 'Chat Message Parsing Worker';
+const launchPreviewSandBoxWorker = async () => {
+  const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.previewSandboxWorkerPath', previewSandBoxWorkerUrl);
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name,
-    url: getConfiguredWorkerUrl$1('develop.chatMessageParsingWorkerPath', chatMessageParsingWorkerUrl)
+    url: configuredWorkerUrl,
+    name: 'Preview Sandbox Worker'
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$4} = getOrCreateWorker(launchChatMessageParsingWorker);
+  invokeAndTransfer: invokeAndTransfer$4} = getOrCreateWorker(launchPreviewSandBoxWorker);
 
-const chatNetworkWorkerUrl = `${assetDir}/packages/chat-network-worker/dist/chatNetworkWorkerMain.js`;
+const sourceControlWorkerUrl = `${assetDir}/packages/source-control-worker/dist/sourceControlWorkerMain.js`;
 
-const launchChatNetworkWorker = async () => {
-  const name = 'Chat Network Worker';
+const launchSourceControlWorker = async () => {
+  const name = 'Source Control Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.chatNetworkWorkerPath', chatNetworkWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.sourceControlWorkerPath', sourceControlWorkerUrl)
   });
   handleIpc(ipc);
+  await invoke$E(ipc, 'Initialize.initialize');
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$3} = getOrCreateWorker(launchChatNetworkWorker);
+  invoke: invoke$l,
+  invokeAndTransfer: invokeAndTransfer$3,
+  restart: restart$f
+} = getOrCreateWorker(launchSourceControlWorker);
 
-const chatStorageWorkerUrl = `${assetDir}/packages/chat-storage-worker/dist/chatStorageWorkerMain.js`;
+const textMeasurementWorkerUrl = `${assetDir}/packages/text-measurement-worker/dist/textMeasurementWorkerMain.js`;
 
-const launchChatStorageWorker = async () => {
-  const name = 'Chat Storage Worker';
+const launchTextMeasurementWorker = async () => {
+  const name = 'Text Measurement Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.chatStorageWorkerPath', chatStorageWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.textMeasurementWorkerPath', textMeasurementWorkerUrl)
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$2} = getOrCreateWorker(launchChatStorageWorker);
+  invokeAndTransfer: invokeAndTransfer$2
+} = getOrCreateWorker(launchTextMeasurementWorker);
 
-const chatToolWorkerUrl = `${assetDir}/packages/chat-tool-worker/dist/chatToolWorkerMain.js`;
+const textSearchWorkerUrl = `${assetDir}/packages/text-search-worker/dist/textSearchWorkerMain.js`;
 
-const launchChatToolWorker = async () => {
-  const name = 'Chat Tool Worker';
+const launchTextSearchWorker = async () => {
+  const name = 'Text Search Worker';
   const ipc = await create$17({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$1('develop.chatToolWorkerPath', chatToolWorkerUrl)
+    url: getConfiguredWorkerUrl$1('develop.textSearchWorkerPath', textSearchWorkerUrl)
   });
   handleIpc(ipc);
   try {
-    await invoke$E(ipc, 'ChatTool.initialize', getPlatform$1());
-  } catch {
+    await invoke$E(ipc, 'TextSearch.initialize', getPlatform$1());
+  } catch (error) {
     // ignore
   }
   return ipc;
 };
 
 const {
-  invokeAndTransfer: invokeAndTransfer$1} = getOrCreateWorker(launchChatToolWorker);
+  invoke: invoke$k,
+  invokeAndTransfer: invokeAndTransfer$1,
+  restart: restart$e
+} = getOrCreateWorker(launchTextSearchWorker);
 
 const sendMessagePortToExtensionHostWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13083,12 +13160,12 @@ const sendMessagePortToErrorWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToAuthWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$j(initialCommand, port, rpcId);
+  await invokeAndTransfer$k(initialCommand, port, rpcId);
 };
 const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$e(initialCommand, port, rpcId);
+  await invokeAndTransfer$9(initialCommand, port, rpcId);
 };
 const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13098,42 +13175,42 @@ const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) =>
 const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$a(initialCommand, port, rpcId);
+  await invokeAndTransfer$6(initialCommand, port, rpcId);
 };
 const sendMessagePortToClipBoardWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$h(initialCommand, port, rpcId);
+  await invokeAndTransfer$i(initialCommand, port, rpcId);
 };
 const sendMessagePortToMainAreaWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$a(initialCommand, port, rpcId);
+  await invokeAndTransfer$6(initialCommand, port, rpcId);
 };
 const sendMessagePortToFileSystemWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$i(initialCommand, port, rpcId);
+  await invokeAndTransfer$j(initialCommand, port, rpcId);
 };
 const sendMessagePortToIconThemeWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$k(initialCommand, port, rpcId);
+  await invokeAndTransfer$l(initialCommand, port, rpcId);
 };
 const sendMessagePortToTextMeasurementWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$8(initialCommand, port, rpcId);
+  await invokeAndTransfer$2(initialCommand, port, rpcId);
 };
 const sendMessagePortToTextSearchWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$7(initialCommand, port, rpcId);
+  await invokeAndTransfer$1(initialCommand, port, rpcId);
 };
 const sendMessagePortToSourceControlWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$9(initialCommand, port, rpcId);
+  await invokeAndTransfer$3(initialCommand, port, rpcId);
 };
 const sendMessagePortToExtensionManagementWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13143,52 +13220,52 @@ const sendMessagePortToExtensionManagementWorker = async (port, initialCommand,
 const sendMessagePortToIframeWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$b(initialCommand, port, rpcId);
+  await invokeAndTransfer$7(initialCommand, port, rpcId);
 };
 const sendMessagePortToFileSearchWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$l(initialCommand, port, rpcId);
+  await invokeAndTransfer$8(initialCommand, port, rpcId);
 };
 const sendMessagePortToOpenerWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$d(initialCommand, port, rpcId);
+  await invokeAndTransfer$5(initialCommand, port, rpcId);
 };
 const sendMessagePortToPreviewSandBoxWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$c(initialCommand, port, rpcId);
+  await invokeAndTransfer$4(initialCommand, port, rpcId);
 };
 const sendMessagePortToChatNetworkWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$3(initialCommand, port, rpcId);
+  await invokeAndTransfer$c(initialCommand, port, rpcId);
 };
 const sendMessagePortToChatMathWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$5(initialCommand, port, rpcId);
+  await invokeAndTransfer$e(initialCommand, port, rpcId);
 };
 const sendMessagePortToChatMessageParsingWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$4(initialCommand, port, rpcId);
+  await invokeAndTransfer$d(initialCommand, port, rpcId);
 };
 const sendMessagePortToChatStorageWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$2(initialCommand, port, rpcId);
+  await invokeAndTransfer$b(initialCommand, port, rpcId);
 };
 const sendMessagePortToChatCoordinatorWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$6(initialCommand, port, rpcId);
+  await invokeAndTransfer$f(initialCommand, port, rpcId);
 };
 const sendMessagePortToChatToolWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$1(initialCommand, port, rpcId);
+  await invokeAndTransfer$a(initialCommand, port, rpcId);
 };
 
 // TODO add only one function sendMessagePortToRpc(rpcId) which sends it to the matching rpc module
@@ -19247,7 +19324,7 @@ const ViewletKeyBindings_ipc = {
   saveState: saveState$a
 };
 
-const commit = '76c4b79';
+const commit = '62bf877';
 
 const getDefaultTitleBarHeight = () => {
   switch (getPlatform$1()) {
@@ -22633,7 +22710,7 @@ const getCommands$c = async () => {
   return Commands$j;
 };
 
-const Css$j = [];
+const Css$j = ["/css/parts/ViewletMainDragOverlay.css", "/css/parts/ViewletMainEditorGroup.css", "/css/parts/ViewletMainWaterMark.css"];
 const Variables$5 = ['MainBackground'];
 
 const getKeyBindings$8 = () => {
@@ -25838,7 +25915,7 @@ const getCommands$3 = async () => {
   return Commands$5;
 };
 
-const Css$6 = ["/css/parts/ViewletSourceControl.css"];
+const Css$6 = ["/css/parts/SourceControlListItem.css", "/css/parts/ViewletSourceControl.css"];
 
 const menus$1 = [];
 const getMenus$1 = async () => {
@@ -27281,8 +27358,9 @@ const openFolder$2 = async () => {
       startIn: 'pictures',
       mode: 'readwrite'
     });
-    await execute$3('PersistentFileHandle.addHandle', result.name, result);
-    await execute$3('Workspace.setPath', `html://${result.name}`);
+    const uri = `html:///${result.name}`;
+    await execute$3('PersistentFileHandle.addHandle', uri, result);
+    await execute$3('Workspace.setPath', uri);
   } catch (error) {
     if (isAbortError(error)) {
       return;