@lvce-editor/server 0.0.32 → 0.0.35

package/static/{37d2807 → 027b7d1}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -39,14 +39,14 @@ var init_Assert = __esm({
       }
     };
     object = (value) => {
-      const type = getType(value);
-      if (type !== "object") {
+      const type2 = getType(value);
+      if (type2 !== "object") {
         throw new Error("expected value to be of type object");
       }
     };
     number = (value) => {
-      const type = getType(value);
-      if (type !== "number") {
+      const type2 = getType(value);
+      if (type2 !== "number") {
         throw new Error("expected value to be of type number");
       }
       if (isNaN(value)) {
@@ -54,32 +54,32 @@ var init_Assert = __esm({
       }
     };
     array = (value) => {
-      const type = getType(value);
-      if (type !== "array") {
+      const type2 = getType(value);
+      if (type2 !== "array") {
         throw new Error("expected value to be of type array");
       }
     };
     string = (value) => {
-      const type = getType(value);
-      if (type !== "string") {
+      const type2 = getType(value);
+      if (type2 !== "string") {
         throw new Error("expected value to be of type string");
       }
     };
     boolean = (value) => {
-      const type = getType(value);
-      if (type !== "boolean") {
+      const type2 = getType(value);
+      if (type2 !== "boolean") {
         throw new Error("expected value to be of type boolean");
       }
     };
     fn = (value) => {
-      const type = getType(value);
-      if (type !== "function") {
+      const type2 = getType(value);
+      if (type2 !== "function") {
         throw new Error("expected value to be of type function");
       }
     };
     uint32array = (value) => {
-      const type = getType(value);
-      if (type !== "uint32array") {
+      const type2 = getType(value);
+      if (type2 !== "uint32array") {
         throw new Error("expected value to be of type uint32array");
       }
     };
@@ -379,20 +379,20 @@ var init_Notification = __esm({
     state4 = {
       notifications: []
     };
-    create = async (type, text) => {
-      state4.notifications.push({ type, text });
+    create = async (type2, text) => {
+      state4.notifications.push({ type: type2, text });
       await invoke(
         "Notification.create",
-        type,
+        type2,
         text
       );
     };
-    showWithOptions = async (type, text, options) => {
-      state4.notifications.push({ type, text, options });
-      console.log({ type, text, options });
+    showWithOptions = async (type2, text, options) => {
+      state4.notifications.push({ type: type2, text, options });
+      console.log({ type: type2, text, options });
       await invoke(
         993,
-        type,
+        type2,
         text,
         options
       );
@@ -473,15 +473,15 @@ var init_IpcParentWithElectron = __esm({
     init_RendererProcess();
     init_Assert();
     create2 = async (options) => {
-      const type = options.type;
-      string(type);
+      const type2 = options.type;
+      string(type2);
       const originalOnMessage = state3.ipc.onmessage;
       const port = await new Promise((resolve2, reject2) => {
         state3.ipc.onmessage = (event) => {
           const port2 = event.ports[0];
           resolve2(port2);
         };
-        state3.ipc.send({ method: "get-port", params: [type] });
+        state3.ipc.send({ method: "get-port", params: [type2] });
       });
       state3.ipc.onmessage = originalOnMessage;
       let handleMessage3;
@@ -916,7 +916,7 @@ var init_SharedProcess = __esm({
 });
 
 // src/parts/Platform/Platform.js
-var isMobileOrTablet, getMarketPlaceUrl, getLogsDir, getUserSettingsPath, getPlatform2, getAssetDir, getRecentlyOpenedPath, getConfigPath, getCachePath, getExtensionHostWorkerUrl, getGithubApiUrl, getCacheName;
+var isMobileOrTablet, getMarketPlaceUrl, getLogsDir, getUserSettingsPath, getPlatform2, getAssetDir, getRecentlyOpenedPath, getConfigPath, getCachePath, getExtensionHostWorkerUrl, getGithubApiUrl, getCacheName, getTestPath, getNodePath, getTmpDir;
 var init_Platform = __esm({
   "src/parts/Platform/Platform.js"() {
     "use strict";
@@ -971,7 +971,7 @@ var init_Platform = __esm({
     };
     getAssetDir = () => {
       if (true) {
-        return "/37d2807";
+        return "/027b7d1";
       }
       if (getPlatform2() === "electron") {
         return "../../../../..";
@@ -1003,6 +1003,15 @@ var init_Platform = __esm({
     getCacheName = () => {
       return "lvce-runtime";
     };
+    getTestPath = () => {
+      return invoke3("Platform.getTestPath");
+    };
+    getNodePath = () => {
+      return invoke3("Platform.getNodePath");
+    };
+    getTmpDir = () => {
+      return invoke3("Platform.getTmpDir");
+    };
   }
 });
 
@@ -1593,7 +1602,7 @@ var init_VError = __esm({
 });
 
 // src/parts/ExtensionMeta/ExtensionMeta.js
-var state10, getId, getWebExtensionManifest, addWebExtension, getSharedProcessExtensions, getExtensions;
+var state10, getId, getWebExtensionManifest, addWebExtension, getSharedProcessExtensions, getExtensions, addNodeExtension;
 var init_ExtensionMeta = __esm({
   "src/parts/ExtensionMeta/ExtensionMeta.js"() {
     "use strict";
@@ -1649,6 +1658,9 @@ var init_ExtensionMeta = __esm({
       const extensions = await getSharedProcessExtensions();
       return extensions;
     };
+    addNodeExtension = async (path) => {
+      throw new Error("not implemented");
+    };
   }
 });
 
@@ -2182,8 +2194,201 @@ var init_ExtensionHostManagementElectron = __esm({
   }
 });
 
+// src/parts/Location/Location.js
+var getHref, setPathName, hydrate2;
+var init_Location = __esm({
+  "src/parts/Location/Location.js"() {
+    "use strict";
+    init_RendererProcess();
+    getHref = () => {
+      return invoke("Location.getHref");
+    };
+    setPathName = (pathName) => {
+      return invoke(
+        "Location.setPathName",
+        pathName
+      );
+    };
+    hydrate2 = () => {
+      return invoke("Location.hydrate");
+    };
+  }
+});
+
+// src/parts/Workspace/Workspace.js
+var state12, setPath, setUri, getResolvedRootFromSharedProcess, isValid, getResolveRootFromSessionStorage, isTest, getResolvedRootFromRendererProcess, getResolvedRoot, getTitle, getPathName, onWorkspaceChange, hydrate3, getWorkspacePath, getHomeDir, pathBaseName, pathDirName, getAbsolutePath;
+var init_Workspace = __esm({
+  "src/parts/Workspace/Workspace.js"() {
+    "use strict";
+    init_Command();
+    init_GlobalEventBus();
+    init_Location();
+    init_Platform();
+    init_SharedProcess();
+    init_Window();
+    state12 = {
+      workspacePath: "",
+      homeDir: "",
+      pathSeparator: "",
+      workspaceUri: "",
+      source: "",
+      href: "",
+      isTest: false
+    };
+    setPath = async (path) => {
+      console.log("[workspace] set path", path);
+      state12.workspacePath = path;
+      await onWorkspaceChange();
+    };
+    setUri = async (uri) => {
+      const path = uri.slice("file://".length);
+      state12.workspacePath = path;
+      state12.workspaceUri = uri;
+      await onWorkspaceChange();
+    };
+    getResolvedRootFromSharedProcess = async () => {
+      const resolvedRoot = await invoke3(
+        "Workspace.resolveRoot"
+      );
+      return resolvedRoot;
+    };
+    isValid = (resolvedRoot) => {
+      return resolvedRoot && typeof resolvedRoot.path === "string" && typeof resolvedRoot.uri === "string" && typeof resolvedRoot.homeDir === "string" && typeof resolvedRoot.pathSeparator === "string";
+    };
+    getResolveRootFromSessionStorage = async () => {
+      const resolvedRoot = await execute(
+        "SessionStorage.getJson",
+        "workspace"
+      );
+      if (!isValid(resolvedRoot)) {
+        return void 0;
+      }
+      return resolvedRoot;
+    };
+    isTest = () => {
+      return state12.isTest;
+    };
+    getResolvedRootFromRendererProcess = async (href) => {
+      const url = new URL(href);
+      if (url.searchParams.has("replayId")) {
+        const replayId = url.searchParams.get("replayId");
+        await execute(
+          "SessionReplay.replaySession",
+          replayId
+        );
+        return void 0;
+      }
+      if (href.includes("tests/")) {
+        state12.isTest = true;
+        return {
+          path: href,
+          homeDir: "",
+          pathSeparator: "/",
+          source: "test"
+        };
+      }
+      if (url.pathname.startsWith("/github")) {
+        const path = `github://${url.pathname.slice("/github".length + 1)}`;
+        return {
+          path,
+          homeDir: "",
+          pathSeparator: "/",
+          source: "renderer-process"
+        };
+      }
+      if (getPlatform2() === "web") {
+        const resolvedRoot = {
+          path: "web:///workspace",
+          homeDir: "",
+          pathSeparator: "/",
+          source: "renderer-process"
+        };
+        return resolvedRoot;
+      }
+      return void 0;
+    };
+    getResolvedRoot = async (href) => {
+      if (getPlatform2() === "web") {
+        return getResolvedRootFromRendererProcess(href);
+      }
+      if (getPlatform2() === "remote") {
+        const resolvedRootFromRendererProcess = await getResolvedRootFromRendererProcess(href);
+        if (resolvedRootFromRendererProcess) {
+          return resolvedRootFromRendererProcess;
+        }
+      }
+      const resolvedRootFromSessionStorage = await getResolveRootFromSessionStorage();
+      if (resolvedRootFromSessionStorage) {
+        return resolvedRootFromSessionStorage;
+      }
+      return getResolvedRootFromSharedProcess();
+    };
+    getTitle = (workspacePath) => {
+      const pathSeparator = state12.pathSeparator;
+      return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
+    };
+    getPathName = (workspacePath) => {
+      if (workspacePath.startsWith("github://")) {
+        return "/github/" + workspacePath.slice("github://".length);
+      }
+      return "";
+    };
+    onWorkspaceChange = async () => {
+      const title = getTitle(state12.workspacePath);
+      await setTitle(title);
+      if (getPlatform2() === "web" || getPlatform2() === "remote") {
+        const pathName = getPathName(state12.workspacePath);
+        await setPathName(pathName);
+      }
+      await emitEvent("workspace.change", state12.workspacePath);
+    };
+    hydrate3 = async ({ href }) => {
+      if (state12.workspacePath) {
+        return;
+      }
+      const resolvedRoot = await getResolvedRoot(href);
+      if (state12.isTest) {
+        return;
+      }
+      if (state12.workspacePath) {
+        return;
+      }
+      if (state12.homeDir !== resolvedRoot.homeDir) {
+        state12.homeDir = resolvedRoot.homeDir;
+      }
+      state12.workspacePath = resolvedRoot.path;
+      state12.homeDir = resolvedRoot.homeDir;
+      state12.pathSeparator = resolvedRoot.pathSeparator;
+      state12.workspaceUri = resolvedRoot.uri;
+      state12.source = resolvedRoot.source;
+      console.log({ state: state12 });
+      await onWorkspaceChange();
+    };
+    getWorkspacePath = () => {
+      return state12.workspacePath;
+    };
+    getHomeDir = () => {
+      return state12.homeDir;
+    };
+    pathBaseName = (path) => {
+      const pathSeparator = state12.pathSeparator;
+      return path.slice(path.lastIndexOf(pathSeparator) + 1);
+    };
+    pathDirName = (path) => {
+      const pathSeparator = state12.pathSeparator;
+      return path.slice(0, path.lastIndexOf(pathSeparator));
+    };
+    getAbsolutePath = (relativePath) => {
+      if (relativePath.startsWith("./")) {
+        return `${state12.workspacePath}/${relativePath.slice(2)}`;
+      }
+      return `${state12.workspacePath}/${relativePath}`;
+    };
+  }
+});
+
 // src/parts/ExtensionHostManagement/ExtensionHostManagement.js
-var state12, getExtensionHostManagementTypes, getExtensionsToActivate, getExtensionsWithError, handleExtensionActivationError, getManagersWithExtensionsToActivate, startTextDocumentSyncing, activateByEvent, getExtensionHosts;
+var state13, getExtensionHostManagementTypes, getExtensionsToActivate, getExtensionsWithError, handleExtensionActivationError, getManagersWithExtensionsToActivate, startSynching, activateByEvent, getExtensionHosts;
 var init_ExtensionHostManagement = __esm({
   "src/parts/ExtensionHostManagement/ExtensionHostManagement.js"() {
     "use strict";
@@ -2200,7 +2405,8 @@ var init_ExtensionHostManagement = __esm({
     init_ExtensionHostManagementShared();
     init_ExtensionHostManagementElectron();
     init_ViewletStates();
-    state12 = {
+    init_Workspace();
+    state13 = {
       extensionHosts: []
     };
     getExtensionHostManagementTypes = () => {
@@ -2261,7 +2467,7 @@ var init_ExtensionHostManagement = __esm({
       }
       return managersToActivate;
     };
-    startTextDocumentSyncing = async (extensionHost) => {
+    startSynching = async (extensionHost) => {
       const handleEditorCreate = (editor2) => {
         const text = getText(editor2);
         return extensionHost.ipc.invoke(
@@ -2292,14 +2498,24 @@ var init_ExtensionHostManagement = __esm({
         "editor.languageChange",
         handleEditorLanguageChange
       );
+      const handleWorkspaceChange2 = (workspacePath) => {
+        return extensionHost.ipc.invoke("Workspace.setWorkspacePath", workspacePath);
+      };
+      const handlePreferencesChange = () => {
+        return extensionHost.ipc.invoke("Configuration.configurationChanged");
+      };
+      addListener("workspace.change", handleWorkspaceChange2);
+      addListener("preferences.changed", handlePreferencesChange);
       const instances = getAllInstances();
       const editorInstance = instances.EditorText;
       if (editorInstance) {
         await handleEditorCreate(editorInstance.state);
       }
+      await handleWorkspaceChange2(state12.workspacePath);
       console.log("finish text document synching");
     };
     activateByEvent = async (event) => {
+      console.log("activate by event", event);
       string(event);
       if (!hasLoaded()) {
         await waitForLoad();
@@ -2321,21 +2537,21 @@ var init_ExtensionHostManagement = __esm({
           managerWithExtensions.manager.name,
           managerWithExtensions.manager.ipc
         );
+        await startSynching(extensionHost);
         object(extensionHost);
         for (const extension of managerWithExtensions.toActivate) {
           await extensionHost.ipc.invoke(
             "ExtensionHostExtension.enableExtension",
             extension
           );
-          await startTextDocumentSyncing(extensionHost);
         }
         extensionHosts.push(extensionHost);
       }
-      state12.extensionHosts = extensionHosts;
+      state13.extensionHosts = extensionHosts;
       return extensionHosts;
     };
     getExtensionHosts = () => {
-      return state12.extensionHosts;
+      return state13.extensionHosts;
     };
   }
 });
@@ -2388,7 +2604,7 @@ var init_ExtensionHostShared = __esm({
     execute2 = async ({ method, params }) => {
       const extensionHosts = getExtensionHosts();
       for (const extensionHost of extensionHosts) {
-        await extensionHost.ipc.invoke(method, ...params);
+        const result = await extensionHost.ipc.invoke(method, ...params);
       }
     };
   }
@@ -2465,259 +2681,66 @@ var init_ExtensionHostFileSystem = __esm({
         event: `onFileSystem:${protocol}`,
         method: "ExtensionHostFileSystem.writeFile",
         params: [protocol, path, content],
-        noProviderFoundMessage: "no file system provider found"
-      });
-    };
-    readDirWithFileTypes = (protocol, path) => {
-      return executeProvider({
-        event: `onFileSystem:${protocol}`,
-        method: "ExtensionHostFileSystem.readDirWithFileTypes",
-        params: [protocol, path],
-        noProviderFoundMessage: "no file system provider found"
-      });
-    };
-    getPathSeparator = (protocol) => {
-      return executeProvider({
-        event: `onFileSystem:${protocol}`,
-        method: "ExtensionHostFileSystem.getPathSeparator",
-        params: [protocol],
-        noProviderFoundMessage: "no file system provider found"
-      });
-    };
-  }
-});
-
-// src/parts/FileSystem/FileSystemAppStartupPerformance.js
-var FileSystemAppStartupPerformance_exports = {};
-__export(FileSystemAppStartupPerformance_exports, {
-  readFile: () => readFile2,
-  writeFile: () => writeFile2
-});
-var readFile2, writeFile2;
-var init_FileSystemAppStartupPerformance = __esm({
-  "src/parts/FileSystem/FileSystemAppStartupPerformance.js"() {
-    "use strict";
-    init_Command();
-    readFile2 = () => {
-      return execute(
-        "Developer.getStartupPerformanceContent"
-      );
-    };
-    writeFile2 = () => {
-      throw new Error("not implemented");
-    };
-  }
-});
-
-// src/parts/FileSystem/FileSystemAppMemoryUsage.js
-var FileSystemAppMemoryUsage_exports = {};
-__export(FileSystemAppMemoryUsage_exports, {
-  readFile: () => readFile3,
-  writeFile: () => writeFile3
-});
-var readFile3, writeFile3;
-var init_FileSystemAppMemoryUsage = __esm({
-  "src/parts/FileSystem/FileSystemAppMemoryUsage.js"() {
-    "use strict";
-    init_Command();
-    readFile3 = () => {
-      return execute(821);
-    };
-    writeFile3 = () => {
-      throw new Error("not implemened");
-    };
-  }
-});
-
-// src/parts/Location/Location.js
-var getHref, setPathName, hydrate2;
-var init_Location = __esm({
-  "src/parts/Location/Location.js"() {
-    "use strict";
-    init_RendererProcess();
-    getHref = () => {
-      return invoke("Location.getHref");
-    };
-    setPathName = (pathName) => {
-      return invoke(
-        "Location.setPathName",
-        pathName
-      );
-    };
-    hydrate2 = () => {
-      return invoke("Location.hydrate");
-    };
-  }
-});
-
-// src/parts/Workspace/Workspace.js
-var state13, setPath, setUri, getResolvedRootFromSharedProcess, isValid, getResolveRootFromSessionStorage, isTest, getResolvedRootFromRendererProcess, getResolvedRoot, getTitle, getPathName, onWorkspaceChange, hydrate3, getWorkspacePath, getHomeDir, pathBaseName, pathDirName, getAbsolutePath;
-var init_Workspace = __esm({
-  "src/parts/Workspace/Workspace.js"() {
-    "use strict";
-    init_Command();
-    init_GlobalEventBus();
-    init_Location();
-    init_Platform();
-    init_SharedProcess();
-    init_Window();
-    state13 = {
-      workspacePath: "",
-      homeDir: "",
-      pathSeparator: "",
-      workspaceUri: "",
-      source: "",
-      href: "",
-      isTest: false
-    };
-    setPath = async (path) => {
-      console.log("[workspace] set path", path);
-      state13.workspacePath = path;
-      await onWorkspaceChange();
-    };
-    setUri = async (uri) => {
-      const path = uri.slice("file://".length);
-      state13.workspacePath = path;
-      state13.workspaceUri = uri;
-      await onWorkspaceChange();
-    };
-    getResolvedRootFromSharedProcess = async () => {
-      const resolvedRoot = await invoke3(
-        "Workspace.resolveRoot"
-      );
-      return resolvedRoot;
-    };
-    isValid = (resolvedRoot) => {
-      return resolvedRoot && typeof resolvedRoot.path === "string" && typeof resolvedRoot.uri === "string" && typeof resolvedRoot.homeDir === "string" && typeof resolvedRoot.pathSeparator === "string";
-    };
-    getResolveRootFromSessionStorage = async () => {
-      const resolvedRoot = await execute(
-        "SessionStorage.getJson",
-        "workspace"
-      );
-      if (!isValid(resolvedRoot)) {
-        return void 0;
-      }
-      return resolvedRoot;
-    };
-    isTest = () => {
-      return state13.isTest;
-    };
-    getResolvedRootFromRendererProcess = async (href) => {
-      const url = new URL(href);
-      if (url.searchParams.has("replayId")) {
-        const replayId = url.searchParams.get("replayId");
-        await execute(
-          "SessionReplay.replaySession",
-          replayId
-        );
-        return void 0;
-      }
-      if (href.includes("tests/")) {
-        state13.isTest = true;
-        return {
-          path: href,
-          homeDir: "",
-          pathSeparator: "/",
-          source: "test"
-        };
-      }
-      if (url.pathname.startsWith("/github")) {
-        const path = `github://${url.pathname.slice("/github".length + 1)}`;
-        return {
-          path,
-          homeDir: "",
-          pathSeparator: "/",
-          source: "renderer-process"
-        };
-      }
-      if (getPlatform2() === "web") {
-        const resolvedRoot = {
-          path: "web:///workspace",
-          homeDir: "",
-          pathSeparator: "/",
-          source: "renderer-process"
-        };
-        return resolvedRoot;
-      }
-      return void 0;
-    };
-    getResolvedRoot = async (href) => {
-      if (getPlatform2() === "web") {
-        return getResolvedRootFromRendererProcess(href);
-      }
-      if (getPlatform2() === "remote") {
-        const resolvedRootFromRendererProcess = await getResolvedRootFromRendererProcess(href);
-        if (resolvedRootFromRendererProcess) {
-          return resolvedRootFromRendererProcess;
-        }
-      }
-      const resolvedRootFromSessionStorage = await getResolveRootFromSessionStorage();
-      if (resolvedRootFromSessionStorage) {
-        return resolvedRootFromSessionStorage;
-      }
-      return getResolvedRootFromSharedProcess();
-    };
-    getTitle = (workspacePath) => {
-      const pathSeparator = state13.pathSeparator;
-      return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
-    };
-    getPathName = (workspacePath) => {
-      if (workspacePath.startsWith("github://")) {
-        return "/github/" + workspacePath.slice("github://".length);
-      }
-      return "";
-    };
-    onWorkspaceChange = async () => {
-      const title = getTitle(state13.workspacePath);
-      await setTitle(title);
-      if (getPlatform2() === "web" || getPlatform2() === "remote") {
-        const pathName = getPathName(state13.workspacePath);
-        await setPathName(pathName);
-      }
-      await emitEvent("workspace.change", state13.workspacePath);
-    };
-    hydrate3 = async ({ href }) => {
-      if (state13.workspacePath) {
-        return;
-      }
-      const resolvedRoot = await getResolvedRoot(href);
-      if (state13.isTest) {
-        return;
-      }
-      if (state13.workspacePath) {
-        return;
-      }
-      if (state13.homeDir !== resolvedRoot.homeDir) {
-        state13.homeDir = resolvedRoot.homeDir;
-      }
-      state13.workspacePath = resolvedRoot.path;
-      state13.homeDir = resolvedRoot.homeDir;
-      state13.pathSeparator = resolvedRoot.pathSeparator;
-      state13.workspaceUri = resolvedRoot.uri;
-      state13.source = resolvedRoot.source;
-      console.log({ state: state13 });
-      await onWorkspaceChange();
+        noProviderFoundMessage: "no file system provider found"
+      });
     };
-    getWorkspacePath = () => {
-      return state13.workspacePath;
+    readDirWithFileTypes = (protocol, path) => {
+      return executeProvider({
+        event: `onFileSystem:${protocol}`,
+        method: "ExtensionHostFileSystem.readDirWithFileTypes",
+        params: [protocol, path],
+        noProviderFoundMessage: "no file system provider found"
+      });
     };
-    getHomeDir = () => {
-      return state13.homeDir;
+    getPathSeparator = (protocol) => {
+      return executeProvider({
+        event: `onFileSystem:${protocol}`,
+        method: "ExtensionHostFileSystem.getPathSeparator",
+        params: [protocol],
+        noProviderFoundMessage: "no file system provider found"
+      });
     };
-    pathBaseName = (path) => {
-      const pathSeparator = state13.pathSeparator;
-      return path.slice(path.lastIndexOf(pathSeparator) + 1);
+  }
+});
+
+// src/parts/FileSystem/FileSystemAppStartupPerformance.js
+var FileSystemAppStartupPerformance_exports = {};
+__export(FileSystemAppStartupPerformance_exports, {
+  readFile: () => readFile2,
+  writeFile: () => writeFile2
+});
+var readFile2, writeFile2;
+var init_FileSystemAppStartupPerformance = __esm({
+  "src/parts/FileSystem/FileSystemAppStartupPerformance.js"() {
+    "use strict";
+    init_Command();
+    readFile2 = () => {
+      return execute(
+        "Developer.getStartupPerformanceContent"
+      );
     };
-    pathDirName = (path) => {
-      const pathSeparator = state13.pathSeparator;
-      return path.slice(0, path.lastIndexOf(pathSeparator));
+    writeFile2 = () => {
+      throw new Error("not implemented");
     };
-    getAbsolutePath = (relativePath) => {
-      if (relativePath.startsWith("./")) {
-        return `${state13.workspacePath}/${relativePath.slice(2)}`;
-      }
-      return `${state13.workspacePath}/${relativePath}`;
+  }
+});
+
+// src/parts/FileSystem/FileSystemAppMemoryUsage.js
+var FileSystemAppMemoryUsage_exports = {};
+__export(FileSystemAppMemoryUsage_exports, {
+  readFile: () => readFile3,
+  writeFile: () => writeFile3
+});
+var readFile3, writeFile3;
+var init_FileSystemAppMemoryUsage = __esm({
+  "src/parts/FileSystem/FileSystemAppMemoryUsage.js"() {
+    "use strict";
+    init_Command();
+    readFile3 = () => {
+      return execute(821);
+    };
+    writeFile3 = () => {
+      throw new Error("not implemened");
     };
   }
 });
@@ -2819,6 +2842,7 @@ var init_LocalStorage = __esm({
 // src/parts/FileSystem/FileSystemDisk.js
 var FileSystemDisk_exports = {};
 __export(FileSystemDisk_exports, {
+  chmod: () => chmod,
   copy: () => copy,
   ensureFile: () => ensureFile,
   getBlobUrl: () => getBlobUrl,
@@ -2833,7 +2857,7 @@ __export(FileSystemDisk_exports, {
   stat: () => stat,
   writeFile: () => writeFile4
 });
-var name4, copy, readFile4, remove3, rename2, mkdir2, writeFile4, ensureFile, readDirWithFileTypes2, getBlobUrl, getPathSeparator2, getRealPath, stat;
+var name4, copy, readFile4, remove3, rename2, mkdir2, writeFile4, ensureFile, readDirWithFileTypes2, getBlobUrl, getPathSeparator2, getRealPath, stat, chmod;
 var init_FileSystemDisk = __esm({
   "src/parts/FileSystem/FileSystemDisk.js"() {
     "use strict";
@@ -2910,6 +2934,13 @@ var init_FileSystemDisk = __esm({
         path
       );
     };
+    chmod = (path, permissions) => {
+      return invoke3(
+        "FileSystem.chmod",
+        path,
+        permissions
+      );
+    };
   }
 });
 
@@ -4057,6 +4088,7 @@ var init_FileSystemData = __esm({
 // src/parts/FileSystem/FileSystemMemory.js
 var FileSystemMemory_exports = {};
 __export(FileSystemMemory_exports, {
+  chmod: () => chmod2,
   getPathSeparator: () => getPathSeparator7,
   mkdir: () => mkdir6,
   name: () => name9,
@@ -4066,7 +4098,7 @@ __export(FileSystemMemory_exports, {
   state: () => state18,
   writeFile: () => writeFile11
 });
-var name9, state18, getDirent2, readFile13, ensureParentDir, writeFile11, mkdir6, getPathSeparator7, remove7, readDirWithFileTypes7;
+var name9, state18, getDirent2, readFile13, ensureParentDir, writeFile11, mkdir6, getPathSeparator7, remove7, readDirWithFileTypes7, chmod2;
 var init_FileSystemMemory = __esm({
   "src/parts/FileSystem/FileSystemMemory.js"() {
     "use strict";
@@ -4166,11 +4198,14 @@ var init_FileSystemMemory = __esm({
       }
       return dirents;
     };
+    chmod2 = (path, permissions) => {
+      throw new Error("[memfs] chmod not implemented");
+    };
   }
 });
 
 // src/parts/FileSystem/FileSystem.js
-var RE_PROTOCOL, getProtocol, state19, getFileSystem, PROTOCOL_POST_FIX_LENGTH, getPath, readFile14, remove8, rename6, mkdir7, writeFile12, readDirWithFileTypes8, getBlobUrl4, copy3, getPathSeparator8, getRealPath2, stat2;
+var RE_PROTOCOL, getProtocol, state19, getFileSystem, PROTOCOL_POST_FIX_LENGTH, getPath, readFile14, remove8, rename6, mkdir7, writeFile12, readDirWithFileTypes8, getBlobUrl4, copy3, getPathSeparator8, getRealPath2, stat2, chmod3;
 var init_FileSystem = __esm({
   "src/parts/FileSystem/FileSystem.js"() {
     "use strict";
@@ -4275,11 +4310,17 @@ var init_FileSystem = __esm({
       const fileSystem = getFileSystem(protocol);
       return fileSystem.stat(path);
     };
+    chmod3 = (uri, permissions) => {
+      const protocol = getProtocol(uri);
+      const path = getPath(protocol, uri);
+      const fileSystem = getFileSystem(protocol);
+      return fileSystem.chmod(path, permissions);
+    };
   }
 });
 
 // src/parts/Preferences/Preferences.js
-var state20, openSettingsJson, openKeyBindingsJson, getPreferencesJson, getPreferences, hydrate4, get, set2;
+var state20, openSettingsJson, openKeyBindingsJson, getPreferencesJson, getPreferences, hydrate4, get, set2, update;
 var init_Preferences = __esm({
   "src/parts/Preferences/Preferences.js"() {
     "use strict";
@@ -4289,6 +4330,7 @@ var init_Preferences = __esm({
     init_FileSystem();
     init_Json();
     init_RendererProcess();
+    init_GlobalEventBus();
     state20 = /* @__PURE__ */ Object.create(null);
     openSettingsJson = async () => {
       await execute(
@@ -4367,6 +4409,12 @@ ${styles.join("\n")}
       const content = stringify(state20);
       await writeFile12("app://settings.json", content);
     };
+    update = async (settings) => {
+      const newSettings = { ...state20, ...settings };
+      const content = stringify(newSettings);
+      await writeFile12("app://settings.json", content);
+      await emitEvent("preferences.changed");
+    };
   }
 });
 
@@ -4615,7 +4663,7 @@ var init_ViewletExplorer = __esm({
       return getPathSeparator8(root);
     };
     loadContent = async (state43) => {
-      const root = state13.workspacePath;
+      const root = state12.workspacePath;
       const pathSeparator = await getPathSeparator9(root);
       const dirents = await getTopLevelDirents(root, pathSeparator);
       const { itemHeight, height } = state43;
@@ -4653,7 +4701,7 @@ var init_ViewletExplorer = __esm({
       return updateIcons(state43);
     };
     handleWorkspaceChange = async (state43) => {
-      const newRoot = state13.workspacePath;
+      const newRoot = state12.workspacePath;
       const state1 = { ...state43, root: newRoot };
       const newState = await loadContent(state1);
       return newState;
@@ -4955,7 +5003,7 @@ var init_ViewletExplorer = __esm({
       }
       return dirents[index].path;
     };
-    acceptDirent = async (state43, type) => {
+    acceptDirent = async (state43, type2) => {
       const editingIndex = state43.editingIndex;
       const focusedIndex = state43.focusedIndex;
       state43.editingIndex = -1;
@@ -4974,7 +5022,7 @@ var init_ViewletExplorer = __esm({
       const parentFolder = getParentFolder(state43.dirents, focusedIndex, state43.root);
       const absolutePath = [parentFolder, newFileName].join(state43.pathSeparator);
       try {
-        switch (type) {
+        switch (type2) {
           case "file":
             await writeFile12(absolutePath, "");
             break;
@@ -5000,7 +5048,7 @@ var init_ViewletExplorer = __esm({
         setSize: 1,
         depth,
         name: newFileName,
-        type,
+        type: type2,
         icon: ""
       };
       newDirent2.icon = getIcon(newDirent2);
@@ -5207,12 +5255,12 @@ var init_ViewletExplorer = __esm({
     };
     handleClickSymLink = async (state43, dirent, index) => {
       const realPath = await getRealPath2(dirent.path);
-      const type = await stat2(realPath);
-      switch (type) {
+      const type2 = await stat2(realPath);
+      switch (type2) {
         case "file":
           return handleClickFile(state43, dirent, index);
         default:
-          throw new Error(`unsupported file type ${type}`);
+          throw new Error(`unsupported file type ${type2}`);
       }
     };
     handleArrowRightDirectoryExpanded = (state43, dirent) => {
@@ -5595,10 +5643,10 @@ var init_ViewletExplorer = __esm({
       return revealItemVisible(state43, index);
     };
     shouldApplyNewState = (newState, fn2) => {
-      if (newState.root !== state13.workspacePath) {
+      if (newState.root !== state12.workspacePath) {
         console.log(
           "root does not match",
-          `${newState.root} !== ${state13.workspacePath}`
+          `${newState.root} !== ${state12.workspacePath}`
         );
         return false;
       }
@@ -5956,7 +6004,7 @@ var init_ViewletSearch = __esm({
     };
     setValue = async (state43, value) => {
       try {
-        const root = state13.workspacePath;
+        const root = state12.workspacePath;
         const results = await textSearch3(root, value);
         const displayResults = toDisplayResults(results);
         const resultCount = getResultCounts(results);
@@ -6305,7 +6353,7 @@ var init_ViewletTerminal = __esm({
       send2(
         "Terminal.create",
         state43.id,
-        state13.workspacePath
+        state12.workspacePath
       );
     };
     handleData = async (state43, data) => {
@@ -7265,7 +7313,7 @@ __export(FindWidget_exports, {
   setValue: () => setValue2,
   state: () => state24
 });
-var state24, create23, update, setValue2, previousMatch, nextMatch, dispose9;
+var state24, create23, update2, setValue2, previousMatch, nextMatch, dispose9;
 var init_FindWidget = __esm({
   "src/parts/FindWidget/FindWidget.js"() {
     "use strict";
@@ -7285,7 +7333,7 @@ var init_FindWidget = __esm({
         state24.activeWidget.id
       );
     };
-    update = async (widget) => {
+    update2 = async (widget) => {
       const results = [];
       const text = widget.getText();
       for (let i = 0; i < widget.textContent.length; i++) {
@@ -7301,7 +7349,7 @@ var init_FindWidget = __esm({
     };
     setValue2 = async (value) => {
       state24.activeWidget.value = value;
-      update(state24.activeWidget);
+      update2(state24.activeWidget);
     };
     previousMatch = () => {
     };
@@ -8088,8 +8136,8 @@ var init_EditorText = __esm({
       }
       return lineCache.slice(startLineIndex + 1, endLineIndex + 1).map(getTokensFromCache);
     };
-    getDecorationClassName = (type) => {
-      switch (type) {
+    getDecorationClassName = (type2) => {
+      switch (type2) {
         case 2816:
         case 2817:
         case 2824:
@@ -8133,7 +8181,7 @@ var init_EditorText = __esm({
         case 272:
           return "Class";
         default:
-          return `Unknown-${type}`;
+          return `Unknown-${type2}`;
       }
     };
     getLineInfo = (line, tokens, decorations, TokenMap2, lineOffset) => {
@@ -8578,29 +8626,269 @@ var init_EditorCommandApplyEdit = __esm({
   }
 });
 
-// src/parts/EditorCommand/EditorCommandBlur.js
-var EditorCommandBlur_exports = {};
-__export(EditorCommandBlur_exports, {
-  editorBlur: () => editorBlur,
-  registerListener: () => registerListener,
-  removeListener: () => removeListener2,
-  state: () => state26
+// src/parts/EditorCommand/EditorCommandBlur.js
+var EditorCommandBlur_exports = {};
+__export(EditorCommandBlur_exports, {
+  editorBlur: () => editorBlur,
+  registerListener: () => registerListener,
+  removeListener: () => removeListener2,
+  state: () => state26
+});
+var state26, editorBlur, registerListener, removeListener2;
+var init_EditorCommandBlur = __esm({
+  "src/parts/EditorCommand/EditorCommandBlur.js"() {
+    "use strict";
+    state26 = {
+      blurListeners: []
+    };
+    editorBlur = (editor2) => {
+      return editor2;
+    };
+    registerListener = (fn2) => {
+      state26.blurListeners.push(fn2);
+    };
+    removeListener2 = (fn2) => {
+      state26.blurListeners.splice(state26.blurListeners.indexOf(fn2), 1);
+    };
+  }
+});
+
+// src/parts/ExtensionHost/ExtensionHostBraceCompletion.js
+var combineResults4, executeBraceCompletionProvider;
+var init_ExtensionHostBraceCompletion = __esm({
+  "src/parts/ExtensionHost/ExtensionHostBraceCompletion.js"() {
+    "use strict";
+    init_ExtensionHostShared();
+    init_Assert();
+    combineResults4 = (results) => {
+      return results[0];
+    };
+    executeBraceCompletionProvider = (editor2, offset, openingBrace) => {
+      object(editor2);
+      number(offset);
+      string(openingBrace);
+      return executeProviders({
+        event: `onBraceCompletion:${editor2.languageId}`,
+        method: "ExtensionHostBraceCompletion.executeBraceCompletionProvider",
+        params: [editor2.id, offset, openingBrace],
+        noProviderFoundMessage: "no brace completion providers found",
+        noProviderFoundResult: void 0,
+        combineResults: combineResults4
+      });
+    };
+  }
+});
+
+// src/parts/EditorCommand/EditorCommandReplaceSelection.js
+var editorReplaceSelections;
+var init_EditorCommandReplaceSelection = __esm({
+  "src/parts/EditorCommand/EditorCommandReplaceSelection.js"() {
+    "use strict";
+    init_TextDocument();
+    editorReplaceSelections = (editor2, replacement, origin2) => {
+      const changes = [];
+      const selections = editor2.selections;
+      for (let i = 0; i < selections.length; i += 4) {
+        const selectionStartRow = selections[i];
+        const selectionStartColumn = selections[i + 1];
+        const selectionEndRow = selections[i + 2];
+        const selectionEndColumn = selections[i + 3];
+        const start = {
+          rowIndex: selectionStartRow,
+          columnIndex: selectionStartColumn
+        };
+        const end = {
+          rowIndex: selectionEndRow,
+          columnIndex: selectionEndColumn
+        };
+        const selection = {
+          start,
+          end
+        };
+        changes.push({
+          start,
+          end,
+          inserted: replacement,
+          deleted: getSelectionText(editor2, selection),
+          origin: origin2
+        });
+      }
+      return changes;
+    };
+  }
+});
+
+// src/parts/ExtensionHost/ExtensionHostTabCompletion.js
+var combineResults5, executeTabCompletionProvider;
+var init_ExtensionHostTabCompletion = __esm({
+  "src/parts/ExtensionHost/ExtensionHostTabCompletion.js"() {
+    "use strict";
+    init_ExtensionHostShared();
+    combineResults5 = (results) => {
+      return results[0];
+    };
+    executeTabCompletionProvider = (editor2, offset) => {
+      return executeProviders({
+        event: `onTabCompletion:${editor2.languageId}`,
+        method: "ExtensionHost.executeTabCompletionProvider",
+        params: [editor2.id, offset],
+        noProviderFoundMessage: "No tab completion provider found",
+        noProviderFoundResult: void 0,
+        combineResults: combineResults5
+      });
+    };
+  }
+});
+
+// src/parts/EditorCommand/EditorCommandPosition.js
+var at, x, y;
+var init_EditorCommandPosition = __esm({
+  "src/parts/EditorCommand/EditorCommandPosition.js"() {
+    "use strict";
+    init_Assert();
+    at = (editor2, x2, y2, offset) => {
+      object(editor2);
+      number(x2);
+      number(y2);
+      number(offset);
+      const rowIndex = Math.max(
+        Math.floor((y2 - editor2.top + editor2.deltaY) / editor2.rowHeight),
+        0
+      );
+      const columnIndex = offset;
+      return {
+        rowIndex,
+        columnIndex
+      };
+    };
+    x = (editor2, rowIndex, columnIndex) => {
+      const x2 = columnIndex * editor2.columnWidth + editor2.left;
+      return x2;
+    };
+    y = (editor2, rowIndex, columnIndex) => {
+      const y2 = (rowIndex + 1) * editor2.rowHeight + editor2.top;
+      return y2;
+    };
+  }
+});
+
+// src/parts/EditorCommand/EditorCommandShowMessage.js
+var state27, editorShowMessage, showErrorMessage, editorHideMessage;
+var init_EditorCommandShowMessage = __esm({
+  "src/parts/EditorCommand/EditorCommandShowMessage.js"() {
+    "use strict";
+    init_Assert();
+    init_RendererProcess();
+    init_EditorCommandPosition();
+    state27 = {
+      timeout: -1
+    };
+    editorShowMessage = async (editor2, rowIndex, columnIndex, message, isError) => {
+      object(editor2);
+      number(rowIndex);
+      number(columnIndex);
+      string(message);
+      const x2 = x(editor2, rowIndex, columnIndex);
+      const y2 = y(editor2, rowIndex, columnIndex);
+      const displayErrorMessage = message;
+      await invoke(
+        "Viewlet.send",
+        "EditorText",
+        "showOverlayMessage",
+        x2,
+        y2,
+        displayErrorMessage
+      );
+      if (!isError) {
+        const handleTimeout = () => {
+          console.log("ran timeout fn");
+          editorHideMessage(editor2);
+        };
+        state27.timeout = setTimeout(handleTimeout, 3e3);
+      }
+      return editor2;
+    };
+    showErrorMessage = (editor2, rowIndex, columnIndex, message) => {
+      return editorShowMessage(
+        editor2,
+        rowIndex,
+        columnIndex,
+        message,
+        true
+      );
+    };
+    editorHideMessage = async (editor2) => {
+      clearTimeout(state27.timeout);
+      state27.timeout = -1;
+      await invoke(
+        "Viewlet.send",
+        "EditorText",
+        "hideOverlayMessage"
+      );
+      return editor2;
+    };
+  }
+});
+
+// src/parts/EditorCommand/EditorCommandBraceCompletion.js
+var EditorCommandBraceCompletion_exports = {};
+__export(EditorCommandBraceCompletion_exports, {
+  editorBraceCompletion: () => editorBraceCompletion
 });
-var state26, editorBlur, registerListener, removeListener2;
-var init_EditorCommandBlur = __esm({
-  "src/parts/EditorCommand/EditorCommandBlur.js"() {
+var getErrorMessage, getMatchingClosingBrace, editorBraceCompletion;
+var init_EditorCommandBraceCompletion = __esm({
+  "src/parts/EditorCommand/EditorCommandBraceCompletion.js"() {
     "use strict";
-    state26 = {
-      blurListeners: []
-    };
-    editorBlur = (editor2) => {
-      return editor2;
+    init_Editor();
+    init_ExtensionHostBraceCompletion();
+    init_TextDocument();
+    init_EditorCommandReplaceSelection();
+    init_ExtensionHostTabCompletion();
+    init_EditorCommandShowMessage();
+    getErrorMessage = (error) => {
+      return `${error}`;
     };
-    registerListener = (fn2) => {
-      state26.blurListeners.push(fn2);
+    getMatchingClosingBrace = (brace) => {
+      switch (brace) {
+        case "{":
+          return "}";
+        case "(":
+          return ")";
+        case "[":
+          return "]";
+        default:
+          return "???";
+      }
     };
-    removeListener2 = (fn2) => {
-      state26.blurListeners.splice(state26.blurListeners.indexOf(fn2), 1);
+    editorBraceCompletion = async (editor2, text) => {
+      try {
+        const offset = offsetAt(editor2, editor2.cursor);
+        const result = await executeBraceCompletionProvider(
+          editor2,
+          offset,
+          text
+        );
+        if (result) {
+          const closingBrace = getMatchingClosingBrace(text);
+          const insertText = text + closingBrace;
+          const changes2 = editorReplaceSelections(
+            editor2,
+            [insertText],
+            "editorType"
+          );
+          return scheduleDocumentAndCursorsSelections(editor2, changes2);
+        }
+        const changes = editorReplaceSelections(editor2, [text], "editorType");
+        return scheduleDocumentAndCursorsSelections(editor2, changes);
+      } catch (error) {
+        console.error(error);
+        const position = Array.isArray(editor2.cursor) ? editor2.cursor[0] : editor2.cursor;
+        return showErrorMessage(
+          editor2,
+          position,
+          getErrorMessage(error)
+        );
+      }
     };
   }
 });
@@ -9345,45 +9633,6 @@ var init_EditorCommandCursorWordRight = __esm({
   }
 });
 
-// src/parts/EditorCommand/EditorCommandReplaceSelection.js
-var editorReplaceSelections;
-var init_EditorCommandReplaceSelection = __esm({
-  "src/parts/EditorCommand/EditorCommandReplaceSelection.js"() {
-    "use strict";
-    init_TextDocument();
-    editorReplaceSelections = (editor2, replacement, origin) => {
-      const changes = [];
-      const selections = editor2.selections;
-      for (let i = 0; i < selections.length; i += 4) {
-        const selectionStartRow = selections[i];
-        const selectionStartColumn = selections[i + 1];
-        const selectionEndRow = selections[i + 2];
-        const selectionEndColumn = selections[i + 3];
-        const start = {
-          rowIndex: selectionStartRow,
-          columnIndex: selectionStartColumn
-        };
-        const end = {
-          rowIndex: selectionEndRow,
-          columnIndex: selectionEndColumn
-        };
-        const selection = {
-          start,
-          end
-        };
-        changes.push({
-          start,
-          end,
-          inserted: replacement,
-          deleted: getSelectionText(editor2, selection),
-          origin
-        });
-      }
-      return changes;
-    };
-  }
-});
-
 // src/parts/EditorCommand/EditorCommandCut.js
 var EditorCommandCut_exports = {};
 __export(EditorCommandCut_exports, {
@@ -9716,38 +9965,6 @@ var init_FuzzySearch = __esm({
   }
 });
 
-// src/parts/EditorCommand/EditorCommandPosition.js
-var at, x, y;
-var init_EditorCommandPosition = __esm({
-  "src/parts/EditorCommand/EditorCommandPosition.js"() {
-    "use strict";
-    init_Assert();
-    at = (editor2, x2, y2, offset) => {
-      object(editor2);
-      number(x2);
-      number(y2);
-      number(offset);
-      const rowIndex = Math.max(
-        Math.floor((y2 - editor2.top + editor2.deltaY) / editor2.rowHeight),
-        0
-      );
-      const columnIndex = offset;
-      return {
-        rowIndex,
-        columnIndex
-      };
-    };
-    x = (editor2, rowIndex, columnIndex) => {
-      const x2 = columnIndex * editor2.columnWidth + editor2.left;
-      return x2;
-    };
-    y = (editor2, rowIndex, columnIndex) => {
-      const y2 = (rowIndex + 1) * editor2.rowHeight + editor2.top;
-      return y2;
-    };
-  }
-});
-
 // src/parts/EditorCommand/EditorCommandCompletion.js
 var EditorCommandCompletion_exports = {};
 __export(EditorCommandCompletion_exports, {
@@ -9879,19 +10096,19 @@ __export(EditorCommandComposition_exports, {
   editorCompositionEnd: () => editorCompositionEnd,
   editorCompositionStart: () => editorCompositionStart,
   editorCompositionUpdate: () => editorCompositionUpdate,
-  state: () => state27
+  state: () => state28
 });
-var state27, editorCompositionStart, getCompositionChanges, editorCompositionUpdate, editorCompositionEnd;
+var state28, editorCompositionStart, getCompositionChanges, editorCompositionUpdate, editorCompositionEnd;
 var init_EditorCommandComposition = __esm({
   "src/parts/EditorCommand/EditorCommandComposition.js"() {
     "use strict";
     init_Editor();
-    state27 = {
+    state28 = {
       isComposing: false,
       compositionText: ""
     };
     editorCompositionStart = (editor2, event) => {
-      state27.isComposing = true;
+      state28.isComposing = true;
       return editor2;
     };
     getCompositionChanges = (selections, data) => {
@@ -9901,7 +10118,7 @@ var init_EditorCommandComposition = __esm({
         const selectionStartColumn = selections[i + 1];
         const selectionEndRow = selections[i + 2];
         const selectionEndColumn = selections[i + 3];
-        const startColumnIndex = selectionStartColumn - state27.compositionText.length;
+        const startColumnIndex = selectionStartColumn - state28.compositionText.length;
         changes.push({
           start: {
             rowIndex: selectionStartRow,
@@ -9912,7 +10129,7 @@ var init_EditorCommandComposition = __esm({
             columnIndex: selectionEndColumn
           },
           inserted: [data],
-          deleted: [state27.compositionText],
+          deleted: [state28.compositionText],
           origin: "compositionUpdate"
         });
       }
@@ -9922,15 +10139,15 @@ var init_EditorCommandComposition = __esm({
       const selections = editor2.selections;
       const changes = getCompositionChanges(selections, data);
       console.log("composition update", changes);
-      state27.compositionText = data;
+      state28.compositionText = data;
       return scheduleDocumentAndCursorsSelections(editor2, changes);
     };
     editorCompositionEnd = (editor2, data) => {
       const selections = editor2.selections;
       const changes = getCompositionChanges(selections, data);
       console.log("composition end", { changes });
-      state27.isComposing = false;
-      state27.compositionText = "";
+      state28.isComposing = false;
+      state28.compositionText = "";
       return scheduleDocumentAndCursorsSelections(editor2, changes);
     };
   }
@@ -10009,12 +10226,12 @@ var init_EditorCommandFormat = __esm({
 });
 
 // src/parts/ExtensionHost/ExtensionHostDefinition.js
-var combineResults4, executeDefinitionProvider;
+var combineResults6, executeDefinitionProvider;
 var init_ExtensionHostDefinition = __esm({
   "src/parts/ExtensionHost/ExtensionHostDefinition.js"() {
     "use strict";
     init_ExtensionHostShared();
-    combineResults4 = (results) => {
+    combineResults6 = (results) => {
       return results[0];
     };
     executeDefinitionProvider = (editor2, offset) => {
@@ -10023,70 +10240,12 @@ var init_ExtensionHostDefinition = __esm({
         method: "ExtensionHostDefinition.executeDefinitionProvider",
         params: [editor2.id, offset],
         noProviderFoundMessage: "no definition provider found",
-        combineResults: combineResults4
+        combineResults: combineResults6
       });
     };
   }
 });
 
-// src/parts/EditorCommand/EditorCommandShowMessage.js
-var state28, editorShowMessage, showErrorMessage, editorHideMessage;
-var init_EditorCommandShowMessage = __esm({
-  "src/parts/EditorCommand/EditorCommandShowMessage.js"() {
-    "use strict";
-    init_Assert();
-    init_RendererProcess();
-    init_EditorCommandPosition();
-    state28 = {
-      timeout: -1
-    };
-    editorShowMessage = async (editor2, rowIndex, columnIndex, message, isError) => {
-      object(editor2);
-      number(rowIndex);
-      number(columnIndex);
-      string(message);
-      const x2 = x(editor2, rowIndex, columnIndex);
-      const y2 = y(editor2, rowIndex, columnIndex);
-      const displayErrorMessage = message;
-      await invoke(
-        "Viewlet.send",
-        "EditorText",
-        "showOverlayMessage",
-        x2,
-        y2,
-        displayErrorMessage
-      );
-      if (!isError) {
-        const handleTimeout = () => {
-          console.log("ran timeout fn");
-          editorHideMessage(editor2);
-        };
-        state28.timeout = setTimeout(handleTimeout, 3e3);
-      }
-      return editor2;
-    };
-    showErrorMessage = (editor2, rowIndex, columnIndex, message) => {
-      return editorShowMessage(
-        editor2,
-        rowIndex,
-        columnIndex,
-        message,
-        true
-      );
-    };
-    editorHideMessage = async (editor2) => {
-      clearTimeout(state28.timeout);
-      state28.timeout = -1;
-      await invoke(
-        "Viewlet.send",
-        "EditorText",
-        "hideOverlayMessage"
-      );
-      return editor2;
-    };
-  }
-});
-
 // src/parts/EditorCommand/EditorCommandGoToDefinition.js
 var EditorCommandGoToDefinition_exports = {};
 __export(EditorCommandGoToDefinition_exports, {
@@ -10174,12 +10333,12 @@ var init_EditorCommandGoToDefinition = __esm({
 });
 
 // src/parts/ExtensionHost/ExtensionHostTypeDefinition.js
-var combineResults5, executeTypeDefinitionProvider;
+var combineResults7, executeTypeDefinitionProvider;
 var init_ExtensionHostTypeDefinition = __esm({
   "src/parts/ExtensionHost/ExtensionHostTypeDefinition.js"() {
     "use strict";
     init_ExtensionHostShared();
-    combineResults5 = (results) => {
+    combineResults7 = (results) => {
       return results[0];
     };
     executeTypeDefinitionProvider = (editor2, offset) => {
@@ -10189,7 +10348,7 @@ var init_ExtensionHostTypeDefinition = __esm({
         params: [editor2.id, offset],
         noProviderFoundMessage: "No type definition provider found",
         noProviderFoundResult: void 0,
-        combineResults: combineResults5
+        combineResults: combineResults7
       });
     };
   }
@@ -10761,40 +10920,18 @@ var init_EditorCommandHandleSingleClick = __esm({
     editorHandleSingleClick = async (editor2, modifier, x2, y2, offset) => {
       object(editor2);
       string(modifier);
-      number(x2);
-      number(y2);
-      number(offset);
-      const position = at(editor2, x2, y2, offset);
-      switch (modifier) {
-        case Modifier.Alt:
-          return handleSingleClickWithAlt(editor2, position);
-        case Modifier.Ctrl:
-          return handleSingleClickWithCtrl(editor2, position);
-        default:
-          return handleSingleClickDefault(editor2, position);
-      }
-    };
-  }
-});
-
-// src/parts/ExtensionHost/ExtensionHostTabCompletion.js
-var combineResults6, executeTabCompletionProvider;
-var init_ExtensionHostTabCompletion = __esm({
-  "src/parts/ExtensionHost/ExtensionHostTabCompletion.js"() {
-    "use strict";
-    init_ExtensionHostShared();
-    combineResults6 = (results) => {
-      return results[0];
-    };
-    executeTabCompletionProvider = (editor2, offset) => {
-      return executeProviders({
-        event: `onTabCompletion:${editor2.languageId}`,
-        method: "ExtensionHost.executeTabCompletionProvider",
-        params: [editor2.id, offset],
-        noProviderFoundMessage: "No tab completion provider found",
-        noProviderFoundResult: void 0,
-        combineResults: combineResults6
-      });
+      number(x2);
+      number(y2);
+      number(offset);
+      const position = at(editor2, x2, y2, offset);
+      switch (modifier) {
+        case Modifier.Alt:
+          return handleSingleClickWithAlt(editor2, position);
+        case Modifier.Ctrl:
+          return handleSingleClickWithCtrl(editor2, position);
+        default:
+          return handleSingleClickDefault(editor2, position);
+      }
     };
   }
 });
@@ -10866,7 +11003,7 @@ var EditorCommandTabCompletion_exports = {};
 __export(EditorCommandTabCompletion_exports, {
   editorTabCompletion: () => editorTabCompletion
 });
-var getTabCompletion, getErrorMessage, editorTabCompletion;
+var getTabCompletion, getErrorMessage2, editorTabCompletion;
 var init_EditorCommandTabCompletion = __esm({
   "src/parts/EditorCommand/EditorCommandTabCompletion.js"() {
     "use strict";
@@ -10885,7 +11022,7 @@ var init_EditorCommandTabCompletion = __esm({
       );
       return tabCompletion;
     };
-    getErrorMessage = (error) => {
+    getErrorMessage2 = (error) => {
       return `${error}`;
     };
     editorTabCompletion = async (editor2) => {
@@ -10904,39 +11041,13 @@ var init_EditorCommandTabCompletion = __esm({
           editor2,
           rowIndex,
           columnIndex,
-          getErrorMessage(error)
+          getErrorMessage2(error)
         );
       }
     };
   }
 });
 
-// src/parts/ExtensionHost/ExtensionHostBraceCompletion.js
-var combineResults7, executeBraceCompletionProvider;
-var init_ExtensionHostBraceCompletion = __esm({
-  "src/parts/ExtensionHost/ExtensionHostBraceCompletion.js"() {
-    "use strict";
-    init_ExtensionHostShared();
-    init_Assert();
-    combineResults7 = (results) => {
-      return results[0];
-    };
-    executeBraceCompletionProvider = (editor2, offset, openingBrace) => {
-      object(editor2);
-      number(offset);
-      string(openingBrace);
-      return executeProviders({
-        event: `onBraceCompletion:${editor2.languageId}`,
-        method: "ExtensionHostBraceCompletion.executeBraceCompletionProvider",
-        params: [editor2.id, offset, openingBrace],
-        noProviderFoundMessage: "no brace completion providers found",
-        noProviderFoundResult: void 0,
-        combineResults: combineResults7
-      });
-    };
-  }
-});
-
 // src/parts/ExtensionHost/ExtensionHostClosingTagCompletion.js
 var init_ExtensionHostClosingTagCompletion = __esm({
   "src/parts/ExtensionHost/ExtensionHostClosingTagCompletion.js"() {
@@ -11828,6 +11939,39 @@ var init_EditorCommandSelectCharacterRight = __esm({
   }
 });
 
+// src/parts/EditorCommand/EditorCommandSelectDown.js
+var EditorCommandSelectDown_exports = {};
+__export(EditorCommandSelectDown_exports, {
+  selectDown: () => selectDown
+});
+var getSelectUpChanges, selectDown;
+var init_EditorCommandSelectDown = __esm({
+  "src/parts/EditorCommand/EditorCommandSelectDown.js"() {
+    "use strict";
+    init_Editor();
+    getSelectUpChanges = (lines, selections) => {
+      const max = lines.length - 1;
+      const newSelections = new Uint32Array(selections.length);
+      for (let i = 0; i < selections.length; i += 4) {
+        const selectionStartRow = selections[i];
+        const selectionStartColumn = selections[i + 1];
+        const selectionEndRow = selections[i + 2];
+        const selectionEndColumn = selections[i + 3];
+        newSelections[i] = selectionStartRow;
+        newSelections[i + 1] = selectionStartColumn;
+        newSelections[i + 2] = Math.min(selectionEndRow + 1, max);
+        newSelections[i + 3] = selectionEndColumn;
+      }
+      return newSelections;
+    };
+    selectDown = (editor2) => {
+      const { lines, selections } = editor2;
+      const newSelections = getSelectUpChanges(lines, selections);
+      return scheduleSelections(editor2, newSelections);
+    };
+  }
+});
+
 // src/parts/EditorCommand/EditorCommandSelectInsideString.js
 var EditorCommandSelectInsideString_exports = {};
 __export(EditorCommandSelectInsideString_exports, {
@@ -12098,6 +12242,38 @@ var init_EditorCommandSelectNextOccurrence = __esm({
   }
 });
 
+// src/parts/EditorCommand/EditorCommandSelectUp.js
+var EditorCommandSelectUp_exports = {};
+__export(EditorCommandSelectUp_exports, {
+  selectUp: () => selectUp
+});
+var getSelectUpChanges2, selectUp;
+var init_EditorCommandSelectUp = __esm({
+  "src/parts/EditorCommand/EditorCommandSelectUp.js"() {
+    "use strict";
+    init_Editor();
+    getSelectUpChanges2 = (lines, selections) => {
+      const newSelections = new Uint32Array(selections.length);
+      for (let i = 0; i < selections.length; i += 4) {
+        const selectionStartRow = selections[i];
+        const selectionStartColumn = selections[i + 1];
+        const selectionEndRow = selections[i + 2];
+        const selectionEndColumn = selections[i + 3];
+        newSelections[i] = Math.max(selectionStartRow - 1, 0);
+        newSelections[i + 1] = selectionStartColumn;
+        newSelections[i + 2] = selectionEndRow;
+        newSelections[i + 3] = selectionEndColumn;
+      }
+      return newSelections;
+    };
+    selectUp = (editor2) => {
+      const { lines, selections } = editor2;
+      const newSelections = getSelectUpChanges2(lines, selections);
+      return scheduleSelections(editor2, newSelections);
+    };
+  }
+});
+
 // src/parts/EditorCommand/EditorCommandSelectWordLeft.js
 var EditorCommandSelectWordLeft_exports = {};
 __export(EditorCommandSelectWordLeft_exports, {
@@ -12184,6 +12360,71 @@ var init_EditorCommandSetLanguageId = __esm({
   }
 });
 
+// src/parts/EditorCommand/EditorCommandSortLinesAscending.js
+var EditorCommandSortLinesAscending_exports = {};
+__export(EditorCommandSortLinesAscending_exports, {
+  sortLinesAscending: () => sortLinesAscending
+});
+var compareLine, getSortedLines, origin, getSortLinesAscendingChanges, sortLinesAscending;
+var init_EditorCommandSortLinesAscending = __esm({
+  "src/parts/EditorCommand/EditorCommandSortLinesAscending.js"() {
+    "use strict";
+    init_TextDocument();
+    init_Editor();
+    compareLine = (a, b) => {
+      return a.localeCompare(b);
+    };
+    getSortedLines = (lines) => {
+      const newLines = [...lines];
+      newLines.sort(compareLine);
+      return newLines;
+    };
+    origin = "sort-lines-ascending";
+    getSortLinesAscendingChanges = (lines, selections) => {
+      const startRowIndex = selections[0];
+      const startColumnIndex = selections[1];
+      const endRowIndex = selections[2];
+      const endColumnIndex = selections[3];
+      const startRow = lines[startRowIndex];
+      const endRow = lines[endRowIndex];
+      const changes = [];
+      for (let i = 0; i < selections.length; i += 4) {
+        const selectionStartRow = selections[i];
+        const selectionStartColumn = selections[i + 1];
+        const selectionEndRow = selections[i + 2];
+        const selectionEndColumn = selections[i + 3];
+        const start = {
+          rowIndex: selectionStartRow,
+          columnIndex: selectionStartColumn
+        };
+        const end = {
+          rowIndex: selectionEndRow,
+          columnIndex: selectionEndColumn
+        };
+        const selection = {
+          start,
+          end
+        };
+        const selectionLines = lines.slice(startRowIndex, endRowIndex + 1);
+        const sortedSelectionLines = getSortedLines(selectionLines);
+        changes.push({
+          start,
+          end,
+          inserted: sortedSelectionLines,
+          deleted: getSelectionText({ lines }, selection),
+          origin
+        });
+      }
+      return changes;
+    };
+    sortLinesAscending = (editor2) => {
+      const { lines, selections } = editor2;
+      const changes = getSortLinesAscendingChanges(lines, selections);
+      return scheduleDocumentAndCursorsSelections(editor2, changes);
+    };
+  }
+});
+
 // src/parts/EditorCommand/EditorCommandToggleBlockComment.js
 var EditorCommandToggleBlockComment_exports = {};
 __export(EditorCommandToggleBlockComment_exports, {
@@ -12587,69 +12828,6 @@ var init_EditorCommandUnindent = __esm({
   }
 });
 
-// src/parts/EditorCommand/EditorCommandBraceCompletion.js
-var EditorCommandBraceCompletion_exports = {};
-__export(EditorCommandBraceCompletion_exports, {
-  editorBraceCompletion: () => editorBraceCompletion
-});
-var getErrorMessage2, getMatchingClosingBrace, editorBraceCompletion;
-var init_EditorCommandBraceCompletion = __esm({
-  "src/parts/EditorCommand/EditorCommandBraceCompletion.js"() {
-    "use strict";
-    init_Editor();
-    init_ExtensionHostBraceCompletion();
-    init_TextDocument();
-    init_EditorCommandReplaceSelection();
-    init_ExtensionHostTabCompletion();
-    init_EditorCommandShowMessage();
-    getErrorMessage2 = (error) => {
-      return `${error}`;
-    };
-    getMatchingClosingBrace = (brace) => {
-      switch (brace) {
-        case "{":
-          return "}";
-        case "(":
-          return ")";
-        case "[":
-          return "]";
-        default:
-          return "???";
-      }
-    };
-    editorBraceCompletion = async (editor2, text) => {
-      try {
-        const offset = offsetAt(editor2, editor2.cursor);
-        const result = await executeBraceCompletionProvider(
-          editor2,
-          offset,
-          text
-        );
-        if (result) {
-          const closingBrace = getMatchingClosingBrace(text);
-          const insertText = text + closingBrace;
-          const changes2 = editorReplaceSelections(
-            editor2,
-            [insertText],
-            "editorType"
-          );
-          return scheduleDocumentAndCursorsSelections(editor2, changes2);
-        }
-        const changes = editorReplaceSelections(editor2, [text], "editorType");
-        return scheduleDocumentAndCursorsSelections(editor2, changes);
-      } catch (error) {
-        console.error(error);
-        const position = Array.isArray(editor2.cursor) ? editor2.cursor[0] : editor2.cursor;
-        return showErrorMessage(
-          editor2,
-          position,
-          getErrorMessage2(error)
-        );
-      }
-    };
-  }
-});
-
 // src/parts/ViewletEditorText/ViewletEditorText.ipc.js
 var ViewletEditorText_ipc_exports = {};
 __export(ViewletEditorText_ipc_exports, {
@@ -12685,6 +12863,7 @@ var init_ViewletEditorText_ipc = __esm({
     Imports = {
       ApplyEdit: () => Promise.resolve().then(() => (init_EditorCommandApplyEdit(), EditorCommandApplyEdit_exports)),
       Blur: () => Promise.resolve().then(() => (init_EditorCommandBlur(), EditorCommandBlur_exports)),
+      BraceCompletion: () => Promise.resolve().then(() => (init_EditorCommandBraceCompletion(), EditorCommandBraceCompletion_exports)),
       CancelSelection: () => Promise.resolve().then(() => (init_EditorCommandCancelSelection(), EditorCommandCancelSelection_exports)),
       ContextMenu: () => Promise.resolve().then(() => (init_EditorCommandHandleContextMenu(), EditorCommandHandleContextMenu_exports)),
       CopyLineDown: () => Promise.resolve().then(() => (init_EditorCommandCopyLineDown(), EditorCommandCopyLineDown_exports)),
@@ -12744,22 +12923,24 @@ var init_ViewletEditorText_ipc = __esm({
       SelectAllOccurrences: () => Promise.resolve().then(() => (init_EditorCommandSelectAllOccurrences(), EditorCommandSelectAllOccurrences_exports)),
       SelectCharacterLeft: () => Promise.resolve().then(() => (init_EditorCommandSelectCharacterLeft(), EditorCommandSelectCharacterLeft_exports)),
       SelectCharacterRight: () => Promise.resolve().then(() => (init_EditorCommandSelectCharacterRight(), EditorCommandSelectCharacterRight_exports)),
+      SelectDown: () => Promise.resolve().then(() => (init_EditorCommandSelectDown(), EditorCommandSelectDown_exports)),
       SelectInsideString: () => Promise.resolve().then(() => (init_EditorCommandSelectInsideString(), EditorCommandSelectInsideString_exports)),
       SelectLine: () => Promise.resolve().then(() => (init_EditorCommandSelectLine(), EditorCommandSelectLine_exports)),
       SelectNextOccurrence: () => Promise.resolve().then(() => (init_EditorCommandSelectNextOccurrence(), EditorCommandSelectNextOccurrence_exports)),
+      SelectUp: () => Promise.resolve().then(() => (init_EditorCommandSelectUp(), EditorCommandSelectUp_exports)),
       SelectWord: () => Promise.resolve().then(() => (init_EditorCommandSelectWord(), EditorCommandSelectWord_exports)),
       SelectWordLeft: () => Promise.resolve().then(() => (init_EditorCommandSelectWordLeft(), EditorCommandSelectWordLeft_exports)),
       SelectWordRight: () => Promise.resolve().then(() => (init_EditorCommandSelectWordRight(), EditorCommandSelectWordRight_exports)),
       SetDecorations: () => Promise.resolve().then(() => (init_EditorCommandSetDecorations(), EditorCommandSetDecorations_exports)),
       SetDeltaY: () => Promise.resolve().then(() => (init_EditorCommandSetDeltaY(), EditorCommandSetDeltaY_exports)),
       SetLanguageId: () => Promise.resolve().then(() => (init_EditorCommandSetLanguageId(), EditorCommandSetLanguageId_exports)),
+      SortLinesAscending: () => Promise.resolve().then(() => (init_EditorCommandSortLinesAscending(), EditorCommandSortLinesAscending_exports)),
       TabCompletion: () => Promise.resolve().then(() => (init_EditorCommandTabCompletion(), EditorCommandTabCompletion_exports)),
       ToggleBlockComment: () => Promise.resolve().then(() => (init_EditorCommandToggleBlockComment(), EditorCommandToggleBlockComment_exports)),
       ToggleComment: () => Promise.resolve().then(() => (init_EditorCommandToggleComment(), EditorCommandToggleComment_exports)),
       Type: () => Promise.resolve().then(() => (init_EditorCommandType(), EditorCommandType_exports)),
       Undo: () => Promise.resolve().then(() => (init_EditorCommandUndo(), EditorCommandUndo_exports)),
-      UnIndent: () => Promise.resolve().then(() => (init_EditorCommandUnindent(), EditorCommandUnindent_exports)),
-      BraceCompletion: () => Promise.resolve().then(() => (init_EditorCommandBraceCompletion(), EditorCommandBraceCompletion_exports))
+      UnIndent: () => Promise.resolve().then(() => (init_EditorCommandUnindent(), EditorCommandUnindent_exports))
     };
     Commands13 = {
       "Editor.applyEdit": lazyCommand(Imports.ApplyEdit, "editorApplyEdit"),
@@ -12830,21 +13011,24 @@ var init_ViewletEditorText_ipc = __esm({
       "Editor.selectAllOccurrences": lazyCommand(Imports.SelectAllOccurrences, "editorSelectAllOccurrences"),
       "Editor.selectCharacterLeft": lazyCommand(Imports.SelectCharacterLeft, "editorSelectCharacterLeft"),
       "Editor.selectCharacterRight": lazyCommand(Imports.SelectCharacterRight, "editorSelectCharacterRight"),
+      "Editor.selectDown": lazyCommand(Imports.SelectDown, "selectDown"),
       "Editor.selectInsideString": lazyCommand(Imports.SelectInsideString, "editorSelectInsideString"),
       "Editor.selectLine": lazyCommand(Imports.SelectLine, "editorSelectLine"),
       "Editor.selectNextOccurrence": lazyCommand(Imports.SelectNextOccurrence, "editorSelectNextOccurrence"),
+      "Editor.selectUp": lazyCommand(Imports.SelectUp, "selectUp"),
       "Editor.selectWord": lazyCommand(Imports.SelectWord, "editorSelectWord"),
       "Editor.selectWordLeft": lazyCommand(Imports.SelectWordLeft, "editorSelectWordLeft"),
       "Editor.selectWordRight": lazyCommand(Imports.SelectWordRight, "editorSelectWordRight"),
       "Editor.setDecorations": lazyCommand(Imports.SetDecorations, "setDecorations"),
       "Editor.setDeltaY": lazyCommand(Imports.SetDeltaY, "editorSetDeltaY"),
       "Editor.setLanguageId": lazyCommand(Imports.SetLanguageId, "setLanguageId"),
+      "Editor.sortLinesAscending": lazyCommand(Imports.SortLinesAscending, "sortLinesAscending"),
       "Editor.tabCompletion": lazyCommand(Imports.TabCompletion, "editorTabCompletion"),
       "Editor.toggleBlockComment": lazyCommand(Imports.ToggleBlockComment, "editorToggleBlockComment"),
       "Editor.toggleComment": lazyCommand(Imports.ToggleComment, "editorToggleComment"),
       "Editor.type": lazyCommand(Imports.Type, "editorType"),
       "Editor.undo": lazyCommand(Imports.Undo, "editorUndo"),
-      "Editor.unindent": lazyCommand(Imports.UnIndent, "editorUnindent")
+      "Editor.unindent": lazyCommand(Imports.UnIndent, "selectUp")
     };
   }
 });
@@ -12986,7 +13170,7 @@ var init_ViewletClock = __esm({
       };
     };
     loadContent14 = (state43) => {
-      const update2 = async () => {
+      const update4 = async () => {
         await invoke(
           "Viewlet.send",
           state43.id,
@@ -12996,7 +13180,7 @@ var init_ViewletClock = __esm({
       };
       return {
         ...state43,
-        interval: setInterval(update2, 1e3)
+        interval: setInterval(update4, 1e3)
       };
     };
     contentLoaded14 = async (state43) => {
@@ -15745,16 +15929,25 @@ var init_QuickPickNoop = __esm({
 });
 
 // src/parts/ExtensionHost/ExtensionHostCommands.js
-var getCommands, executeCommand;
+var getCommandsFromExtension, getCommandsFromExtensions, getCommands, executeCommand;
 var init_ExtensionHostCommands = __esm({
   "src/parts/ExtensionHost/ExtensionHostCommands.js"() {
     "use strict";
     init_ExtensionHostShared();
-    getCommands = () => {
-      return execute2({
-        method: "ExtensionHost.getCommands",
-        params: []
-      });
+    init_ExtensionMeta();
+    getCommandsFromExtension = (extension) => {
+      if (!extension || !extension.commands) {
+        return [];
+      }
+      return extension.commands;
+    };
+    getCommandsFromExtensions = (extensions) => {
+      return extensions.flatMap(getCommandsFromExtension);
+    };
+    getCommands = async () => {
+      const extensions = await getExtensions();
+      const commands = getCommandsFromExtensions(extensions);
+      return commands;
     };
     executeCommand = (id2) => {
       return executeProvider({
@@ -15830,6 +16023,7 @@ var init_QuickPickCommand = __esm({
     getExtensionPicks = async () => {
       try {
         const extensionPicks = await getCommands();
+        console.log({ extensionPicks });
         if (!extensionPicks) {
           return [];
         }
@@ -16124,7 +16318,7 @@ var init_QuickPickFile = __esm({
       };
     };
     getPicks7 = async (searchValue) => {
-      const workspace = state13.workspacePath;
+      const workspace = state12.workspacePath;
       if (!workspace) {
         return [];
       }
@@ -16133,7 +16327,7 @@ var init_QuickPickFile = __esm({
       return picks;
     };
     selectPick7 = async (item) => {
-      const workspace = state13.workspacePath;
+      const workspace = state12.workspacePath;
       const absolutePath = `${workspace}/${item.label}`;
       await openUri2(absolutePath);
       return {
@@ -16447,7 +16641,7 @@ var init_QuickPickColorTheme = __esm({
 });
 
 // src/parts/ViewletQuickPick/ViewletQuickPick.js
-var QuickPickState, name38, create44, filterPicks, getVisible6, getFilteredItems, getProvider2, getDefaultValue, loadContent25, contentLoaded25, dispose26, handleBlur3, getPick, selectIndex4, selectCurrentIndex, handleInput3, getNewValueInsertText, getNewValueDeleteContentBackward, RE_ALPHA_NUMERIC3, isAlphaNumeric3, getNewValueDeleteWordBackward, getNewValueDeleteContentForward, getNewValueDeleteWordForward, getNewValue, handleBeforeInput, focusIndex9, focusFirst9, focusLast9, focusPrevious9, focusNext9, setDeltaY5, handleWheel3, hasFunctionalRender16, renderValue2, renderCursorOffset, renderItems5, renderFocusedIndex6, render17;
+var QuickPickState, name38, create44, filterPicks, getVisible6, getFilteredItems, getProvider2, getDefaultValue, loadContent25, contentLoaded25, dispose26, handleBlur3, getPick, findLabelIndex, selectItem, selectIndex4, selectCurrentIndex, handleInput3, getNewValueInsertText, getNewValueDeleteContentBackward, RE_ALPHA_NUMERIC3, isAlphaNumeric3, getNewValueDeleteWordBackward, getNewValueDeleteContentForward, getNewValueDeleteWordForward, getNewValue, handleBeforeInput, focusIndex9, focusFirst9, focusLast9, focusPrevious9, focusNext9, setDeltaY5, handleWheel3, hasFunctionalRender16, renderValue2, renderCursorOffset, renderItems5, renderFocusedIndex6, render17;
 var init_ViewletQuickPick = __esm({
   "src/parts/ViewletQuickPick/ViewletQuickPick.js"() {
     "use strict";
@@ -16621,6 +16815,23 @@ var init_ViewletQuickPick = __esm({
       }
       console.warn("no pick matching index", index);
     };
+    findLabelIndex = (items, label) => {
+      for (let i = 0; i < items.length; i++) {
+        if (items[i].label === label) {
+          return i;
+        }
+      }
+      return -1;
+    };
+    selectItem = (state43, label) => {
+      string(label);
+      const index = findLabelIndex(state43.items, label);
+      console.log({ index });
+      if (index === -1) {
+        return state43;
+      }
+      return selectIndex4(state43, index);
+    };
     selectIndex4 = async (state43, index, button = 0) => {
       const actualIndex = index + state43.minLineY;
       const pick = getPick(state43, actualIndex);
@@ -16968,6 +17179,7 @@ __export(ViewletQuickPick_ipc_exports, {
   render: () => render17,
   selectCurrentIndex: () => selectCurrentIndex,
   selectIndex: () => selectIndex4,
+  selectItem: () => selectItem,
   setDeltaY: () => setDeltaY5
 });
 var Commands25;
@@ -16987,7 +17199,8 @@ var init_ViewletQuickPick_ipc = __esm({
       "QuickPick.focusNext": wrapViewletCommand("QuickPick", focusNext9),
       "QuickPick.handleBlur": wrapViewletCommand("QuickPick", handleBlur3),
       "QuickPick.handleBeforeInput": wrapViewletCommand("QuickPick", handleBeforeInput),
-      "QuickPick.handleWheel": wrapViewletCommand("QuickPick", handleWheel3)
+      "QuickPick.handleWheel": wrapViewletCommand("QuickPick", handleWheel3),
+      "QuickPick.selectItem": wrapViewletCommand("QuickPick", selectItem)
     };
   }
 });
@@ -17325,44 +17538,35 @@ var init_Viewlet = __esm({
     };
     wrapViewletCommand = (id2, fn2) => {
       const wrappedViewletCommand = async (...args) => {
-        try {
-          const activeInstance = getInstance(id2);
-          if (!activeInstance) {
-            console.info(
-              `cannot execute viewlet command ${id2}.${fn2.name}: no active instance for ${id2}`
-            );
-            return;
+        const activeInstance = getInstance(id2);
+        if (!activeInstance) {
+          console.info(
+            `cannot execute viewlet command ${id2}.${fn2.name}: no active instance for ${id2}`
+          );
+          return;
+        }
+        if (activeInstance.factory && activeInstance.factory.hasFunctionalRender) {
+          const oldState = activeInstance.state;
+          const newState = await fn2(oldState, ...args);
+          if (!newState) {
+            console.log({ fn: fn2 });
           }
-          if (activeInstance.factory && activeInstance.factory.hasFunctionalRender) {
-            const oldState = activeInstance.state;
-            const newState = await fn2(oldState, ...args);
-            if (!newState) {
-              console.log({ fn: fn2 });
-            }
-            object(newState);
-            if (oldState === newState) {
-              return;
-            }
-            const commands = render18(
-              activeInstance.factory,
-              oldState,
-              newState
-            );
-            setState(id2, newState);
-            await invoke(
-              "Viewlet.sendMultiple",
-              commands
-            );
-          } else {
-            return fn2(activeInstance.state, ...args);
+          object(newState);
+          if (oldState === newState) {
+            return;
           }
-        } catch (error) {
+          const commands = render18(
+            activeInstance.factory,
+            oldState,
+            newState
+          );
+          setState(id2, newState);
           await invoke(
-            "Viewlet.handleError",
-            id2,
-            "",
-            `${error}`
+            "Viewlet.sendMultiple",
+            commands
           );
+        } else {
+          return fn2(activeInstance.state, ...args);
         }
       };
       return wrappedViewletCommand;
@@ -17419,12 +17623,12 @@ var init_Viewlet = __esm({
     };
     openWidget = async (id2, ...args) => {
       const hasInstance2 = hasInstance(id2);
-      const type = args[0];
+      const type2 = args[0];
       const commands = await load({
         getModule: getModule5,
         id: id2,
         type: 0,
-        uri: `quickPick://${type}`,
+        uri: `quickPick://${type2}`,
         show: false,
         focus: true
       });
@@ -18098,7 +18302,7 @@ var init_MenuEntries = __esm({
 });
 
 // src/parts/Menu/Menu.js
-var state35, MENU_WIDTH, CONTEXT_MENU_ITEM_HEIGHT, CONTEXT_MENU_SEPARATOR_HEIGHT, CONTEXT_MENU_PADDING, CONTEXT_MENU_WIDTH, getMenuWidth, getMenuHeight, getCurrentMenu, addMenuInternal, getMenuBounds, show2, showSubMenuAtEnter, showSubMenu, selectIndex5, selectItem, selectCurrent2, hide2, hideSubMenus, MENU_DELAY_TRIANGLE, resolveAfterTimeout, handleMouseEnter2, focusIndex10, getIndexToFocusNextStartingAt, focusFirst4, focusLast4, getIndexToFocusPreviousStartingAt2, getIndexToFocusPrevious, focusPrevious4, canBeFocused, getIndexToFocusNext, focusNext4;
+var state35, MENU_WIDTH, CONTEXT_MENU_ITEM_HEIGHT, CONTEXT_MENU_SEPARATOR_HEIGHT, CONTEXT_MENU_PADDING, CONTEXT_MENU_WIDTH, getMenuWidth, getMenuHeight, getCurrentMenu, addMenuInternal, getMenuBounds, show2, showSubMenuAtEnter, showSubMenu, selectIndex5, selectItem2, selectCurrent2, hide2, hideSubMenus, MENU_DELAY_TRIANGLE, resolveAfterTimeout, handleMouseEnter2, focusIndex10, getIndexToFocusNextStartingAt, focusFirst4, focusLast4, getIndexToFocusPreviousStartingAt2, getIndexToFocusPrevious, focusPrevious4, canBeFocused, getIndexToFocusNext, focusNext4;
 var init_Menu = __esm({
   "src/parts/Menu/Menu.js"() {
     "use strict";
@@ -18242,7 +18446,7 @@ var init_Menu = __esm({
           break;
       }
     };
-    selectItem = (text) => {
+    selectItem2 = (text) => {
       for (let level = 0; level < state35.menus.length; level++) {
         const menu = state35.menus[level];
         for (let i = 0; i < menu.items.length; i++) {
@@ -19266,11 +19470,11 @@ var init_ClipBoard = __esm({
         throw new VError(error, "Failed to write text to clipboard");
       }
     };
-    writeNativeFiles = async (type, files2) => {
+    writeNativeFiles = async (type2, files2) => {
       try {
         await invoke3(
           "ClipBoard.writeFiles",
-          type,
+          type2,
           files2
         );
       } catch (error) {
@@ -19581,12 +19785,12 @@ var init_ky = __esm({
         };
         const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
         const result = isRetriableMethod ? ky2._retry(fn2) : fn2();
-        for (const [type, mimeType] of Object.entries(responseTypes)) {
-          result[type] = async () => {
+        for (const [type2, mimeType] of Object.entries(responseTypes)) {
+          result[type2] = async () => {
             ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
             const awaitedResult = await result;
             const response = awaitedResult.clone();
-            if (type === "json") {
+            if (type2 === "json") {
               if (response.status === 204) {
                 return "";
               }
@@ -19594,7 +19798,7 @@ var init_ky = __esm({
                 return options.parseJson(await response.text());
               }
             }
-            return response[type]();
+            return response[type2]();
           };
         }
         return result;
@@ -19877,7 +20081,7 @@ var init_Menu_ipc = __esm({
       "Menu.focusLast": focusLast4,
       "Menu.focusIndex": focusIndex10,
       "Menu.handleMouseEnter": handleMouseEnter2,
-      "Menu.selectItem": selectItem
+      "Menu.selectItem": selectItem2
     };
   }
 });
@@ -20288,7 +20492,8 @@ var init_Dialog = __esm({
         return;
       }
       const folders = await invoke3(
-        "Electron.showOpenDialog"
+        "Electron.showOpenDialog",
+        "Open Folder"
       );
       if (!folders || folders.length === 0) {
         return;
@@ -20599,7 +20804,8 @@ var init_FileSystem_ipc = __esm({
       "FileSystem.remove": remove8,
       "FileSystem.readDirWithFileTypes": readDirWithFileTypes8,
       "FileSystem.writeFile": writeFile12,
-      "FileSystem.mkdir": mkdir7
+      "FileSystem.mkdir": mkdir7,
+      "FileSystem.chmod": chmod3
     };
   }
 });
@@ -20857,10 +21063,10 @@ var init_SaveState = __esm({
         instances,
         mainEditors: [],
         workspace: {
-          path: state13.workspacePath,
-          homeDir: state13.homeDir,
-          pathSeparator: state13.pathSeparator,
-          uri: state13.workspaceUri
+          path: state12.workspacePath,
+          homeDir: state12.homeDir,
+          pathSeparator: state12.pathSeparator,
+          uri: state12.workspaceUri
         }
       };
     };
@@ -21134,9 +21340,9 @@ function createBlob(parts, properties) {
     return builder.getBlob(properties.type);
   }
 }
-function base64StringToBlob(base64, type) {
+function base64StringToBlob(base64, type2) {
   var parts = [binaryStringToArrayBuffer(atob(base64))];
-  return type ? createBlob(parts, { type }) : createBlob(parts);
+  return type2 ? createBlob(parts, { type: type2 }) : createBlob(parts);
 }
 function binaryStringToArrayBuffer(binary) {
   var length = binary.length;
@@ -21375,7 +21581,8 @@ var init_ExtensionMeta_ipc = __esm({
     "use strict";
     init_ExtensionMeta();
     Commands68 = {
-      "ExtensionMeta.addWebExtension": addWebExtension
+      "ExtensionMeta.addWebExtension": addWebExtension,
+      "ExtensionMeta.addNodeExtension": addNodeExtension
     };
   }
 });
@@ -21383,14 +21590,14 @@ var init_ExtensionMeta_ipc = __esm({
 // src/parts/TestFrameWorkComponent/TestFrameWorkComponentContextMenu.js
 var TestFrameWorkComponentContextMenu_exports = {};
 __export(TestFrameWorkComponentContextMenu_exports, {
-  selectItem: () => selectItem2
+  selectItem: () => selectItem3
 });
-var selectItem2;
+var selectItem3;
 var init_TestFrameWorkComponentContextMenu = __esm({
   "src/parts/TestFrameWorkComponent/TestFrameWorkComponentContextMenu.js"() {
     "use strict";
     init_Command();
-    selectItem2 = async (text) => {
+    selectItem3 = async (text) => {
       await execute("Menu.selectItem", text);
     };
   }
@@ -21408,11 +21615,15 @@ __export(TestFrameWorkComponentEditor_exports, {
   cursorWordRight: () => cursorWordRight,
   executeBraceCompletion: () => executeBraceCompletion,
   executeTabCompletion: () => executeTabCompletion,
+  findAllReferences: () => findAllReferences,
+  goToDefinition: () => goToDefinition,
+  goToTypeDefinition: () => goToTypeDefinition,
   openCompletion: () => openCompletion,
   openEditorContextMenu: () => openEditorContextMenu,
-  setCursor: () => setCursor
+  setCursor: () => setCursor,
+  type: () => type
 });
-var setCursor, openCompletion, openEditorContextMenu, executeTabCompletion, executeBraceCompletion, cursorCharacterRight, cursorCharacterLeft, copyLineDown, cursorDown, cursorUp, cursorWordLeft, cursorWordRight;
+var setCursor, openCompletion, openEditorContextMenu, executeTabCompletion, executeBraceCompletion, cursorCharacterRight, cursorCharacterLeft, copyLineDown, cursorDown, cursorUp, cursorWordLeft, cursorWordRight, goToDefinition, goToTypeDefinition, type, findAllReferences;
 var init_TestFrameWorkComponentEditor = __esm({
   "src/parts/TestFrameWorkComponent/TestFrameWorkComponentEditor.js"() {
     "use strict";
@@ -21453,6 +21664,18 @@ var init_TestFrameWorkComponentEditor = __esm({
     cursorWordRight = async () => {
       await execute("Editor.cursorWordRight");
     };
+    goToDefinition = async () => {
+      await execute("Editor.goToDefinition");
+    };
+    goToTypeDefinition = async () => {
+      await execute("Editor.goToTypeDefinition");
+    };
+    type = async (text) => {
+      await execute("Editor.type");
+    };
+    findAllReferences = async () => {
+      await execute("SideBar.show", "References", true);
+    };
   }
 });
 
@@ -21503,9 +21726,10 @@ var init_TestFrameWorkComponentExplorer = __esm({
 // src/parts/TestFrameWorkComponent/TestFrameWorkComponentExtension.js
 var TestFrameWorkComponentExtension_exports = {};
 __export(TestFrameWorkComponentExtension_exports, {
+  addNodeExtension: () => addNodeExtension2,
   addWebExtension: () => addWebExtension2
 });
-var addWebExtension2;
+var addWebExtension2, addNodeExtension2;
 var init_TestFrameWorkComponentExtension = __esm({
   "src/parts/TestFrameWorkComponent/TestFrameWorkComponentExtension.js"() {
     "use strict";
@@ -21514,29 +21738,43 @@ var init_TestFrameWorkComponentExtension = __esm({
       const absolutePath = relativePath;
       await execute("ExtensionMeta.addWebExtension", absolutePath);
     };
+    addNodeExtension2 = async (relativePath) => {
+      const absolutePath = relativePath;
+      await execute("ExtensionMeta.addNodeExtension", absolutePath);
+    };
   }
 });
 
 // src/parts/TestFrameWorkComponent/TestFrameWorkComponentFileSystem.js
 var TestFrameWorkComponentFileSystem_exports = {};
 __export(TestFrameWorkComponentFileSystem_exports, {
-  getTmpDir: () => getTmpDir,
+  chmod: () => chmod4,
+  getTmpDir: () => getTmpDir2,
   mkdir: () => mkdir8,
   writeFile: () => writeFile13
 });
-var writeFile13, mkdir8, getTmpDir;
+var writeFile13, mkdir8, getTmpDir2, chmod4;
 var init_TestFrameWorkComponentFileSystem = __esm({
   "src/parts/TestFrameWorkComponent/TestFrameWorkComponentFileSystem.js"() {
     "use strict";
     init_Command();
+    init_Platform();
     writeFile13 = async (path, content) => {
       await execute("FileSystem.writeFile", path, content);
     };
     mkdir8 = async (path) => {
       await execute("FileSystem.mkdir", path);
     };
-    getTmpDir = async () => {
-      return `memfs://`;
+    getTmpDir2 = async ({ scheme = "memfs" } = {}) => {
+      switch (scheme) {
+        case "memfs":
+          return "memfs://";
+        default:
+          return getTmpDir();
+      }
+    };
+    chmod4 = async (uri, permissions) => {
+      await execute("FileSystem.chmod", uri, permissions);
     };
   }
 });
@@ -21635,9 +21873,10 @@ var TestFrameWorkComponentQuickPick_exports = {};
 __export(TestFrameWorkComponentQuickPick_exports, {
   focusNext: () => focusNext11,
   open: () => open4,
+  selectItem: () => selectItem4,
   setValue: () => setValue3
 });
-var open4, setValue3, focusNext11;
+var open4, setValue3, focusNext11, selectItem4;
 var init_TestFrameWorkComponentQuickPick = __esm({
   "src/parts/TestFrameWorkComponent/TestFrameWorkComponentQuickPick.js"() {
     "use strict";
@@ -21651,6 +21890,9 @@ var init_TestFrameWorkComponentQuickPick = __esm({
     focusNext11 = async () => {
       await execute("QuickPick.focusNext");
     };
+    selectItem4 = async (label) => {
+      await execute("QuickPick.selectItem", label);
+    };
   }
 });
 
@@ -21686,9 +21928,58 @@ var init_TestFrameWorkComponentSideBar = __esm({
   }
 });
 
+// src/parts/TestFrameWorkComponent/TestFrameWorkComponentCommand.js
+var TestFrameWorkComponentCommand_exports = {};
+__export(TestFrameWorkComponentCommand_exports, {
+  execute: () => execute4
+});
+var execute4;
+var init_TestFrameWorkComponentCommand = __esm({
+  "src/parts/TestFrameWorkComponent/TestFrameWorkComponentCommand.js"() {
+    "use strict";
+    init_ExtensionHostCommands();
+    execute4 = async (id2, ...args) => {
+      await executeCommand(id2);
+    };
+  }
+});
+
+// src/parts/TestFrameWorkComponent/TestFrameWorkComponentPlatform.js
+var TestFrameWorkComponentPlatform_exports = {};
+__export(TestFrameWorkComponentPlatform_exports, {
+  getNodePath: () => getNodePath2
+});
+var getNodePath2;
+var init_TestFrameWorkComponentPlatform = __esm({
+  "src/parts/TestFrameWorkComponent/TestFrameWorkComponentPlatform.js"() {
+    "use strict";
+    init_Platform();
+    getNodePath2 = () => {
+      return getNodePath();
+    };
+  }
+});
+
+// src/parts/TestFrameWorkComponent/TestFrameWorkComponentSettings.js
+var TestFrameWorkComponentSettings_exports = {};
+__export(TestFrameWorkComponentSettings_exports, {
+  update: () => update3
+});
+var update3;
+var init_TestFrameWorkComponentSettings = __esm({
+  "src/parts/TestFrameWorkComponent/TestFrameWorkComponentSettings.js"() {
+    "use strict";
+    init_Preferences();
+    update3 = async (settings) => {
+      await update(settings);
+    };
+  }
+});
+
 // src/parts/TestFrameWorkComponent/TestFrameWorkComponent.js
 var TestFrameWorkComponent_exports = {};
 __export(TestFrameWorkComponent_exports, {
+  Command: () => TestFrameWorkComponentCommand_exports,
   ContextMenu: () => TestFrameWorkComponentContextMenu_exports,
   Editor: () => TestFrameWorkComponentEditor_exports,
   Explorer: () => TestFrameWorkComponentExplorer_exports,
@@ -21696,8 +21987,10 @@ __export(TestFrameWorkComponent_exports, {
   FileSystem: () => TestFrameWorkComponentFileSystem_exports,
   KeyBoard: () => TestFrameWorkComponentKeyBoard_exports,
   Main: () => TestFrameWorkComponentMain_exports,
+  Platform: () => TestFrameWorkComponentPlatform_exports,
   QuickPick: () => TestFrameWorkComponentQuickPick_exports,
   Search: () => TestFrameWorkComponentSearch_exports,
+  Settings: () => TestFrameWorkComponentSettings_exports,
   SideBar: () => TestFrameWorkComponentSideBar_exports,
   Workspace: () => TestFrameWorkComponentWorkspace_exports
 });
@@ -21715,6 +22008,9 @@ var init_TestFrameWorkComponent = __esm({
     init_TestFrameWorkComponentQuickPick();
     init_TestFrameWorkComponentSearch();
     init_TestFrameWorkComponentSideBar();
+    init_TestFrameWorkComponentCommand();
+    init_TestFrameWorkComponentPlatform();
+    init_TestFrameWorkComponentSettings();
   }
 });
 
@@ -21791,16 +22087,16 @@ var TestFrameWork_exports = {};
 __export(TestFrameWork_exports, {
   Locator: () => create45,
   expect: () => expect,
-  getTmpDir: () => getTmpDir2,
+  getTmpDir: () => getTmpDir3,
   test: () => test
 });
-var getTmpDir2, waitForReady, test, Assert, expect;
+var getTmpDir3, waitForReady, test, Assert, expect;
 var init_TestFrameWork = __esm({
   "src/parts/TestFrameWork/TestFrameWork.js"() {
     "use strict";
     init_RendererProcess();
     init_Locator();
-    getTmpDir2 = async () => {
+    getTmpDir3 = async () => {
       return `memfs://`;
     };
     waitForReady = async () => {
@@ -21933,7 +22229,7 @@ var init_TestFrameWork = __esm({
 });
 
 // src/parts/Test/Test.js
-var importScript, exposeGlobals, execute4;
+var importScript, exposeGlobals, execute5;
 var init_Test = __esm({
   "src/parts/Test/Test.js"() {
     "use strict";
@@ -21952,7 +22248,7 @@ var init_Test = __esm({
         global[key] = value;
       }
     };
-    execute4 = async (href) => {
+    execute5 = async (href) => {
       exposeGlobals(globalThis, TestFrameWorkComponent_exports);
       exposeGlobals(globalThis, TestFrameWork_exports);
       const scriptUrl = href;
@@ -21972,7 +22268,7 @@ var init_Test_ipc = __esm({
     "use strict";
     init_Test();
     Commands69 = {
-      "Test.execute": execute4
+      "Test.execute": execute5
     };
   }
 });
@@ -22174,6 +22470,7 @@ var init_Command = __esm({
           return MODULE_EXTENSION_HOST_CORE;
         case "ExtensionMeta.addExtension":
         case "ExtensionMeta.addWebExtension":
+        case "ExtensionMeta.addNodeExtension":
           return MODULE_EXTENSION_META;
         case "Test.execute":
           return MODULE_TEST;
@@ -22583,6 +22880,7 @@ var init_Workbench = __esm({
     init_SessionReplay();
     init_InitData();
     init_Command();
+    init_Platform();
     handleUnhandledRejection = async (event) => {
       console.info(`[renderer-worker] Unhandled Rejection: ${event.reason}`);
       try {
@@ -22672,7 +22970,8 @@ var init_Workbench = __esm({
       mark2("code/didLoadTitleBar");
       mark(Phase.Fifteen);
       if (isTest()) {
-        const jsPath = initData.Location.href.replace("/tests", "/packages/extension-host-worker-tests/src").replace(/\.html$/, ".js");
+        const testPath = await getTestPath();
+        const jsPath = initData.Location.href.replace("/tests", `${testPath}/src`).replace(/\.html$/, ".js");
         await execute("Test.execute", jsPath);
       } else {
         mark2("code/willLoadSaveState");