@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.0.0

package/vscode/src/vs/workbench/api/browser/{mainThreadChatProvider.js → mainThreadLanguageModels.js}

@@ -1,4 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore, DisposableMap, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
@@ -6,33 +7,35 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IChatProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatProvider';
+import { ILanguageModelsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { IAuthenticationAccessService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationAccessService';
 import { IAuthenticationService, INTERNAL_AUTH_PROVIDER_PREFIX } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
 import { IExtensionFeaturesManagementService, Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 
-let MainThreadChatProvider = class MainThreadChatProvider {
-    constructor(extHostContext, _chatProviderService, _extensionFeaturesManagementService, _logService, _authenticationService, _extensionService) {
+let MainThreadLanguageModels = class MainThreadLanguageModels {
+    constructor(extHostContext, _chatProviderService, _extensionFeaturesManagementService, _logService, _authenticationService, _authenticationAccessService, _extensionService) {
         this._chatProviderService = _chatProviderService;
         this._extensionFeaturesManagementService = _extensionFeaturesManagementService;
         this._logService = _logService;
         this._authenticationService = _authenticationService;
+        this._authenticationAccessService = _authenticationAccessService;
         this._extensionService = _extensionService;
         this._store = ( new DisposableStore());
         this._providerRegistrations = ( new DisposableMap());
         this._pendingProgress = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
-        this._proxy.$updateLanguageModels({ added: _chatProviderService.getProviders() });
-        this._store.add(_chatProviderService.onDidChangeProviders(this._proxy.$updateLanguageModels, this._proxy));
+        this._proxy.$updateLanguageModels({ added: coalesce(( _chatProviderService.getLanguageModelIds().map(id => _chatProviderService.lookupLanguageModel(id)))) });
+        this._store.add(_chatProviderService.onDidChangeLanguageModels(this._proxy.$updateLanguageModels, this._proxy));
     }
     dispose() {
         this._providerRegistrations.dispose();
         this._store.dispose();
     }
-    $registerProvider(handle, identifier, metadata) {
+    $registerLanguageModelProvider(handle, identifier, metadata) {
         const dipsosables = ( new DisposableStore());
-        dipsosables.add(this._chatProviderService.registerChatResponseProvider(identifier, {
+        dipsosables.add(this._chatProviderService.registerLanguageModelChat(identifier, {
             metadata,
             provideChatResponse: async (messages, from, options, progress, token) => {
                 const requestId = (Math.random() * 1e6) | 0;
@@ -51,7 +54,7 @@ let MainThreadChatProvider = class MainThreadChatProvider {
         dipsosables.add(( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
             id: `lm-${identifier}`,
             label: ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadChatProvider',
+                'vs/workbench/api/browser/mainThreadLanguageModels',
                 'languageModels',
                 "Language Model ({0})",
                 `${identifier}`
@@ -70,20 +73,20 @@ let MainThreadChatProvider = class MainThreadChatProvider {
     }
     async $prepareChatAccess(extension, providerId, justification) {
         const activate = this._extensionService.activateByEvent(`onLanguageModelAccess:${providerId}`);
-        const metadata = this._chatProviderService.lookupChatResponseProvider(providerId);
+        const metadata = this._chatProviderService.lookupLanguageModel(providerId);
         if (metadata) {
             return metadata;
         }
         await Promise.race([
             activate,
-            Event.toPromise(Event.filter(this._chatProviderService.onDidChangeProviders, e => Boolean(e.added?.includes(providerId))))
+            Event.toPromise(Event.filter(this._chatProviderService.onDidChangeLanguageModels, e => Boolean(e.added?.some(value => value.identifier === providerId))))
         ]);
-        return this._chatProviderService.lookupChatResponseProvider(providerId);
+        return this._chatProviderService.lookupLanguageModel(providerId);
     }
     async $fetchResponse(extension, providerId, requestId, messages, options, token) {
         await this._extensionFeaturesManagementService.getAccess(extension, `lm-${providerId}`);
         this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
-        const task = this._chatProviderService.fetchChatResponse(providerId, extension, messages, options, ( new Progress(value => {
+        const task = this._chatProviderService.makeLanguageModelChatRequest(providerId, extension, messages, options, ( new Progress(value => {
             this._proxy.$handleResponseFragment(requestId, value);
         })), token);
         task.catch(err => {
@@ -100,7 +103,7 @@ let MainThreadChatProvider = class MainThreadChatProvider {
             return Disposable.None;
         }
         const accountLabel = auth.accountLabel ?? ( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadChatProvider',
+            'vs/workbench/api/browser/mainThreadLanguageModels',
             'languageModelsAccountId',
             'Language Models'
         ));
@@ -109,28 +112,8 @@ let MainThreadChatProvider = class MainThreadChatProvider {
         disposables.add(toDisposable(() => {
             this._authenticationService.unregisterAuthenticationProvider(authProviderId);
         }));
-        disposables.add(this._authenticationService.onDidChangeSessions(async (e) => {
-            if (e.providerId === authProviderId) {
-                if (e.event.removed?.length) {
-                    const allowedExtensions = this._authenticationService.readAllowedExtensions(authProviderId, accountLabel);
-                    const extensionsToUpdateAccess = [];
-                    for (const allowed of allowedExtensions) {
-                        const from = await this._extensionService.getExtension(allowed.id);
-                        this._authenticationService.updateAllowedExtension(authProviderId, authProviderId, allowed.id, allowed.name, false);
-                        if (from) {
-                            extensionsToUpdateAccess.push({
-                                from: from.identifier,
-                                to: extension,
-                                enabled: false
-                            });
-                        }
-                    }
-                    this._proxy.$updateModelAccesslist(extensionsToUpdateAccess);
-                }
-            }
-        }));
-        disposables.add(this._authenticationService.onDidChangeExtensionSessionAccess(async (e) => {
-            const allowedExtensions = this._authenticationService.readAllowedExtensions(authProviderId, accountLabel);
+        disposables.add(this._authenticationAccessService.onDidChangeExtensionSessionAccess(async (e) => {
+            const allowedExtensions = this._authenticationAccessService.readAllowedExtensions(authProviderId, accountLabel);
             const accessList = [];
             for (const allowedExtension of allowedExtensions) {
                 const from = await this._extensionService.getExtension(allowedExtension.id);
@@ -147,14 +130,15 @@ let MainThreadChatProvider = class MainThreadChatProvider {
         return disposables;
     }
 };
-MainThreadChatProvider = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatProvider),
-    ( __param(1, IChatProviderService)),
+MainThreadLanguageModels = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLanguageModels),
+    ( __param(1, ILanguageModelsService)),
     ( __param(2, IExtensionFeaturesManagementService)),
     ( __param(3, ILogService)),
     ( __param(4, IAuthenticationService)),
-    ( __param(5, IExtensionService))
-], MainThreadChatProvider);
+    ( __param(5, IAuthenticationAccessService)),
+    ( __param(6, IExtensionService))
+], MainThreadLanguageModels);
 class LanguageModelAccessAuthProvider {
     constructor(id, label, _accountLabel) {
         this.id = id;
@@ -198,4 +182,4 @@ class LanguageModelAccessAuthProvider {
     }
 }
 
-export { MainThreadChatProvider };
+export { MainThreadLanguageModels };

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
@@ -19,7 +19,7 @@ let MainThreadQuickDiff = class MainThreadQuickDiff {
             selector,
             isSCM: false,
             getOriginalResource: async (uri) => {
-                return URI.revive(await this.proxy.$provideOriginalResource(handle, uri, ( new CancellationTokenSource()).token));
+                return URI.revive(await this.proxy.$provideOriginalResource(handle, uri, CancellationToken.None));
             }
         };
         const disposable = this.quickDiffService.addQuickDiffProvider(provider);

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';

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

@@ -8,11 +8,14 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { revive } from 'vscode/vscode/vs/base/common/marshalling';
+import { SearchContext } from 'vscode/vscode/vs/workbench/contrib/search/common/constants';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 
 let MainThreadSearch = class MainThreadSearch {
-    constructor(extHostContext, _searchService, _telemetryService, _configurationService) {
+    constructor(extHostContext, _searchService, _telemetryService, _configurationService, contextKeyService) {
         this._searchService = _searchService;
         this._telemetryService = _telemetryService;
+        this.contextKeyService = contextKeyService;
         this._searchProvider = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSearch));
         this._proxy.$enableExtensionHostSearch();
@@ -30,6 +33,16 @@ let MainThreadSearch = class MainThreadSearch {
             this._proxy
         )));
     }
+    $registerAITextSearchProvider(handle, scheme) {
+        SearchContext.hasAIResultProvider.bindTo(this.contextKeyService).set(true);
+        this._searchProvider.set(handle, ( new RemoteSearchProvider(
+            this._searchService,
+            2 ,
+            scheme,
+            handle,
+            this._proxy
+        )));
+    }
     $registerFileSearchProvider(handle, scheme) {
         this._searchProvider.set(handle, ( new RemoteSearchProvider(
             this._searchService,
@@ -65,7 +78,8 @@ MainThreadSearch = __decorate([
     extHostNamedCustomer(MainContext.MainThreadSearch),
     ( __param(1, ISearchService)),
     ( __param(2, ITelemetryService)),
-    ( __param(3, IConfigurationService))
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService))
 ], MainThreadSearch);
 class SearchOperation {
     static { this._idPool = 0; }
@@ -111,9 +125,7 @@ class RemoteSearchProvider {
         }
         const search = ( new SearchOperation(onProgress));
         this._searches.set(search.id, search);
-        const searchP = query.type === 1
-            ? this._proxy.$provideFileSearchResults(this._handle, search.id, query, token)
-            : this._proxy.$provideTextSearchResults(this._handle, search.id, query, token);
+        const searchP = this._provideSearchResults(query, search.id, token);
         return Promise.resolve(searchP).then((result) => {
             this._searches.delete(search.id);
             return { results: Array.from(( search.matches.values())), stats: result.stats, limitHit: result.limitHit, messages: result.messages };
@@ -141,6 +153,16 @@ class RemoteSearchProvider {
             }
         });
     }
+    _provideSearchResults(query, session, token) {
+        switch (query.type) {
+            case 1 :
+                return this._proxy.$provideFileSearchResults(this._handle, session, query, token);
+            case 2 :
+                return this._proxy.$provideTextSearchResults(this._handle, session, query, token);
+            default:
+                return this._proxy.$provideAITextSearchResults(this._handle, session, query, token);
+        }
+    }
 }
 
 export { MainThreadSearch };

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
@@ -20,7 +20,7 @@ let MainThreadShare = class MainThreadShare {
             selector,
             priority,
             provideShare: async (item) => {
-                const result = await this.proxy.$provideShare(handle, item, ( new CancellationTokenSource()).token);
+                const result = await this.proxy.$provideShare(handle, item, CancellationToken.None);
                 return typeof result === 'string' ? result : URI.revive(result);
             }
         };

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

@@ -114,6 +114,7 @@ let MainThreadTerminalService = class MainThreadTerminalService {
                 ? (id, cols, rows) => ( new TerminalProcessExtHostProxy(id, cols, rows, this._terminalService))
                 : undefined,
             extHostTerminalId,
+            forceShellIntegration: launchConfig.forceShellIntegration,
             isFeatureTerminal: launchConfig.isFeatureTerminal,
             isExtensionOwnedTerminal: launchConfig.isExtensionOwnedTerminal,
             useShellEnvironment: launchConfig.useShellEnvironment,

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

@@ -0,0 +1,51 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ITerminalService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegration extends Disposable {
+    constructor(extHostContext, _terminalService, workbenchEnvironmentService) {
+        super();
+        this._terminalService = _terminalService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTerminalShellIntegration));
+        const onDidAddCommandDetection = this._terminalService.createOnInstanceEvent(instance => {
+            return ( Event.map(Event.filter(instance.capabilities.onDidAddCapabilityType, e => {
+                return e === 2 ;
+            }, this._store), () => instance));
+        });
+        this._store.add(onDidAddCommandDetection(e => this._proxy.$shellIntegrationChange(e.instanceId)));
+        const commandDetectionStartEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(2 , e => e.onCommandExecuted));
+        let currentCommand;
+        this._store.add(commandDetectionStartEvent.event(e => {
+            if (e.data === currentCommand) {
+                return;
+            }
+            currentCommand = e.data;
+            this._proxy.$shellExecutionStart(e.instance.instanceId, e.data.command, e.data.cwd);
+        }));
+        const commandDetectionEndEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(2 , e => e.onCommandFinished));
+        this._store.add(commandDetectionEndEvent.event(e => {
+            currentCommand = undefined;
+            this._proxy.$shellExecutionEnd(e.instance.instanceId, e.data.command, e.data.exitCode);
+        }));
+        const cwdChangeEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(0 , e => e.onDidChangeCwd));
+        this._store.add(cwdChangeEvent.event(e => this._proxy.$cwdChange(e.instance.instanceId, e.data)));
+        this._store.add(this._terminalService.onDidDisposeInstance(e => this._proxy.$closeTerminal(e.instanceId)));
+        if (!workbenchEnvironmentService.remoteAuthority) {
+            this._store.add(this._terminalService.onAnyInstanceData(e => this._proxy.$shellExecutionData(e.instance.instanceId, e.data)));
+        }
+    }
+    $executeCommand(terminalId, commandLine) {
+        this._terminalService.getInstanceFromId(terminalId)?.runCommand(commandLine, true);
+    }
+};
+MainThreadTerminalShellIntegration = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTerminalShellIntegration),
+    ( __param(1, ITerminalService)),
+    ( __param(2, IWorkbenchEnvironmentService))
+], MainThreadTerminalShellIntegration);
+
+export { MainThreadTerminalShellIntegration };

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

@@ -1,6 +1,11 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable, MutableDisposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { transaction } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/observableInternal/derived';
+import 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import 'vscode/vscode/vs/base/common/cancellation';
 import { WellDefinedPrefixTree } from 'vscode/vscode/vs/base/common/prefixTree';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
@@ -12,7 +17,7 @@ import { ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/
 import { LiveTestResult } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResult';
 import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
 import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
-import { ITestItem, ITestMessage, TestsDiffOp, IFileCoverage, CoverageDetails } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
+import { ITestItem, IFileCoverage, CoverageDetails, ITestMessage, TestsDiffOp } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 
@@ -31,16 +36,27 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         }));
         this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => {
             const obj = {};
-            for (const { controller, profiles } of this.testProfiles.all()) {
-                obj[controller.id] = ( profiles.filter(p => p.isDefault).map(p => p.profileId));
+            for (const group of [2 , 4 , 8 ]) {
+                for (const profile of this.testProfiles.getGroupDefaultProfiles(group)) {
+                    obj[profile.controllerId] ??= [];
+                    obj[profile.controllerId].push(profile.profileId);
+                }
             }
             this.proxy.$setDefaultRunProfiles(obj);
         }));
         this._register(resultService.onResultsChanged(evt => {
-            const results = 'completed' in evt ? evt.completed : ('inserted' in evt ? evt.inserted : undefined);
-            const serialized = results?.toJSONWithMessages();
-            if (serialized) {
-                this.proxy.$publishTestResults([serialized]);
+            if ('completed' in evt) {
+                const serialized = evt.completed.toJSONWithMessages();
+                if (serialized) {
+                    this.proxy.$publishTestResults([serialized]);
+                }
+            }
+            else if ('removed' in evt) {
+                evt.removed.forEach(r => {
+                    if (r instanceof LiveTestResult) {
+                        this.proxy.$disposeRun(r.id);
+                    }
+                });
             }
         }));
     }
@@ -73,19 +89,27 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
     $addTestsToRun(controllerId, runId, tests) {
         this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(t => ITestItem.deserialize(this.uriIdentityService, t)))));
     }
-    $signalCoverageAvailable(runId, taskId, available) {
+    $appendCoverage(runId, taskId, coverage) {
         this.withLiveRun(runId, run => {
             const task = run.tasks.find(t => t.id === taskId);
             if (!task) {
                 return;
             }
-            const fn = available ? ((token) => TestCoverage.load(taskId, {
-                provideFileCoverage: async (token) => await this.proxy.$provideFileCoverage(runId, taskId, token)
-                    .then(c => ( c.map(u => IFileCoverage.deserialize(this.uriIdentityService, u)))),
-                resolveFileCoverage: (i, token) => this.proxy.$resolveFileCoverage(runId, taskId, i, token)
-                    .then(d => ( d.map(CoverageDetails.deserialize))),
-            }, this.uriIdentityService, token)) : undefined;
-            task.coverage.set(fn, undefined);
+            const deserialized = IFileCoverage.deserialize(this.uriIdentityService, coverage);
+            transaction(tx => {
+                let value = task.coverage.read(undefined);
+                if (!value) {
+                    value = ( new TestCoverage(taskId, this.uriIdentityService, {
+                        getCoverageDetails: (id, token) => this.proxy.$getCoverageDetails(id, token)
+                            .then(r => ( r.map(CoverageDetails.deserialize))),
+                    }));
+                    value.append(deserialized, tx);
+                    task.coverage.set(value, tx);
+                }
+                else {
+                    value.append(deserialized, tx);
+                }
+            });
         });
     }
     $startedExtensionTestRun(req) {

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -50,6 +50,9 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
     get backupId() {
         return undefined;
     }
+    get canHotExit() {
+        return true;
+    }
     isDirty() {
         return this.textFileService.isDirty(this.resource);
     }

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

@@ -23,6 +23,7 @@ import { extensionRunningPreferenceToString, extensionHostKindToString } from 'v
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
 import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
 import { toExtensionDescription, ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import '../common/extensionsProposedApi.js';
 import { dedupExtensions } from '../common/extensionsUtil.js';
 import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';

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

@@ -128,10 +128,18 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(added, removed)));
             }
         }));
+        this._register(this._extensionManagementService.onDidEnableExtensions(extensions => {
+            if (extensions.length) {
+                if (isCI) {
+                    this._logService.info(`AbstractExtensionService.onDidEnableExtensions fired`);
+                }
+                this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(extensions, [])));
+            }
+        }));
         this._register(this._extensionManagementService.onDidInstallExtensions((result) => {
             const extensions = [];
             for (const { local, operation } of result) {
-                if (local && operation !== 4  && this._safeInvokeIsEnabled(local)) {
+                if (local && local.isValid && operation !== 4  && this._safeInvokeIsEnabled(local)) {
                     extensions.push(local);
                 }
             }
@@ -739,8 +747,11 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. No extensions were activated.`);
         }
     }
-    async startExtensionHosts() {
+    async startExtensionHosts(updates) {
         this._doStopExtensionHosts();
+        if (updates) {
+            await this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(updates.toAdd, updates.toRemove)));
+        }
         const lock = await this._registry.acquireLock('startExtensionHosts');
         try {
             this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));