@codingame/monaco-vscode-extensions-service-override 8.0.4 → 9.0.2

package/vscode/src/vs/workbench/api/browser/mainThreadTesting.js

@@ -37,8 +37,8 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             disposeTestFollowups: ids => this.proxy.$disposeTestFollowups(ids),
             getTestsRelatedToCode: (uri, position, token) => this.proxy.$getTestsRelatedToCode(uri, position, token),
         }));
-        this._register(this.testService.onDidCancelTestRun(({ runId }) => {
-            this.proxy.$cancelExtensionTestRun(runId);
+        this._register(this.testService.onDidCancelTestRun(({ runId, taskId }) => {
+            this.proxy.$cancelExtensionTestRun(runId, taskId);
         }));
         this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => {
             const obj = {};
@@ -208,6 +208,14 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         const result = await this.testService.runResolvedTests(req, token);
         return result.id;
     }
+    async $getCoverageDetails(resultId, taskIndex, uri, token) {
+        const details = await this.resultService.getResult(resultId)
+            ?.tasks[taskIndex]
+            ?.coverage.get()
+            ?.getUri(( URI.from(uri)))
+            ?.details(token);
+        return details || [];
+    }
     dispose() {
         super.dispose();
         for (const subscription of ( this.testProviderRegistrations.values())) {

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -109,13 +109,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
         return this.notificationService.prompt(Severity$1.Info, ( localize(
-            4876,
+            4850,
             "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
             source,
             tunnelOptions.remoteAddress.port,
             tunnelOptions.localAddressPort
         )), [{
-                label: ( localize(4877, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
+                label: ( localize(4851, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
                 run: async () => {
                     this.elevateionRetry = true;
                     await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -51,7 +51,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                 }
                 catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( (new Action('default', ( localize(4866, "Open using default opener")), undefined, undefined, async () => {
+                        const openDefaultAction = ( (new Action('default', ( localize(4840, "Open using default opener")), undefined, undefined, async () => {
                             await this.openerService.open(uri, {
                                 allowTunneling: false,
                                 allowContributedOpeners: defaultExternalUriOpenerId,
@@ -61,7 +61,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                         this.notificationService.notify({
                             severity: Severity$1.Error,
                             message: ( localize(
-                                4867,
+                                4841,
                                 'Could not open uri with \'{0}\': {1}',
                                 id,
                                  (e.toString())

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -103,7 +103,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
 				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
 				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
 			</head>
-			<body>${( localize(9799, "An error occurred while loading view: {0}", escape(viewType)))}</body>
+			<body>${( localize(9829, "An error occurred while loading view: {0}", escape(viewType)))}</body>
 		</html>`;
     }
 };

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -24,6 +24,7 @@ import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace
 import { SideBySideEditor, SaveReason, EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
 import { firstOrDefault, coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri.service';
+import { revive } from 'vscode/vscode/vs/base/common/marshalling';
 
 let MainThreadWorkspace = class MainThreadWorkspace {
     constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
@@ -75,11 +76,11 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const wantsToDelete = removeCount > 0;
         if (wantsToAdd && !wantsToDelete) {
             if (addCount === 1) {
-                message = ( localize(4868, "Extension '{0}' added 1 folder to the workspace", extensionName));
+                message = ( localize(4842, "Extension '{0}' added 1 folder to the workspace", extensionName));
             }
             else {
                 message = ( localize(
-                    4869,
+                    4843,
                     "Extension '{0}' added {1} folders to the workspace",
                     extensionName,
                     addCount
@@ -88,11 +89,11 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         }
         else if (wantsToDelete && !wantsToAdd) {
             if (removeCount === 1) {
-                message = ( localize(4870, "Extension '{0}' removed 1 folder from the workspace", extensionName));
+                message = ( localize(4844, "Extension '{0}' removed 1 folder from the workspace", extensionName));
             }
             else {
                 message = ( localize(
-                    4871,
+                    4845,
                     "Extension '{0}' removed {1} folders from the workspace",
                     extensionName,
                     removeCount
@@ -100,7 +101,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             }
         }
         else {
-            message = ( localize(4872, "Extension '{0}' changed folders of the workspace", extensionName));
+            message = ( localize(4846, "Extension '{0}' changed folders of the workspace", extensionName));
         }
         return message;
     }
@@ -123,7 +124,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
     $startFileSearch(_includeFolder, options, token) {
         const includeFolder = URI.revive(_includeFolder);
         const workspace = this._contextService.getWorkspace();
-        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, options);
+        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, revive(options));
         return this._searchService.fileSearch(query, token).then(result => {
             return (
                  (result.results.map(m => m.resource))
@@ -139,7 +140,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const folder = URI.revive(_folder);
         const workspace = this._contextService.getWorkspace();
         const folders = folder ? [folder] : ( (workspace.folders.map(folder => folder.uri)));
-        const query = this._queryBuilder.text(pattern, folders, options);
+        const query = this._queryBuilder.text(pattern, folders, revive(options));
         query._reason = 'startTextSearch';
         const onProgress = (p) => {
             if (p.results) {

package/vscode/src/vs/workbench/services/extensionManagement/browser/extensionBisect.js

@@ -141,11 +141,11 @@ let ExtensionBisectUi = class ExtensionBisectUi {
     }
     _showBisectPrompt() {
         const goodPrompt = {
-            label: ( localize(1138, "I can't reproduce")),
+            label: ( localize(1141, "I can't reproduce")),
             run: () => this._commandService.executeCommand('extension.bisect.next', false)
         };
         const badPrompt = {
-            label: ( localize(1139, "I can reproduce")),
+            label: ( localize(1142, "I can reproduce")),
             run: () => this._commandService.executeCommand('extension.bisect.next', true)
         };
         const stop = {
@@ -154,11 +154,11 @@ let ExtensionBisectUi = class ExtensionBisectUi {
         };
         const message = this._extensionBisectService.disabledCount === 1
             ? ( localize(
-            1140,
+            1143,
             "Extension Bisect is active and has disabled 1 extension. Check if you can still reproduce the problem and proceed by selecting from these options."
         ))
             : ( localize(
-            1141,
+            1144,
             "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
             this._extensionBisectService.disabledCount
         ));
@@ -176,7 +176,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'extension.bisect.start',
-            title: ( localize2(1142, 'Start Extension Bisect')),
+            title: ( localize2(1145, 'Start Extension Bisect')),
             category: Categories.Help,
             f1: true,
             precondition: ( (ExtensionBisectUi.ctxIsBisectActive.negate())),
@@ -196,13 +196,13 @@ registerAction2(class extends Action2 {
         const extensionsBisect = accessor.get(IExtensionBisectService);
         const extensions = (await extensionManagement.getInstalled(ExtensionType.User)).filter(ext => extensionEnablementService.isEnabled(ext));
         const res = await dialogService.confirm({
-            message: ( localize(1143, "Extension Bisect")),
+            message: ( localize(1146, "Extension Bisect")),
             detail: ( localize(
-                1144,
+                1147,
                 "Extension Bisect will use binary search to find an extension that causes a problem. During the process the window reloads repeatedly (~{0} times). Each time you must confirm if you are still seeing problems.",
                 2 + Math.log2(extensions.length) | 0
             )),
-            primaryButton: ( localize(1145, "&&Start Extension Bisect"))
+            primaryButton: ( localize(1148, "&&Start Extension Bisect"))
         });
         if (res.confirmed) {
             await extensionsBisect.start(extensions);
@@ -214,7 +214,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'extension.bisect.next',
-            title: ( localize2(1146, 'Continue Extension Bisect')),
+            title: ( localize2(1149, 'Continue Extension Bisect')),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive
@@ -248,8 +248,8 @@ registerAction2(class extends Action2 {
             return;
         }
         if (done.bad) {
-            await dialogService.info(( localize(1147, "Extension Bisect")), ( localize(
-                1148,
+            await dialogService.info(( localize(1150, "Extension Bisect")), ( localize(
+                1151,
                 "Extension Bisect is done but no extension has been identified. This might be a problem with {0}.",
                 productService.nameShort
             )));
@@ -257,15 +257,15 @@ registerAction2(class extends Action2 {
         else {
             const res = await dialogService.confirm({
                 type: Severity$1.Info,
-                message: ( localize(1147, "Extension Bisect")),
-                primaryButton: ( localize(1149, "&&Report Issue & Continue")),
-                cancelButton: ( localize(1150, "Continue")),
+                message: ( localize(1150, "Extension Bisect")),
+                primaryButton: ( localize(1152, "&&Report Issue & Continue")),
+                cancelButton: ( localize(1153, "Continue")),
                 detail: ( localize(
-                    1151,
+                    1154,
                     "Extension Bisect is done and has identified {0} as the extension causing the problem.",
                     done.id
                 )),
-                checkbox: { label: ( localize(1152, "Keep this extension disabled")), checked: true }
+                checkbox: { label: ( localize(1155, "Keep this extension disabled")), checked: true }
             });
             if (res.checkboxChecked) {
                 await extensionEnablementService.disableExtension({ id: done.id }, undefined);
@@ -280,28 +280,28 @@ registerAction2(class extends Action2 {
     async _checkForBad(dialogService, bisectService) {
         const { result } = await dialogService.prompt({
             type: Severity$1.Info,
-            message: ( localize(1153, "Extension Bisect")),
+            message: ( localize(1156, "Extension Bisect")),
             detail: ( localize(
-                1154,
+                1157,
                 "Extension Bisect is active and has disabled {0} extensions. Check if you can still reproduce the problem and proceed by selecting from these options.",
                 bisectService.disabledCount
             )),
             buttons: [
                 {
-                    label: ( localize(1155, "I ca&&n't reproduce")),
+                    label: ( localize(1158, "I ca&&n't reproduce")),
                     run: () => false
                 },
                 {
-                    label: ( localize(1156, "I can &&reproduce")),
+                    label: ( localize(1159, "I can &&reproduce")),
                     run: () => true
                 },
                 {
-                    label: ( localize(1157, "&&Stop Bisect")),
+                    label: ( localize(1160, "&&Stop Bisect")),
                     run: () => undefined
                 }
             ],
             cancelButton: {
-                label: ( localize(1158, "&&Cancel Bisect")),
+                label: ( localize(1161, "&&Cancel Bisect")),
                 run: () => null
             }
         });
@@ -312,7 +312,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'extension.bisect.stop',
-            title: ( localize2(1159, 'Stop Extension Bisect')),
+            title: ( localize2(1162, 'Stop Extension Bisect')),
             category: Categories.Help,
             f1: true,
             precondition: ExtensionBisectUi.ctxIsBisectActive

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.js

@@ -114,7 +114,7 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         return this._resolveExtensionsDefault();
     }
     async _onExtensionHostExit(code) {
-        this._doStopExtensionHosts();
+        await this._doStopExtensionHosts();
         const automatedWindow = mainWindow;
         if (typeof automatedWindow.codeAutomationExit === 'function') {
             automatedWindow.codeAutomationExit(code, await getLogs(this._fileService, this._environmentService));

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.js

@@ -2,6 +2,7 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { addDisposableListener } from 'vscode/vscode/vs/base/browser/dom';
 import { parentOriginHash } from 'vscode/vscode/vs/base/browser/iframe';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import 'vscode/vscode/vs/base/common/amd';
 import { Barrier } from 'vscode/vscode/vs/base/common/async';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { onUnexpectedError, canceled } from 'vscode/vscode/vs/base/common/errors';
@@ -12,6 +13,7 @@ import { isWeb, Language, language } from 'vscode/vscode/vs/base/common/platform
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import 'vscode/vscode/vs/nls';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
 import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
 import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -26,6 +28,7 @@ import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/co
 import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
 import { ExtensionHostExitCode, isMessageOfType, MessageType, createMessageOfType, UIKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
 import { ExtensionHostStartup } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { getNLSMessages, getNLSLanguage } from 'vscode/vscode/vs/nls.messages';
 
 let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
     constructor(runningLocation, startup, _initDataProvider, _telemetryService, _contextService, _labelService, _logService, _loggerService, _environmentService, _userDataProfilesService, _productService, _layoutService, _storageService) {
@@ -60,7 +63,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         }
         COI.addSearchParam(suffixSearchParams, true, true);
         const suffix = `?${( suffixSearchParams.toString())}`;
-        const iframeModulePath = 'vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.html';
+        const iframeModulePath = `vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.${'esm.' }html`;
         if (isWeb) {
             const webEndpointUrlTemplate = this._productService.webEndpointUrlTemplate;
             const commit = this._productService.commit;
@@ -141,16 +144,16 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                 return rejectBarrier(ExtensionHostExitCode.UnexpectedError, err);
             }
             if (event.data.type === 'vscode.bootstrap.nls') {
-                const factoryModuleId = 'vs/base/worker/workerMain.js';
-                const baseUrl = require.toUrl(factoryModuleId).slice(0, -factoryModuleId.length);
+                const baseUrl = undefined ;
                 iframe.contentWindow.postMessage({
                     type: event.data.type,
                     data: {
                         baseUrl,
-                        workerUrl: require.toUrl(factoryModuleId),
+                        workerUrl: ( ( FileAccess.asBrowserUri('vs/workbench/api/worker/extensionHostWorker.esm.js')).toString(true)) ,
+                        fileRoot: globalThis._VSCODE_FILE_ROOT,
                         nls: {
-                            messages: globalThis._VSCODE_NLS_MESSAGES,
-                            language: globalThis._VSCODE_NLS_LANGUAGE
+                            messages: getNLSMessages(),
+                            language: getNLSLanguage()
                         }
                     }
                 }, '*');

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.js

@@ -167,17 +167,22 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }));
         this._register(this._lifecycleService.onWillShutdown(event => {
             if (this._remoteAgentService.getConnection()) {
-                event.join(() => this._remoteAgentService.endConnection(), {
+                event.join(async () => {
+                    await this._remoteAgentService.endConnection();
+                    await this._doStopExtensionHosts();
+                    this._remoteAgentService.getConnection()?.dispose();
+                }, {
                     id: 'join.disconnectRemote',
-                    label: ( localize(1126, "Disconnect Remote Agent")),
+                    label: ( localize(1128, "Disconnect Remote Agent")),
                     order: WillShutdownJoinerOrder.Last
                 });
             }
-        }));
-        this._register(this._lifecycleService.onDidShutdown(() => {
-            const connection = this._remoteAgentService.getConnection();
-            connection?.dispose();
-            this._doStopExtensionHosts();
+            else {
+                event.join(this._doStopExtensionHosts(), {
+                    id: 'join.stopExtensionHosts',
+                    label: ( localize(1129, "Stopping Extension Hosts")),
+                });
+            }
         }));
     }
     _getExtensionHostManagers(kind) {
@@ -246,7 +251,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localize(
-                    1127,
+                    1130,
                     "The following extensions contain dependency loops and have been disabled: {0}",
                     ( (result.removedDueToLooping.map(e => `'${e.identifier.value}'`))).join(', ')
                 ))
@@ -400,7 +405,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localize(
-                    1127,
+                    1130,
                     "The following extensions contain dependency loops and have been disabled: {0}",
                     ( (result.removedDueToLooping.map(e => `'${e.identifier.value}'`))).join(', ')
                 ))
@@ -415,7 +420,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
             const msg = ( localize(
-                1128,
+                1131,
                 "No extension host found that can launch the test runner at {0}.",
                  (this._environmentService.extensionTestsLocationURI.toString())
             ));
@@ -548,14 +553,14 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     stopExtensionHosts(reason, auto) {
         return this._doStopExtensionHostsWithVeto(reason, auto);
     }
-    _doStopExtensionHosts() {
+    async _doStopExtensionHosts() {
         const previouslyActivatedExtensionIds = [];
         for (const extensionStatus of ( (this._extensionStatus.values()))) {
             if (extensionStatus.activationStarted) {
                 previouslyActivatedExtensionIds.push(extensionStatus.id);
             }
         }
-        this._extensionHostManagers.disposeAllInReverse();
+        await this._extensionHostManagers.stopAllInReverse();
         for (const extensionStatus of ( (this._extensionStatus.values()))) {
             extensionStatus.clearRuntimeStatus();
         }
@@ -563,11 +568,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._onDidChangeExtensionsStatus.fire(previouslyActivatedExtensionIds);
         }
     }
-    async _doStopExtensionHostsWithVeto(reason, auto) {
+    async _doStopExtensionHostsWithVeto(reason, auto = false) {
         const vetos = [];
         const vetoReasons = ( (new Set()));
         this._onWillStop.fire({
             reason,
+            auto,
             veto(value, reason) {
                 vetos.push(value);
                 if (typeof value === 'boolean') {
@@ -581,23 +587,23 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( localize(1129, "{0} (Error: {1})", reason, toErrorMessage(error))));
+                        vetoReasons.add(( localize(1132, "{0} (Error: {1})", reason, toErrorMessage(error))));
                     });
                 }
             }
         });
         const veto = await handleVetos(vetos, error => this._logService.error(error));
         if (!veto) {
-            this._doStopExtensionHosts();
+            await this._doStopExtensionHosts();
         }
         else {
             if (!auto) {
                 const vetoReasonsArray = Array.from(vetoReasons);
                 this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`);
-                await this._dialogService.warn(( localize(1130, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
-                    ( localize(1131, "The reason for blocking the operation: {0}", vetoReasonsArray[0])) :
+                await this._dialogService.warn(( localize(1133, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
+                    ( localize(1134, "The reason for blocking the operation: {0}", vetoReasonsArray[0])) :
                     ( localize(
-                        1132,
+                        1135,
                         "The reasons for blocking the operation:\n- {0}",
                         vetoReasonsArray.join('\n -')
                     )));
@@ -669,7 +675,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (signal) {
                 this._onRemoteExtensionHostCrashed(extensionHost, signal);
             }
-            this._extensionHostManagers.disposeOne(extensionHost);
+            this._extensionHostManagers.stopOne(extensionHost);
         }
     }
     _getExtensionHostExitInfoWithTimeout(reconnectionToken) {
@@ -695,15 +701,15 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._remoteCrashTracker.registerCrash();
             if (this._remoteCrashTracker.shouldAutomaticallyRestart()) {
                 this._logService.info(`Automatically restarting the remote extension host.`);
-                this._notificationService.status(( localize(1133, "The remote extension host terminated unexpectedly. Restarting...")), { hideAfter: 5000 });
+                this._notificationService.status(( localize(1136, "The remote extension host terminated unexpectedly. Restarting...")), { hideAfter: 5000 });
                 this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
             }
             else {
                 this._notificationService.prompt(Severity$1.Error, ( localize(
-                    1134,
+                    1137,
                     "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
                 )), [{
-                        label: ( localize(1135, "Restart Remote Extension Host")),
+                        label: ( localize(1138, "Restart Remote Extension Host")),
                         run: () => {
                             this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
                         }
@@ -728,7 +734,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
     }
     async startExtensionHosts(updates) {
-        this._doStopExtensionHosts();
+        await this._doStopExtensionHosts();
         if (updates) {
             await this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem(updates.toAdd, updates.toRemove))));
         }
@@ -983,22 +989,30 @@ class ExtensionHostCollection extends Disposable {
         this._extensionHostManagers = [];
     }
     dispose() {
-        this.disposeAllInReverse();
+        for (let i = this._extensionHostManagers.length - 1; i >= 0; i--) {
+            const manager = this._extensionHostManagers[i];
+            manager.extensionHost.disconnect();
+            manager.dispose();
+        }
+        this._extensionHostManagers = [];
         super.dispose();
     }
     add(extensionHostManager, disposableStore) {
         this._extensionHostManagers.push(( (new ExtensionHostManagerData(extensionHostManager, disposableStore))));
     }
-    disposeAllInReverse() {
+    async stopAllInReverse() {
         for (let i = this._extensionHostManagers.length - 1; i >= 0; i--) {
-            this._extensionHostManagers[i].dispose();
+            const manager = this._extensionHostManagers[i];
+            await manager.extensionHost.disconnect();
+            manager.dispose();
         }
         this._extensionHostManagers = [];
     }
-    disposeOne(extensionHostManager) {
+    async stopOne(extensionHostManager) {
         const index = this._extensionHostManagers.findIndex(el => el.extensionHost === extensionHostManager);
         if (index >= 0) {
             this._extensionHostManagers.splice(index, 1);
+            await extensionHostManager.disconnect();
             extensionHostManager.dispose();
         }
     }
@@ -1180,7 +1194,7 @@ class ActivationFeatureMarkdowneRenderer extends Disposable {
 }
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'activationEvents',
-    label: ( localize(1136, "Activation Events")),
+    label: ( localize(1139, "Activation Events")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManager.js

@@ -91,13 +91,12 @@ let ExtensionHostManager = ExtensionHostManager_1 = class ExtensionHostManager e
             }));
         });
     }
+    async disconnect() {
+        await this._extensionHost?.disconnect?.();
+    }
     dispose() {
-        if (this._extensionHost) {
-            this._extensionHost.dispose();
-        }
-        if (this._rpcProtocol) {
-            this._rpcProtocol.dispose();
-        }
+        this._extensionHost?.dispose();
+        this._rpcProtocol?.dispose();
         for (let i = 0, len = this._customers.length; i < len; i++) {
             const customer = this._customers[i];
             try {
@@ -483,7 +482,7 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
     constructor() {
         super({
             id: 'editor.action.measureExtHostLatency',
-            title: ( localize2(4824, "Measure Extension Host Latency")),
+            title: ( localize2(4798, "Measure Extension Host Latency")),
             category: Categories.Developer,
             f1: true
         });

package/vscode/src/vs/workbench/services/extensions/common/extensionsProposedApi.js

@@ -107,7 +107,7 @@ class ApiProposalsMarkdowneRenderer extends Disposable {
 }
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'enabledApiProposals',
-    label: ( localize(1137, "API Proposals")),
+    label: ( localize(1140, "API Proposals")),
     access: {
         canToggle: false
     },

package/vscode/src/vs/workbench/services/extensions/common/extensionsUtil.js

@@ -8,7 +8,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
         const extension = result.get(systemExtension.identifier);
         if (extension) {
             logService.warn(( localize(
-                4825,
+                4799,
                 "Overwriting extension {0} with {1}.",
                 extension.extensionLocation.fsPath,
                 systemExtension.extensionLocation.fsPath
@@ -28,7 +28,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
             }
             else {
                 logService.warn(( localize(
-                    4825,
+                    4799,
                     "Overwriting extension {0} with {1}.",
                     extension.extensionLocation.fsPath,
                     userExtension.extensionLocation.fsPath
@@ -45,7 +45,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
         const extension = result.get(workspaceExtension.identifier);
         if (extension) {
             logService.warn(( localize(
-                4826,
+                4800,
                 "Overwriting {0} with Workspace Extension {1}.",
                 extension.extensionLocation.fsPath,
                 workspaceExtension.extensionLocation.fsPath
@@ -55,7 +55,7 @@ function dedupExtensions(system, user, workspace, development, logService) {
     });
     development.forEach(developedExtension => {
         logService.info(( localize(
-            4827,
+            4801,
             "Loading development extension at {0}",
             developedExtension.extensionLocation.fsPath
         )));

package/vscode/src/vs/workbench/services/extensions/common/lazyCreateExtensionHostManager.js

@@ -57,6 +57,9 @@ let LazyCreateExtensionHostManager = class LazyCreateExtensionHostManager extend
             await this._actual.ready();
         }
     }
+    async disconnect() {
+        await this._actual?.disconnect();
+    }
     representsRunningLocation(runningLocation) {
         return this._extensionHost.runningLocation.equals(runningLocation);
     }