@lvce-editor/extension-host-worker 8.19.0 → 8.24.0

package/dist/extension-api/index.js

@@ -847,7 +847,7 @@ var createRpc = (ipc) => {
     fn(response);
     delete callbacks2[id2];
   };
-  const rpc2 = {
+  const rpc = {
     async dispose() {
       await ipc?.dispose();
     },
@@ -867,7 +867,7 @@ var createRpc = (ipc) => {
       ipc.send(message);
     }
   };
-  return rpc2;
+  return rpc;
 };
 
 // packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/HandleMessage/HandleMessage.js
@@ -917,9 +917,9 @@ var create5 = async ({ commandMap: commandMap5, isMessagePortOpen = true, messag
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc2 = createRpc(ipc);
+  const rpc = createRpc(ipc);
   messagePort.start();
-  return rpc2;
+  return rpc;
 };
 
 // packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/WebWorkerRpcClient/WebWorkerRpcClient.js
@@ -931,8 +931,248 @@ var create6 = async ({ commandMap: commandMap5 }) => {
   register(commandMap5);
   const ipc = await listen(IpcChildWithModuleWorkerAndMessagePort$1);
   handleIpc(ipc);
-  const rpc2 = createRpc(ipc);
-  return rpc2;
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/CreateMockRpc/CreateMockRpc.js
+var createMockRpc = ({ commandMap: commandMap5 }) => {
+  const invocations = [];
+  const invoke2 = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap5[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke: invoke2,
+    invokeAndTransfer: invoke2
+  };
+  return mockRpc;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc-registry/dist/parts/RpcRegistry/RpcRegistry.js
+var rpcs = /* @__PURE__ */ Object.create(null);
+var set = (id2, rpc) => {
+  rpcs[id2] = rpc;
+};
+var get2 = (id2) => {
+  return rpcs[id2];
+};
+var remove2 = (id2) => {
+  delete rpcs[id2];
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc-registry/dist/parts/RpcFactory/RpcFactory.js
+var create7 = (rpcId) => {
+  return {
+    async dispose() {
+      const rpc = get2(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get2(rpcId);
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get2(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap5) {
+      const mockRpc = createMockRpc({ commandMap: commandMap5 });
+      set(rpcId, mockRpc);
+      mockRpc[Symbol.dispose] = () => {
+        remove2(rpcId);
+      };
+      return mockRpc;
+    },
+    set(rpc) {
+      set(rpcId, rpc);
+    }
+  };
+};
+
+// packages/extension-api/node_modules/@lvce-editor/constants/dist/parts/RpcId/RpcId.js
+var RpcId_exports = {};
+__export(RpcId_exports, {
+  AuthProcess: () => AuthProcess,
+  AuthWorker: () => AuthWorker,
+  BlobWorker: () => BlobWorker,
+  ChatCoordinatorWorker: () => ChatCoordinatorWorker,
+  ChatDebugWorker: () => ChatDebugWorker,
+  ChatMathWorker: () => ChatMathWorker,
+  ChatMessageParsingWorker: () => ChatMessageParsingWorker,
+  ChatNetworkWorker: () => ChatNetworkWorker,
+  ChatStorageWorker: () => ChatStorageWorker,
+  ChatToolWorker: () => ChatToolWorker,
+  ChatViewModelWorker: () => ChatViewModelWorker,
+  Cli: () => Cli,
+  ClipBoardProcess: () => ClipBoardProcess,
+  ClipBoardWorker: () => ClipBoardWorker,
+  ColorPickerWorker: () => ColorPickerWorker,
+  CompletionWorker: () => CompletionWorker,
+  DebugWorker: () => DebugWorker,
+  EditorWorker: () => EditorWorker,
+  EmbedsProcess: () => EmbedsProcess,
+  EmbedsWorker: () => EmbedsWorker,
+  ErrorWorker: () => ErrorWorker,
+  ExtensionDetailWorker: () => ExtensionDetailWorker,
+  ExtensionHostHelperProcess: () => ExtensionHostHelperProcess,
+  ExtensionHostWorker: () => ExtensionHostWorker,
+  ExtensionManagementWorker: () => ExtensionManagementWorker,
+  FileSearchWorker: () => FileSearchWorker,
+  FileSystemProcess: () => FileSystemProcess,
+  FileSystemWorker: () => FileSystemWorker,
+  FileWatcherProcess: () => FileWatcherProcess,
+  FindWidgetWorker: () => FindWidgetWorker,
+  GithubWorker: () => GithubWorker,
+  HoverWorker: () => HoverWorker,
+  IconThemeWorker: () => IconThemeWorker,
+  IframeWorker: () => IframeWorker,
+  MainAreaWorker: () => MainAreaWorker,
+  MainProcess: () => MainProcess,
+  MarkdownWorker: () => MarkdownWorker,
+  OpenerWorker: () => OpenerWorker,
+  OutputWorker: () => OutputWorker,
+  PreviewSandBoxWorker: () => PreviewSandBoxWorker,
+  PreviewWorker: () => PreviewWorker,
+  ProblemsWorker: () => ProblemsWorker,
+  ProcessExplorerRenderer: () => ProcessExplorerRenderer,
+  QuickPickWorker: () => QuickPickWorker,
+  RenameWorker: () => RenameWorker,
+  RendererProcess: () => RendererProcess,
+  RendererWorker: () => RendererWorker,
+  SearchProcess: () => SearchProcess,
+  SearchProcessElectron: () => SearchProcessElectron,
+  SettingsWorker: () => SettingsWorker,
+  SharedProcess: () => SharedProcess,
+  SourceActionWorker: () => SourceActionWorker,
+  SourceControlWorker: () => SourceControlWorker,
+  StatusBarWorker: () => StatusBarWorker,
+  SyntaxHighlightingWorker: () => SyntaxHighlightingWorker,
+  TemplateWorker: () => TemplateWorker,
+  TerminalProcess: () => TerminalProcess,
+  TestWithPlaywrightCli: () => TestWithPlaywrightCli,
+  TestWithPlaywrightWorker: () => TestWithPlaywrightWorker,
+  TestWorker: () => TestWorker,
+  TextMeasurementWorker: () => TextMeasurementWorker,
+  TextSearchWorker: () => TextSearchWorker,
+  TypescriptCompileProcess: () => TypescriptCompileProcess
+});
+var AuthProcess = 6040;
+var AuthWorker = 6010;
+var BlobWorker = 19e3;
+var ChatCoordinatorWorker = 6008;
+var ChatDebugWorker = 6006;
+var ChatMathWorker = 6007;
+var ChatMessageParsingWorker = 6009;
+var ChatNetworkWorker = 6002;
+var ChatStorageWorker = 6003;
+var ChatToolWorker = 6005;
+var ChatViewModelWorker = 6022;
+var Cli = 6004;
+var ClipBoardProcess = 3401;
+var ClipBoardWorker = 3400;
+var ColorPickerWorker = 302;
+var CompletionWorker = 301;
+var DebugWorker = 55;
+var EditorWorker = 99;
+var EmbedsProcess = 207;
+var EmbedsWorker = 208;
+var ErrorWorker = 3308;
+var ExtensionDetailWorker = 3402;
+var ExtensionHostHelperProcess = 3;
+var ExtensionHostWorker = 44;
+var ExtensionManagementWorker = 9006;
+var FileSearchWorker = 7013;
+var FileSystemProcess = 210;
+var FileSystemWorker = 209;
+var FileWatcherProcess = 220;
+var FindWidgetWorker = 9002;
+var GithubWorker = 4444;
+var HoverWorker = 9003;
+var IconThemeWorker = 7009;
+var IframeWorker = 344;
+var MainAreaWorker = 82221;
+var MainProcess = -5;
+var MarkdownWorker = 300;
+var OpenerWorker = 4561;
+var OutputWorker = 7001;
+var PreviewSandBoxWorker = 3212;
+var PreviewWorker = 3211;
+var ProblemsWorker = 3403;
+var ProcessExplorerRenderer = 33;
+var QuickPickWorker = 1e4;
+var RenameWorker = 9004;
+var RendererProcess = 1670;
+var RendererWorker = 1;
+var SearchProcess = 77;
+var SearchProcessElectron = 2;
+var SettingsWorker = 11010;
+var SharedProcess = 1492;
+var SourceActionWorker = 303;
+var SourceControlWorker = 66;
+var StatusBarWorker = 7201;
+var SyntaxHighlightingWorker = 3309;
+var TemplateWorker = 4445;
+var TerminalProcess = 7;
+var TestWithPlaywrightCli = 6e3;
+var TestWithPlaywrightWorker = 6001;
+var TestWorker = 9001;
+var TextMeasurementWorker = 7011;
+var TextSearchWorker = 7010;
+var TypescriptCompileProcess = 221;
+
+// packages/extension-api/node_modules/@lvce-editor/rpc-registry/dist/parts/ExtensionManagementWorker/ExtensionManagementWorker.js
+var ExtensionManagementWorker_exports = {};
+__export(ExtensionManagementWorker_exports, {
+  disable: () => disable,
+  disable2: () => disable2,
+  dispose: () => dispose,
+  enable: () => enable,
+  enable2: () => enable2,
+  getExtension: () => getExtension,
+  getLanguages: () => getLanguages,
+  install: () => install,
+  invalidateExtensionsCache: () => invalidateExtensionsCache,
+  invoke: () => invoke,
+  invokeAndTransfer: () => invokeAndTransfer,
+  registerMockRpc: () => registerMockRpc,
+  set: () => set2,
+  uninstall: () => uninstall
+});
+var { dispose, invoke, invokeAndTransfer, registerMockRpc, set: set2 } = create7(RpcId_exports.ExtensionManagementWorker);
+var enable = (id2) => {
+  return invoke(`Extensions.enable`, id2);
+};
+var enable2 = (id2, platform) => {
+  return invoke(`Extensions.enable2`, id2, platform);
+};
+var disable = (id2) => {
+  return invoke(`Extensions.disable`, id2);
+};
+var disable2 = (id2, platform) => {
+  return invoke(`Extensions.disable2`, id2, platform);
+};
+var getExtension = (id2) => {
+  return invoke(`Extensions.getExtension`, id2);
+};
+var getLanguages = (platform, assetDir) => {
+  return invoke("Extensions.getLanguages", platform, assetDir);
+};
+var install = (id2) => {
+  return invoke(`Extensions.install`, id2);
+};
+var uninstall = (id2) => {
+  return invoke(`Extensions.uninstall`, id2);
+};
+var invalidateExtensionsCache = () => {
+  return invoke(`Extensions.invalidateExtensionsCache`);
 };
 
 // packages/extension-api/src/parts/ExtensionApiError/ExtensionApiError.ts
@@ -1148,8 +1388,66 @@ var getCompletionProviderRegistrySnapshot = () => {
 };
 var resetCompletionProviderRegistry = registry.reset;
 
-// packages/extension-api/src/parts/FormattingProviderRegistry/FormattingProviderRegistry.ts
+// packages/extension-api/src/parts/DiagnosticProviderRegistry/DiagnosticProviderRegistry.ts
+var getType2 = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+};
+var validateDiagnosticResult = (diagnostics) => {
+  if (!Array.isArray(diagnostics)) {
+    throw new ExtensionApiError(`invalid diagnostic result: diagnostic must be of type array but is ${getType2(diagnostics)}`);
+  }
+  for (const item of diagnostics) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new ExtensionApiError(`invalid diagnostic result: expected diagnostic item to be of type object but was of type ${getType2(item)}`);
+    }
+  }
+  return diagnostics;
+};
 var registry2 = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      id: provider.id,
+      languageId: provider.languageId,
+      provideDiagnostics(textDocument, ...args) {
+        return provider.provideDiagnostics(textDocument, ...args);
+      }
+    };
+  },
+  providerName: "diagnostic provider",
+  requiredMethods: ["provideDiagnostics"],
+  requireLanguageId: true
+});
+var hasDiagnosticProvider = registry2.hasProvider;
+var registerDiagnosticProvider = (provider) => {
+  const registeredProvider = registry2.registerProvider(provider);
+  return {
+    dispose() {
+      registry2.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+var executeDiagnosticProvider = async (textDocument, ...args) => {
+  return registry2.executeProviderByLanguageId(textDocument.languageId, "provideDiagnostics", [textDocument, ...args], validateDiagnosticResult);
+};
+var getDiagnosticProviders = registry2.getProviders;
+var getDiagnosticProviderRegistrySnapshot = () => {
+  return {
+    providers: registry2.getProviders()
+  };
+};
+var resetDiagnosticProviderRegistry = registry2.reset;
+
+// packages/extension-api/src/parts/FormattingProviderRegistry/FormattingProviderRegistry.ts
+var registry3 = createProviderRegistry({
   mapProvider(provider) {
     return {
       format(textDocument, ...args) {
@@ -1163,45 +1461,33 @@ var registry2 = createProviderRegistry({
   requiredMethods: ["format"],
   requireLanguageId: true
 });
-var hasFormattingProvider = registry2.hasProvider;
+var hasFormattingProvider = registry3.hasProvider;
 var registerFormattingProvider = (provider) => {
-  const registeredProvider = registry2.registerProvider(provider);
+  const registeredProvider = registry3.registerProvider(provider);
   return {
     dispose() {
-      registry2.deleteProvider(registeredProvider.id);
+      registry3.deleteProvider(registeredProvider.id);
     }
   };
 };
 var executeFormattingProvider = async (textDocument, ...args) => {
-  return registry2.executeProviderByLanguageId(textDocument.languageId, "format", [textDocument, ...args]);
+  return registry3.executeProviderByLanguageId(textDocument.languageId, "format", [textDocument, ...args]);
 };
-var getFormattingProviders = registry2.getProviders;
+var getFormattingProviders = registry3.getProviders;
 var getFormattingProviderRegistrySnapshot = () => {
   return {
-    providers: registry2.getProviders()
+    providers: registry3.getProviders()
   };
 };
-var resetFormattingProviderRegistry = registry2.reset;
-
-// packages/extension-api/src/parts/Rpc/Rpc.ts
-var rpc;
-var set = (value) => {
-  rpc = value;
-};
-var invoke = async (method, ...params) => {
-  if (!rpc) {
-    return void 0;
-  }
-  return rpc.invoke(method, ...params);
-};
+var resetFormattingProviderRegistry = registry3.reset;
 
 // packages/extension-api/src/parts/NotifyStatusBarChange/NotifyStatusBarChange.ts
 var notifyStatusBarChange = async (id2) => {
-  await invoke("StatusBar.handleChange", id2);
+  await ExtensionManagementWorker_exports.invoke("StatusBar.handleChange", id2);
 };
 
 // packages/extension-api/src/parts/StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.ts
-var registry3 = createProviderRegistry({
+var registry4 = createProviderRegistry({
   mapProvider(provider) {
     return {
       getStatusBarItem() {
@@ -1219,13 +1505,13 @@ var getStatusBarItem = (provider) => {
 var isStatusBarItem = (item) => {
   return item !== void 0;
 };
-var hasStatusBarItemProvider = registry3.hasProvider;
+var hasStatusBarItemProvider = registry4.hasProvider;
 var registerStatusBarItemProvider = (provider) => {
-  const registeredProvider = registry3.registerProvider(provider);
+  const registeredProvider = registry4.registerProvider(provider);
   void notifyStatusBarChange(registeredProvider.id);
   return {
     dispose() {
-      registry3.deleteProvider(registeredProvider.id);
+      registry4.deleteProvider(registeredProvider.id);
       void notifyStatusBarChange(registeredProvider.id);
     },
     async refresh() {
@@ -1233,19 +1519,19 @@ var registerStatusBarItemProvider = (provider) => {
     }
   };
 };
-var getStatusBarItemProviders = registry3.getProviders;
+var getStatusBarItemProviders = registry4.getProviders;
 var getStatusBarItems = () => {
-  return registry3.getProviders().map(getStatusBarItem).filter(isStatusBarItem);
+  return registry4.getProviders().map(getStatusBarItem).filter(isStatusBarItem);
 };
 var getStatusBarItemProviderRegistrySnapshot = () => {
   return {
-    providers: registry3.getProviders()
+    providers: registry4.getProviders()
   };
 };
-var resetStatusBarItemProviderRegistry = registry3.reset;
+var resetStatusBarItemProviderRegistry = registry4.reset;
 
 // packages/extension-api/src/parts/HoverProviderRegistry/HoverProviderRegistry.ts
-var getType2 = (value) => {
+var getType3 = (value) => {
   if (value === null) {
     return "null";
   }
@@ -1262,11 +1548,11 @@ var validateHoverResult = (hover) => {
     return void 0;
   }
   if (!hover || typeof hover !== "object" || Array.isArray(hover)) {
-    throw new ExtensionApiError(`invalid hover result: hover must be of type object or undefined but is ${getType2(hover)}`);
+    throw new ExtensionApiError(`invalid hover result: hover must be of type object or undefined but is ${getType3(hover)}`);
   }
   return hover;
 };
-var registry4 = createProviderRegistry({
+var registry5 = createProviderRegistry({
   mapProvider(provider) {
     return {
       id: provider.id,
@@ -1280,38 +1566,158 @@ var registry4 = createProviderRegistry({
   requiredMethods: ["provideHover"],
   requireLanguageId: true
 });
-var hasHoverProvider = registry4.hasProvider;
+var hasHoverProvider = registry5.hasProvider;
 var registerHoverProvider = (provider) => {
-  const registeredProvider = registry4.registerProvider(provider);
+  const registeredProvider = registry5.registerProvider(provider);
   return {
     dispose() {
-      registry4.deleteProvider(registeredProvider.id);
+      registry5.deleteProvider(registeredProvider.id);
     }
   };
 };
 var executeHoverProvider = async (textDocument, offset, ...args) => {
-  return registry4.executeProviderByLanguageId(textDocument.languageId, "provideHover", [textDocument, offset, ...args], validateHoverResult);
+  return registry5.executeProviderByLanguageId(textDocument.languageId, "provideHover", [textDocument, offset, ...args], validateHoverResult);
 };
-var getHoverProviders = registry4.getProviders;
+var getHoverProviders = registry5.getProviders;
 var getHoverProviderRegistrySnapshot = () => {
   return {
-    providers: registry4.getProviders()
+    providers: registry5.getProviders()
+  };
+};
+var resetHoverProviderRegistry = registry5.reset;
+
+// packages/extension-api/src/parts/OutputChannel/OutputChannel.ts
+var outputChannels = /* @__PURE__ */ Object.create(null);
+var isActivated = false;
+var RE_DASH_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var assertOutputChannelId = (id2) => {
+  if (typeof id2 !== "string" || id2.length === 0) {
+    throw new ExtensionApiError("output channel id is required");
+  }
+  if (!RE_DASH_CASE.test(id2)) {
+    throw new ExtensionApiError(`output channel id ${id2} must be dash-case`);
+  }
+};
+var assertCanWrite = (id2) => {
+  if (!isActivated) {
+    throw new ExtensionApiError(`output channel ${id2} cannot be written before activate`);
+  }
+};
+var ExtensionOutputChannel = class {
+  #id;
+  constructor(id2) {
+    this.#id = id2;
+  }
+  async append(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.appendOutputChannel", this.#id, text);
+  }
+  async appendLine(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.appendOutputChannel", this.#id, `${text}
+`);
+  }
+  async clear() {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.clearOutputChannel", this.#id);
+  }
+  async replace(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.replaceOutputChannel", this.#id, text);
+  }
+};
+var activateOutputChannels = () => {
+  isActivated = true;
+};
+var createOutputChannel = (id2) => {
+  assertOutputChannelId(id2);
+  if (id2 in outputChannels) {
+    throw new ExtensionApiError(`output channel ${id2} is already created`);
+  }
+  outputChannels[id2] = {
+    id: id2
+  };
+  return new ExtensionOutputChannel(id2);
+};
+var getOutputChannelRegistrySnapshot = () => {
+  return {
+    outputChannels: Object.values(outputChannels)
+  };
+};
+var resetOutputChannelRegistry = () => {
+  for (const id2 of Object.keys(outputChannels)) {
+    delete outputChannels[id2];
+  }
+  isActivated = false;
+};
+
+// packages/extension-api/src/parts/ViewRegistry/ViewRegistry.ts
+var views = /* @__PURE__ */ Object.create(null);
+var assertView = (view) => {
+  if (!view) {
+    throw new ExtensionApiError("view is not defined");
+  }
+  if (typeof view.id !== "string" || view.id.length === 0) {
+    throw new ExtensionApiError("view is missing id");
+  }
+  if (typeof view.create !== "function") {
+    throw new ExtensionApiError(`view ${view.id} is missing create function`);
+  }
+  if (view.id in views) {
+    throw new ExtensionApiError(`view ${view.id} is already registered`);
+  }
+};
+var toRegisteredView = (view) => {
+  return {
+    icon: view.icon,
+    id: view.id,
+    title: view.title
+  };
+};
+var registerView = (view) => {
+  assertView(view);
+  views[view.id] = view;
+  return {
+    dispose() {
+      delete views[view.id];
+    }
   };
 };
-var resetHoverProviderRegistry = registry4.reset;
+var executeViewProvider = (id2) => {
+  const view = views[id2];
+  if (!view) {
+    throw new ExtensionApiError(`view ${id2} not found`);
+  }
+  return view.create();
+};
+var getViewRegistrySnapshot = () => {
+  return {
+    views: Object.values(views).map(toRegisteredView)
+  };
+};
+var resetViewRegistry = () => {
+  for (const id2 of Object.keys(views)) {
+    delete views[id2];
+  }
+};
 
 // packages/extension-api/src/parts/ExtensionApiCommandMap/ExtensionApiCommandMap.ts
 var commandMap = {
   "ExtensionApi.executeCommand": executeCommand,
   "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
+  "ExtensionApi.executeDiagnosticProvider": executeDiagnosticProvider,
   "ExtensionApi.executeFormattingProvider": executeFormattingProvider,
   "ExtensionApi.executeHoverProvider": executeHoverProvider,
   "ExtensionApi.executeResolveCompletionItemProvider": executeResolveCompletionItemProvider,
+  "ExtensionApi.executeViewProvider": executeViewProvider,
   "ExtensionApi.getCommandRegistrySnapshot": getCommandRegistrySnapshot,
   "ExtensionApi.getCompletionProviderRegistrySnapshot": getCompletionProviderRegistrySnapshot,
+  "ExtensionApi.getDiagnosticProviderRegistrySnapshot": getDiagnosticProviderRegistrySnapshot,
   "ExtensionApi.getFormattingProviderRegistrySnapshot": getFormattingProviderRegistrySnapshot,
   "ExtensionApi.getHoverProviderRegistrySnapshot": getHoverProviderRegistrySnapshot,
-  "ExtensionApi.getStatusBarItems": getStatusBarItems
+  "ExtensionApi.getOutputChannelRegistrySnapshot": getOutputChannelRegistrySnapshot,
+  "ExtensionApi.getStatusBarItems": getStatusBarItems,
+  "ExtensionApi.getViewRegistrySnapshot": getViewRegistrySnapshot
 };
 
 // packages/extension-api/src/parts/ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.ts
@@ -1346,10 +1752,10 @@ var commandMap3 = {
 
 // packages/extension-api/src/parts/ExtensionApiWorkerListen/ExtensionApiWorkerListen.ts
 var listen2 = async () => {
-  const rpc2 = WebWorkerRpcClient_exports.create({
+  const rpc = WebWorkerRpcClient_exports.create({
     commandMap: commandMap3
   });
-  return rpc2;
+  return rpc;
 };
 
 // packages/extension-api/src/parts/Activation/Activation.ts
@@ -1358,18 +1764,19 @@ var activate = async () => {
   if (!rpcPromise) {
     rpcPromise = listen2();
   }
-  const rpc2 = await rpcPromise;
-  set(rpc2);
+  const rpc = await rpcPromise;
+  ExtensionManagementWorker_exports.set(rpc);
+  activateOutputChannels();
 };
 
 // packages/extension-api/src/parts/ExecuteCommand/ExecuteCommand.ts
 var executeCommand2 = async (id2, ...args) => {
-  return invoke("Extensions.executeCommand", id2, ...args);
+  return ExtensionManagementWorker_exports.invoke("Extensions.executeCommand", id2, ...args);
 };
 
 // packages/extension-api/src/parts/QuickPick/QuickPick.ts
 var showQuickPick = async (options) => {
-  return invoke("ExtensionHostQuickPick.showQuickPick", options);
+  return ExtensionManagementWorker_exports.invoke("ExtensionHostQuickPick.showQuickPick", options);
 };
 
 // packages/extension-api/src/parts/CommandMap/CommandMap.ts
@@ -1399,24 +1806,35 @@ var handleExtensionManagementMessagePort2 = async ({
 };
 export {
   activate,
+  createOutputChannel,
   executeCommand2 as executeCommand,
   executeCompletionProvider,
+  executeDiagnosticProvider,
   executeFormattingProvider,
   executeHoverProvider,
   executeResolveCompletionItemProvider,
+  executeViewProvider,
   getCompletionProviderRegistrySnapshot,
+  getDiagnosticProviderRegistrySnapshot,
   getFormattingProviderRegistrySnapshot,
   getHoverProviderRegistrySnapshot,
+  getOutputChannelRegistrySnapshot,
   getStatusBarItemProviderRegistrySnapshot,
+  getViewRegistrySnapshot,
   handleExtensionManagementMessagePort2 as handleExtensionManagementMessagePort,
   registerCommand,
   registerCompletionProvider,
+  registerDiagnosticProvider,
   registerFormattingProvider,
   registerHoverProvider,
   registerStatusBarItemProvider,
+  registerView,
   resetCompletionProviderRegistry,
+  resetDiagnosticProviderRegistry,
   resetFormattingProviderRegistry,
   resetHoverProviderRegistry,
+  resetOutputChannelRegistry,
   resetStatusBarItemProviderRegistry,
+  resetViewRegistry,
   showQuickPick
 };