@codingame/monaco-vscode-extensions-service-override 1.83.16 → 1.85.0-next.0

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

@@ -1,44 +1,74 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore, dispose, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableMap, DisposableStore, dispose, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { Sequence } from 'monaco-editor/esm/vs/base/common/sequence.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { ResourceTree } from 'vscode/vscode/vs/base/common/resourceTree';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
 
-function getSCMHistoryItemIcon(historyItem) {
-    if (!historyItem.icon) {
+function getSCMInputBoxActionButtonIcon(actionButton) {
+    if (!actionButton.icon) {
         return undefined;
     }
-    else if (URI.isUri(historyItem.icon)) {
-        return URI.revive(historyItem.icon);
+    else if (URI.isUri(actionButton.icon)) {
+        return URI.revive(actionButton.icon);
     }
-    else if (ThemeIcon.isThemeIcon(historyItem.icon)) {
-        return historyItem.icon;
+    else if (ThemeIcon.isThemeIcon(actionButton.icon)) {
+        return actionButton.icon;
     }
     else {
-        const icon = historyItem.icon;
+        const icon = actionButton.icon;
+        return { light: URI.revive(icon.light), dark: URI.revive(icon.dark) };
+    }
+}
+function getIconFromIconDto(iconDto) {
+    if (iconDto === undefined) {
+        return undefined;
+    }
+    else if (URI.isUri(iconDto)) {
+        return URI.revive(iconDto);
+    }
+    else if (ThemeIcon.isThemeIcon(iconDto)) {
+        return iconDto;
+    }
+    else {
+        const icon = iconDto;
         return { light: URI.revive(icon.light), dark: URI.revive(icon.dark) };
     }
 }
 class MainThreadSCMResourceGroup {
+    get resourceTree() {
+        if (!this._resourceTree) {
+            const rootUri = this.provider.rootUri ?? URI.file('/');
+            this._resourceTree = ( new ResourceTree(this, rootUri, this._uriIdentService.extUri));
+            for (const resource of this.resources) {
+                this._resourceTree.add(resource.sourceUri, resource);
+            }
+        }
+        return this._resourceTree;
+    }
     get hideWhenEmpty() { return !!this.features.hideWhenEmpty; }
-    constructor(sourceControlHandle, handle, provider, features, label, id) {
+    constructor(sourceControlHandle, handle, provider, features, label, id, _uriIdentService) {
         this.sourceControlHandle = sourceControlHandle;
         this.handle = handle;
         this.provider = provider;
         this.features = features;
         this.label = label;
         this.id = id;
-        this.elements = [];
-        this._onDidSplice = ( new Emitter());
-        this.onDidSplice = this._onDidSplice.event;
+        this._uriIdentService = _uriIdentService;
+        this.resources = [];
         this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
+        this._onDidChangeResources = ( new Emitter());
+        this.onDidChangeResources = this._onDidChangeResources.event;
     }
     toJSON() {
         return {
@@ -48,8 +78,9 @@ class MainThreadSCMResourceGroup {
         };
     }
     splice(start, deleteCount, toInsert) {
-        this.elements.splice(start, deleteCount, ...toInsert);
-        this._onDidSplice.fire({ start, deleteCount, toInsert });
+        this.resources.splice(start, deleteCount, ...toInsert);
+        this._resourceTree = undefined;
+        this._onDidChangeResources.fire();
     }
     $updateGroup(features) {
         this.features = { ...this.features, ...features };
@@ -103,6 +134,29 @@ class MainThreadSCMHistoryProvider {
         this._onDidChangeCurrentHistoryItemGroup = ( new Emitter());
         this.onDidChangeCurrentHistoryItemGroup = this._onDidChangeCurrentHistoryItemGroup.event;
     }
+    async resolveHistoryItemGroupDetails(historyItemGroup) {
+        const historyItemGroupBase = await this.resolveHistoryItemGroupBase(historyItemGroup.id);
+        const ancestor = historyItemGroupBase ?
+            await this.resolveHistoryItemGroupCommonAncestor(historyItemGroup.id, historyItemGroupBase.id) : undefined;
+        let incoming;
+        if (historyItemGroupBase) {
+            incoming = {
+                id: historyItemGroupBase.id,
+                label: historyItemGroupBase.label,
+                icon: Codicon.arrowCircleDown,
+                ancestor: ancestor?.id,
+                count: ancestor?.behind ?? 0,
+            };
+        }
+        const outgoing = {
+            id: historyItemGroup.id,
+            label: historyItemGroup.label,
+            icon: Codicon.arrowCircleUp,
+            ancestor: ancestor?.id,
+            count: ancestor?.ahead ?? 0,
+        };
+        return { incoming, outgoing };
+    }
     async resolveHistoryItemGroupBase(historyItemGroupId) {
         return this.proxy.$resolveHistoryItemGroupBase(this.handle, historyItemGroupId, CancellationToken.None);
     }
@@ -111,7 +165,7 @@ class MainThreadSCMHistoryProvider {
     }
     async provideHistoryItems(historyItemGroupId, options) {
         const historyItems = await this.proxy.$provideHistoryItems(this.handle, historyItemGroupId, options, CancellationToken.None);
-        return historyItems?.map(historyItem => ({ ...historyItem, icon: getSCMHistoryItemIcon(historyItem), }));
+        return historyItems?.map(historyItem => ({ ...historyItem, icon: getIconFromIconDto(historyItem.icon) }));
     }
     async provideHistoryItemChanges(historyItemId) {
         const changes = await this.proxy.$provideHistoryItemChanges(this.handle, historyItemId, CancellationToken.None);
@@ -130,27 +184,32 @@ class MainThreadSCMProvider {
     get label() { return this._label; }
     get rootUri() { return this._rootUri; }
     get inputBoxDocumentUri() { return this._inputBoxDocumentUri; }
-    get contextValue() { return this._contextValue; }
+    get contextValue() { return this._providerId; }
     get commitTemplate() { return this.features.commitTemplate || ''; }
     get historyProvider() { return this._historyProvider; }
     get acceptInputCommand() { return this.features.acceptInputCommand; }
     get actionButton() { return this.features.actionButton ?? undefined; }
     get statusBarCommands() { return this.features.statusBarCommands; }
     get count() { return this.features.count; }
+    get name() { return this._name ?? this._label; }
     get onDidChangeStatusBarCommands() { return this._onDidChangeStatusBarCommands.event; }
-    constructor(proxy, _handle, _contextValue, _label, _rootUri, _inputBoxDocumentUri, _quickDiffService) {
+    constructor(proxy, _handle, _providerId, _label, _rootUri, _inputBoxDocumentUri, _quickDiffService, _uriIdentService, _workspaceContextService) {
         this.proxy = proxy;
         this._handle = _handle;
-        this._contextValue = _contextValue;
+        this._providerId = _providerId;
         this._label = _label;
         this._rootUri = _rootUri;
         this._inputBoxDocumentUri = _inputBoxDocumentUri;
         this._quickDiffService = _quickDiffService;
+        this._uriIdentService = _uriIdentService;
+        this._workspaceContextService = _workspaceContextService;
         this._id = `scm${MainThreadSCMProvider.ID_HANDLE++}`;
-        this.groups = ( new Sequence());
-        this._groupsByHandle = Object.create(null);
+        this.groups = [];
+        this._onDidChangeResourceGroups = ( new Emitter());
+        this.onDidChangeResourceGroups = this._onDidChangeResourceGroups.event;
         this._onDidChangeResources = ( new Emitter());
         this.onDidChangeResources = this._onDidChangeResources.event;
+        this._groupsByHandle = Object.create(null);
         this.features = {};
         this._onDidChangeCommitTemplate = ( new Emitter());
         this.onDidChangeCommitTemplate = this._onDidChangeCommitTemplate.event;
@@ -160,6 +219,15 @@ class MainThreadSCMProvider {
         this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
         this.isSCM = true;
+        if (_rootUri) {
+            const folder = this._workspaceContextService.getWorkspaceFolder(_rootUri);
+            if (folder?.uri.toString() === ( _rootUri.toString())) {
+                this._name = folder.name;
+            }
+            else if (_rootUri.path !== '/') {
+                this._name = basename(_rootUri);
+            }
+        }
     }
     $updateSourceControl(features) {
         this.features = { ...this.features, ...features };
@@ -193,11 +261,12 @@ class MainThreadSCMProvider {
     }
     $registerGroups(_groups) {
         const groups = ( _groups.map(([handle, id, label, features]) => {
-            const group = ( new MainThreadSCMResourceGroup(this.handle, handle, this, features, label, id));
+            const group = ( new MainThreadSCMResourceGroup(this.handle, handle, this, features, label, id, this._uriIdentService));
             this._groupsByHandle[handle] = group;
             return group;
         }));
-        this.groups.splice(this.groups.elements.length, 0, groups);
+        this.groups.splice(this.groups.length, 0, ...groups);
+        this._onDidChangeResourceGroups.fire();
     }
     $updateGroup(handle, features) {
         const group = this._groupsByHandle[handle];
@@ -257,8 +326,8 @@ class MainThreadSCMProvider {
             return;
         }
         delete this._groupsByHandle[handle];
-        this.groups.splice(this.groups.elements.indexOf(group), 1);
-        this._onDidChangeResources.fire();
+        this.groups.splice(this.groups.indexOf(group), 1);
+        this._onDidChangeResourceGroups.fire();
     }
     async getOriginalResource(uri) {
         if (!this.features.hasQuickDiffProvider) {
@@ -289,13 +358,27 @@ class MainThreadSCMProvider {
         this._quickDiff?.dispose();
     }
 }
+class MainThreadSCMInputBoxValueProvider {
+    constructor(proxy, handle, label, icon) {
+        this.proxy = proxy;
+        this.handle = handle;
+        this.label = label;
+        this.icon = icon;
+    }
+    provideValue(rootUri, context, token) {
+        return this.proxy.$provideInputBoxValue(this.handle, rootUri, context, token);
+    }
+}
 let MainThreadSCM = class MainThreadSCM {
-    constructor(extHostContext, scmService, scmViewService, quickDiffService) {
+    constructor(extHostContext, scmService, scmViewService, quickDiffService, _uriIdentService, workspaceContextService) {
         this.scmService = scmService;
         this.scmViewService = scmViewService;
         this.quickDiffService = quickDiffService;
+        this._uriIdentService = _uriIdentService;
+        this.workspaceContextService = workspaceContextService;
         this._repositories = ( new Map());
         this._repositoryDisposables = ( new Map());
+        this._inputBoxValueProviders = ( new DisposableMap());
         this._disposables = ( new DisposableStore());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSCM));
     }
@@ -304,6 +387,7 @@ let MainThreadSCM = class MainThreadSCM {
         this._repositories.clear();
         dispose(( this._repositoryDisposables.values()));
         this._repositoryDisposables.clear();
+        this._inputBoxValueProviders.dispose();
         this._disposables.dispose();
     }
     $registerSourceControl(handle, id, label, rootUri, inputBoxDocumentUri) {
@@ -314,7 +398,9 @@ let MainThreadSCM = class MainThreadSCM {
             label,
             rootUri ? URI.revive(rootUri) : undefined,
             URI.revive(inputBoxDocumentUri),
-            this.quickDiffService
+            this.quickDiffService,
+            this._uriIdentService,
+            this.workspaceContextService
         ));
         const repository = this.scmService.registerSCMProvider(provider);
         this._repositories.set(handle, repository);
@@ -345,6 +431,19 @@ let MainThreadSCM = class MainThreadSCM {
         repository.dispose();
         this._repositories.delete(handle);
     }
+    $registerSourceControlInputBoxValueProvider(handle, sourceControlId, label, icon) {
+        const provider = ( new MainThreadSCMInputBoxValueProvider(this._proxy, handle, label, getIconFromIconDto(icon)));
+        const disposable = this.scmService.registerSCMInputValueProvider(sourceControlId, provider);
+        this._inputBoxValueProviders.set(handle, disposable);
+    }
+    $unregisterSourceControlInputBoxValueProvider(handle) {
+        const provider = this._inputBoxValueProviders.get(handle);
+        if (!provider) {
+            return;
+        }
+        provider.dispose();
+        this._inputBoxValueProviders.deleteAndDispose(handle);
+    }
     $registerGroups(sourceControlHandle, groups, splices) {
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
@@ -414,6 +513,13 @@ let MainThreadSCM = class MainThreadSCM {
         }
         repository.input.visible = visible;
     }
+    $setInputBoxActionButton(sourceControlHandle, actionButton) {
+        const repository = this._repositories.get(sourceControlHandle);
+        if (!repository) {
+            return;
+        }
+        repository.input.actionButton = actionButton ? { ...actionButton, icon: getSCMInputBoxActionButtonIcon(actionButton) } : undefined;
+    }
     $showValidationMessage(sourceControlHandle, message, type) {
         const repository = this._repositories.get(sourceControlHandle);
         if (!repository) {
@@ -457,7 +563,9 @@ MainThreadSCM = __decorate([
     extHostNamedCustomer(MainContext.MainThreadSCM),
     ( __param(1, ISCMService)),
     ( __param(2, ISCMViewService)),
-    ( __param(3, IQuickDiffService))
+    ( __param(3, IQuickDiffService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, IWorkspaceContextService))
 ], MainThreadSCM);
 
 export { MainThreadSCM };

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

@@ -7,6 +7,7 @@ import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/commo
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 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 'monaco-editor/esm/vs/base/common/marshalling.js';
 
 let MainThreadSearch = class MainThreadSearch {
     constructor(extHostContext, _searchService, _telemetryService, _configurationService) {
@@ -131,10 +132,7 @@ class RemoteSearchProvider {
         }
         dataOrUri.forEach(result => {
             if (result.results) {
-                searchOp.addMatch({
-                    resource: URI.revive(result.resource),
-                    results: result.results
-                });
+                searchOp.addMatch(revive(result));
             }
             else {
                 searchOp.addMatch({

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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadSpeech = class MainThreadSpeech extends Disposable {
+    constructor(extHostContext, speechService, logService) {
+        super();
+        this.speechService = speechService;
+        this.logService = logService;
+        this.providerRegistrations = ( new Map());
+        this.providerSessions = ( new Map());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSpeech));
+    }
+    $registerProvider(handle, identifier, metadata) {
+        this.logService.trace('[Speech] extension registered provider', metadata.extension.value);
+        const registration = this.speechService.registerSpeechProvider(identifier, {
+            metadata,
+            createSpeechToTextSession: token => {
+                const disposables = ( new DisposableStore());
+                const cts = ( new CancellationTokenSource(token));
+                const session = Math.random();
+                this.proxy.$createSpeechToTextSession(handle, session);
+                disposables.add(token.onCancellationRequested(() => this.proxy.$cancelSpeechToTextSession(session)));
+                const onDidChange = disposables.add(( new Emitter()));
+                this.providerSessions.set(session, { onDidChange });
+                return {
+                    onDidChange: onDidChange.event,
+                    dispose: () => {
+                        cts.dispose(true);
+                        this.providerSessions.delete(session);
+                        disposables.dispose();
+                    }
+                };
+            }
+        });
+        this.providerRegistrations.set(handle, {
+            dispose: () => {
+                registration.dispose();
+            }
+        });
+    }
+    $unregisterProvider(handle) {
+        const registration = this.providerRegistrations.get(handle);
+        if (registration) {
+            registration.dispose();
+            this.providerRegistrations.delete(handle);
+        }
+    }
+    $emitSpeechToTextEvent(session, event) {
+        const providerSession = this.providerSessions.get(session);
+        if (providerSession) {
+            providerSession.onDidChange.fire(event);
+        }
+    }
+};
+MainThreadSpeech = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadSpeech),
+    ( __param(1, ISpeechService)),
+    ( __param(2, ILogService))
+], MainThreadSpeech);
+
+export { MainThreadSpeech };

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

@@ -45,14 +45,14 @@ let MainThreadTerminalService = class MainThreadTerminalService {
             this._onInstanceDimensionsChanged(instance);
         }));
         this._store.add(_terminalService.onDidDisposeInstance(instance => this._onTerminalDisposed(instance)));
-        this._store.add(_terminalService.onDidReceiveProcessId(instance => this._onTerminalProcessIdReady(instance)));
+        this._store.add(_terminalService.onAnyInstanceProcessIdReady(instance => this._onTerminalProcessIdReady(instance)));
         this._store.add(_terminalService.onDidChangeInstanceDimensions(instance => this._onInstanceDimensionsChanged(instance)));
-        this._store.add(_terminalService.onDidMaximumDimensionsChange(instance => this._onInstanceMaximumDimensionsChanged(instance)));
+        this._store.add(_terminalService.onAnyInstanceMaximumDimensionsChange(instance => this._onInstanceMaximumDimensionsChanged(instance)));
         this._store.add(_terminalService.onDidRequestStartExtensionTerminal(e => this._onRequestStartExtensionTerminal(e)));
         this._store.add(_terminalService.onDidChangeActiveInstance(instance => this._onActiveTerminalChanged(instance ? instance.instanceId : null)));
-        this._store.add(_terminalService.onDidChangeInstanceTitle(instance => instance && this._onTitleChanged(instance.instanceId, instance.title)));
-        this._store.add(_terminalService.onDidInputInstanceData(instance => this._proxy.$acceptTerminalInteraction(instance.instanceId)));
-        this._store.add(_terminalService.onDidChangeSelection(instance => this._proxy.$acceptTerminalSelection(instance.instanceId, instance.selection)));
+        this._store.add(_terminalService.onAnyInstanceTitleChange(instance => instance && this._onTitleChanged(instance.instanceId, instance.title)));
+        this._store.add(_terminalService.onAnyInstanceDataInput(instance => this._proxy.$acceptTerminalInteraction(instance.instanceId)));
+        this._store.add(_terminalService.onAnyInstanceSelectionChange(instance => this._proxy.$acceptTerminalSelection(instance.instanceId, instance.selection)));
         for (const instance of this._terminalService.instances) {
             this._onTerminalOpened(instance);
             instance.processReady.then(() => this._onTerminalProcessIdReady(instance));
@@ -161,9 +161,9 @@ let MainThreadTerminalService = class MainThreadTerminalService {
     async $dispose(id) {
         (await this._getTerminalInstance(id))?.dispose(TerminalExitReason.Extension);
     }
-    async $sendText(id, text, addNewLine) {
+    async $sendText(id, text, shouldExecute) {
         const instance = await this._getTerminalInstance(id);
-        await instance?.sendText(text, addNewLine);
+        await instance?.sendText(text, shouldExecute);
     }
     $sendProcessExit(terminalId, exitCode) {
         this._terminalProcessProxies.get(terminalId)?.emitExit(exitCode);
@@ -184,11 +184,10 @@ let MainThreadTerminalService = class MainThreadTerminalService {
         this._dataEventTracker.clear();
     }
     $startSendingCommandEvents() {
-        this._logService.info('$startSendingCommandEvents');
         if (this._sendCommandEventListener.value) {
             return;
         }
-        const multiplexer = this._terminalService.onInstanceCapabilityEvent(2 , capability => capability.onCommandFinished);
+        const multiplexer = this._terminalService.createOnInstanceCapabilityEvent(2 , capability => capability.onCommandFinished);
         multiplexer.event(e => {
             this._onDidExecuteCommand(e.instance.instanceId, {
                 commandLine: e.data.command,
@@ -200,7 +199,6 @@ let MainThreadTerminalService = class MainThreadTerminalService {
         this._sendCommandEventListener.value = multiplexer;
     }
     $stopSendingCommandEvents() {
-        this._logService.info('$stopSendingCommandEvents');
         this._sendCommandEventListener.clear();
     }
     $startLinkProvider() {

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

@@ -1,19 +1,19 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, MutableDisposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { WellDefinedPrefixTree } from 'vscode/vscode/vs/base/common/prefixTree';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { MutableObservableValue } from 'vscode/vscode/vs/workbench/contrib/testing/common/observableValue';
-import { ITestItem, ITestMessage, TestsDiffOp } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
-import { TestCoverage } from '../../contrib/testing/common/testCoverage.js';
+import { TestCoverage } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverage';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
 import { ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
 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 { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { WellDefinedPrefixTree } from 'vscode/vscode/vs/base/common/prefixTree';
-import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
 
 let MainThreadTesting = class MainThreadTesting extends Disposable {
     constructor(extHostContext, testService, testProfiles, resultService) {
@@ -27,6 +27,18 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         this._register(this.testService.onDidCancelTestRun(({ runId }) => {
             this.proxy.$cancelExtensionTestRun(runId);
         }));
+        this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => {
+            const defaults = ( new Set([
+                ...testProfiles.getGroupDefaultProfiles(2 ),
+                ...testProfiles.getGroupDefaultProfiles(4 ),
+                ...testProfiles.getGroupDefaultProfiles(8 ),
+            ]));
+            const obj = {};
+            for (const { controller, profiles } of this.testProfiles.all()) {
+                obj[controller.id] = ( profiles.filter(p => ( defaults.has(p))).map(p => p.profileId));
+            }
+            this.proxy.$setActiveRunProfiles(obj);
+        }));
         this._register(resultService.onResultsChanged(evt => {
             const results = 'completed' in evt ? evt.completed : ('inserted' in evt ? evt.inserted : undefined);
             const serialized = results?.toJSONWithMessages();
@@ -64,16 +76,19 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
     $addTestsToRun(controllerId, runId, tests) {
         this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(ITestItem.deserialize))));
     }
-    $signalCoverageAvailable(runId, taskId) {
+    $signalCoverageAvailable(runId, taskId, available) {
         this.withLiveRun(runId, run => {
             const task = run.tasks.find(t => t.id === taskId);
             if (!task) {
                 return;
             }
-            task.coverage.value = ( new TestCoverage({
-                provideFileCoverage: async (token) => revive(await this.proxy.$provideFileCoverage(runId, taskId, token)),
-                resolveFileCoverage: (i, token) => this.proxy.$resolveFileCoverage(runId, taskId, i, token),
-            }));
+            const fn = available ? ((token) => TestCoverage.load(taskId, {
+                provideFileCoverage: async (token) => await this.proxy.$provideFileCoverage(runId, taskId, token)
+                    .then(c => ( c.map(IFileCoverage.deserialize))),
+                resolveFileCoverage: (i, token) => this.proxy.$resolveFileCoverage(runId, taskId, i, token)
+                    .then(d => ( d.map(CoverageDetails.deserialize))),
+            }, token)) : undefined;
+            task.coverage.set(fn, undefined);
         });
     }
     $startedExtensionTestRun(req) {

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableMap, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IViewsService, Extensions, NoTreeViewError, ResolvableTreeItem } from 'vscode/vscode/vs/workbench/common/views';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
@@ -20,7 +20,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         this.notificationService = notificationService;
         this.extensionService = extensionService;
         this.logService = logService;
-        this._dataProviders = ( new Map());
+        this._dataProviders = this._register(( new DisposableMap()));
         this._dndControllers = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTreeViews));
     }
@@ -29,8 +29,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         this.extensionService.whenInstalledExtensionsRegistered().then(() => {
             const dataProvider = ( new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService));
             const disposables = ( new DisposableStore());
-            this._register(disposables);
-            this._dataProviders.set(treeViewId, { dataProvider, disposables });
+            this._dataProviders.set(treeViewId, { dataProvider, dispose: () => disposables.dispose() });
             const dndController = (options.hasHandleDrag || options.hasHandleDrop)
                 ? ( new TreeViewDragAndDropController(
                 treeViewId,
@@ -112,11 +111,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         if (viewer) {
             viewer.dataProvider = undefined;
         }
-        const dataProvider = this._dataProviders.get(treeViewId);
-        if (dataProvider) {
-            dataProvider.disposables.dispose();
-            this._dataProviders.delete(treeViewId);
-        }
+        this._dataProviders.deleteAndDispose(treeViewId);
     }
     async reveal(treeView, dataProvider, itemIn, parentChain, options) {
         options = options ? options : { select: false, focus: false };
@@ -173,13 +168,13 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         return viewDescriptor ? viewDescriptor.treeView : null;
     }
     dispose() {
-        this._dataProviders.forEach((dataProvider, treeViewId) => {
-            const treeView = this.getTreeView(treeViewId);
+        for (const dataprovider of this._dataProviders) {
+            const treeView = this.getTreeView(dataprovider[0]);
             if (treeView) {
                 treeView.dataProvider = undefined;
             }
-        });
-        this._dataProviders.clear();
+        }
+        this._dataProviders.dispose();
         this._dndControllers.clear();
         super.dispose();
     }

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

@@ -42,7 +42,7 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
             this._proxy.$registerCandidateFinder(this.processFindingEnabled());
         }
         else {
-            this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING))));
+            this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.processFindingEnabled())));
         }
         this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
             if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING)) {

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

@@ -205,6 +205,9 @@ let MainThreadWorkspace = class MainThreadWorkspace {
     $resolveProxy(url) {
         return this._requestService.resolveProxy(url);
     }
+    $loadCertificates() {
+        return this._requestService.loadCertificates();
+    }
     $requestWorkspaceTrust(options) {
         return this._workspaceTrustRequestService.requestWorkspaceTrust(options);
     }

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatExecuteActions.js

@@ -0,0 +1,40 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CHAT_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { CONTEXT_CHAT_INPUT_HAS_TEXT, CONTEXT_CHAT_REQUEST_IN_PROGRESS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+
+class SubmitAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.submit'; }
+    constructor() {
+        super({
+            id: SubmitAction.ID,
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/chat/browser/actions/chatExecuteActions',
+                    'interactive.submit.label',
+                    "Submit"
+                )),
+                original: 'Submit'
+            },
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.send,
+            precondition: CONTEXT_CHAT_INPUT_HAS_TEXT,
+            menu: {
+                id: MenuId.ChatExecute,
+                when: ( CONTEXT_CHAT_REQUEST_IN_PROGRESS.negate()),
+                group: 'navigation',
+            },
+        });
+    }
+    run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        widget?.acceptInput(context?.inputValue);
+    }
+}
+
+export { SubmitAction };