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

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

@@ -20,6 +20,7 @@ import { isGroupEditorMoveEvent } from 'vscode/vscode/vs/workbench/common/editor
 import { InteractiveEditorInput } from '../../contrib/interactive/browser/interactiveEditorInput.js';
 import { MergeEditorInput } from '../../contrib/mergeEditor/browser/mergeEditorInput.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ChatEditorInput } from '../../contrib/chat/browser/chatEditorInput.js';
 
 let MainThreadEditorTabs = class MainThreadEditorTabs {
     constructor(extHostContext, _editorGroupsService, _configurationService, _logService, editorService) {
@@ -42,7 +43,7 @@ let MainThreadEditorTabs = class MainThreadEditorTabs {
         }));
         this._dispoables.add(this._editorGroupsService.onDidAddGroup(() => this._createTabsModel()));
         this._dispoables.add(this._editorGroupsService.onDidRemoveGroup(() => this._createTabsModel()));
-        this._editorGroupsService.whenReady.then(() => this._createTabsModel());
+        this._editorGroupsService.mainPart.whenReady.then(() => this._createTabsModel());
     }
     dispose() {
         this._groupLookup.clear();
@@ -143,6 +144,12 @@ let MainThreadEditorTabs = class MainThreadEditorTabs {
                 inputBoxUri: editor.inputResource
             };
         }
+        if (editor instanceof ChatEditorInput) {
+            return {
+                kind: 10 ,
+                providerId: editor.providerId ?? 'unknown',
+            };
+        }
         return { kind: 0  };
     }
     _generateTabId(editor, groupId) {
@@ -347,42 +354,42 @@ let MainThreadEditorTabs = class MainThreadEditorTabs {
                 else {
                     return;
                 }
-            case 7 :
+            case 8 :
                 if (event.editor !== undefined && event.editorIndex !== undefined) {
                     this._onDidTabLabelChange(groupId, event.editor, event.editorIndex);
                     break;
                 }
-            case 3 :
+            case 4 :
                 if (event.editor !== undefined && event.editorIndex !== undefined) {
                     this._onDidTabOpen(groupId, event.editor, event.editorIndex);
                     break;
                 }
-            case 4 :
+            case 5 :
                 if (event.editorIndex !== undefined) {
                     this._onDidTabClose(groupId, event.editorIndex);
                     break;
                 }
-            case 6 :
+            case 7 :
                 if (event.editorIndex !== undefined) {
                     this._onDidTabActiveChange(groupId, event.editorIndex);
                     break;
                 }
-            case 11 :
+            case 12 :
                 if (event.editorIndex !== undefined && event.editor !== undefined) {
                     this._onDidTabDirty(groupId, event.editorIndex, event.editor);
                     break;
                 }
-            case 10 :
+            case 11 :
                 if (event.editorIndex !== undefined && event.editor !== undefined) {
                     this._onDidTabPinChange(groupId, event.editorIndex, event.editor);
                     break;
                 }
-            case 9 :
+            case 10 :
                 if (event.editorIndex !== undefined && event.editor !== undefined) {
                     this._onDidTabPreviewChange(groupId, event.editorIndex, event.editor);
                     break;
                 }
-            case 5 :
+            case 6 :
                 if (isGroupEditorMoveEvent(event) && event.editor && event.editorIndex !== undefined && event.oldEditorIndex !== undefined) {
                     this._onDidTabMove(groupId, event.editorIndex, event.oldEditorIndex, event.editor);
                     break;

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

@@ -2,28 +2,17 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { DisposableMap, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { FilePermission, FileSystemProviderErrorCode, FileType, FileOperationError, toFileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IFileService, FilePermission, FileSystemProviderErrorCode, FileType, FileOperationError, toFileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IWorkbenchFileService } from 'vscode/vscode/vs/workbench/services/files/common/files';
-import { normalizeWatcherPattern } from '../../../platform/files/common/watcher.js';
-import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
-import { rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
 
 var MainThreadFileSystem_1;
 let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
-    constructor(extHostContext, _fileService, _contextService, _logService, _configurationService) {
+    constructor(extHostContext, _fileService) {
         this._fileService = _fileService;
-        this._contextService = _contextService;
-        this._logService = _logService;
-        this._configurationService = _configurationService;
         this._fileProvider = ( new DisposableMap());
         this._disposables = ( new DisposableStore());
-        this._watches = ( new DisposableMap());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystem));
         const infoProxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo));
         for (const entry of _fileService.listCapabilities()) {
@@ -35,7 +24,6 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
     dispose() {
         this._disposables.dispose();
         this._fileProvider.dispose();
-        this._watches.dispose();
     }
     async $registerFileSystemProvider(handle, scheme, capabilities, readonlyMessage) {
         this._fileProvider.set(handle, ( new RemoteFileSystemProvider(
@@ -141,70 +129,10 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
     $ensureActivation(scheme) {
         return this._fileService.activateProvider(scheme);
     }
-    async $watch(extensionId, session, resource, unvalidatedOpts) {
-        const uri = URI.revive(resource);
-        const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
-        const opts = { ...unvalidatedOpts };
-        if (opts.recursive) {
-            try {
-                const stat = await this._fileService.stat(uri);
-                if (!stat.isDirectory) {
-                    opts.recursive = false;
-                }
-            }
-            catch (error) {
-                this._logService.error(`MainThreadFileSystem#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
-            }
-        }
-        if (workspaceFolder && opts.recursive) {
-            this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-            return;
-        }
-        this._logService.trace(`MainThreadFileSystem#$watch(): request to start watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-        if (opts.recursive) {
-            const config = this._configurationService.getValue();
-            if (config.files?.watcherExclude) {
-                for (const key in config.files.watcherExclude) {
-                    if (config.files.watcherExclude[key] === true) {
-                        opts.excludes.push(key);
-                    }
-                }
-            }
-        }
-        else if (workspaceFolder) {
-            const config = this._configurationService.getValue();
-            if (config.files?.watcherExclude) {
-                for (const key in config.files.watcherExclude) {
-                    if (config.files.watcherExclude[key] === true) {
-                        if (!opts.includes) {
-                            opts.includes = [];
-                        }
-                        const includePattern = `${rtrim(key, '/')}/${GLOBSTAR}`;
-                        opts.includes.push(normalizeWatcherPattern(workspaceFolder.uri.fsPath, includePattern));
-                    }
-                }
-            }
-            if (!opts.includes || opts.includes.length === 0) {
-                this._logService.trace(`MainThreadFileSystem#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
-                return;
-            }
-        }
-        const subscription = this._fileService.watch(uri, opts);
-        this._watches.set(session, subscription);
-    }
-    $unwatch(session) {
-        if (( this._watches.has(session))) {
-            this._logService.trace(`MainThreadFileSystem#$unwatch(): request to stop watching (session: ${session})`);
-            this._watches.deleteAndDispose(session);
-        }
-    }
 };
 MainThreadFileSystem = MainThreadFileSystem_1 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadFileSystem),
-    ( __param(1, IWorkbenchFileService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IConfigurationService))
+    ( __param(1, IFileService))
 ], MainThreadFileSystem);
 class RemoteFileSystemProvider {
     constructor(fileService, scheme, capabilities, readOnlyMessage, _handle, _proxy) {

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

@@ -1,8 +1,8 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableStore, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
 import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
@@ -17,22 +17,34 @@ import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { reviveWorkspaceEditDto } from './mainThreadBulkEdits.js';
+import { GLOBSTAR } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { normalizeWatcherPattern } from 'vscode/vscode/vs/platform/files/common/watcher';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 var MainThreadFileSystemEventService_1;
 let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
     static { MainThreadFileSystemEventService_1 = this; }
     static { this.MementoKeyAdditionalEdits = `file.particpants.additionalEdits`; }
-    constructor(extHostContext, fileService, workingCopyFileService, bulkEditService, progressService, dialogService, storageService, logService, envService, uriIdentService) {
+    constructor(extHostContext, _fileService, workingCopyFileService, bulkEditService, progressService, dialogService, storageService, logService, envService, uriIdentService, _contextService, _logService, _configurationService) {
+        this._fileService = _fileService;
+        this._contextService = _contextService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
         this._listener = ( new DisposableStore());
-        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
-        this._listener.add(fileService.onDidFilesChange(event => {
-            proxy.$onFileEvent({
+        this._watches = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
+        this._listener.add(_fileService.onDidFilesChange(event => {
+            this._proxy.$onFileEvent({
                 created: event.rawAdded,
                 changed: event.rawUpdated,
                 deleted: event.rawDeleted
             });
         }));
+        const that = this;
         const fileOperationParticipant = new (class {
             async participate(files, operation, undoInfo, timeout, token) {
                 if (undoInfo?.isUndoing) {
@@ -46,7 +58,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     cancellable: true,
                     delay: Math.min(timeout / 2, 3000)
                 }, () => {
-                    const onWillEvent = proxy.$onWillRunFileOperation(operation, files, timeout, cts.token);
+                    const onWillEvent = that._proxy.$onWillRunFileOperation(operation, files, timeout, cts.token);
                     return raceCancellation(onWillEvent, cts.token);
                 }, () => {
                     cts.cancel();
@@ -242,14 +254,90 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             }
         });
         this._listener.add(workingCopyFileService.addFileOperationParticipant(fileOperationParticipant));
-        this._listener.add(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => proxy.$onDidRunFileOperation(e.operation, e.files)));
+        this._listener.add(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this._proxy.$onDidRunFileOperation(e.operation, e.files)));
+    }
+    async $watch(extensionId, session, resource, unvalidatedOpts, correlate) {
+        const uri = URI.revive(resource);
+        const opts = {
+            ...unvalidatedOpts
+        };
+        if (opts.recursive) {
+            try {
+                const stat = await this._fileService.stat(uri);
+                if (!stat.isDirectory) {
+                    opts.recursive = false;
+                }
+            }
+            catch (error) {
+                this._logService.error(`MainThreadFileSystemEventService#$watch(): failed to stat a resource for file watching (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}): ${error}`);
+            }
+        }
+        if (correlate) {
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            const watcherDisposables = ( new DisposableStore());
+            const subscription = watcherDisposables.add(this._fileService.createWatcher(uri, opts));
+            watcherDisposables.add(subscription.onDidChange(event => {
+                this._proxy.$onFileEvent({
+                    session,
+                    created: event.rawAdded,
+                    changed: event.rawUpdated,
+                    deleted: event.rawDeleted
+                });
+            }));
+            this._watches.set(session, watcherDisposables);
+        }
+        else {
+            const workspaceFolder = this._contextService.getWorkspaceFolder(uri);
+            if (workspaceFolder && opts.recursive) {
+                this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+                return;
+            }
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+            if (opts.recursive && opts.excludes.length === 0) {
+                const config = this._configurationService.getValue();
+                if (config.files?.watcherExclude) {
+                    for (const key in config.files.watcherExclude) {
+                        if (config.files.watcherExclude[key] === true) {
+                            opts.excludes.push(key);
+                        }
+                    }
+                }
+            }
+            else if (workspaceFolder) {
+                const config = this._configurationService.getValue();
+                if (config.files?.watcherExclude) {
+                    for (const key in config.files.watcherExclude) {
+                        if (config.files.watcherExclude[key] === true) {
+                            if (!opts.includes) {
+                                opts.includes = [];
+                            }
+                            const includePattern = `${rtrim(key, '/')}/${GLOBSTAR}`;
+                            opts.includes.push(normalizeWatcherPattern(workspaceFolder.uri.fsPath, includePattern));
+                        }
+                    }
+                }
+                if (!opts.includes || opts.includes.length === 0) {
+                    this._logService.trace(`MainThreadFileSystemEventService#$watch(): ignoring request to start watching because path is inside workspace and no excludes are configured (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session})`);
+                    return;
+                }
+            }
+            const subscription = this._fileService.watch(uri, opts);
+            this._watches.set(session, subscription);
+        }
+    }
+    $unwatch(session) {
+        if (( this._watches.has(session))) {
+            this._logService.trace(`MainThreadFileSystemEventService#$unwatch(): request to stop watching (session: ${session})`);
+            this._watches.deleteAndDispose(session);
+        }
     }
     dispose() {
         this._listener.dispose();
+        this._watches.dispose();
     }
 };
 MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decorate([
-    extHostCustomer,
+    extHostNamedCustomer(MainContext.MainThreadFileSystemEventService),
     ( __param(1, IFileService)),
     ( __param(2, IWorkingCopyFileService)),
     ( __param(3, IBulkEditService)),
@@ -258,7 +346,10 @@ MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decora
     ( __param(6, IStorageService)),
     ( __param(7, ILogService)),
     ( __param(8, IEnvironmentService)),
-    ( __param(9, IUriIdentityService))
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, IWorkspaceContextService)),
+    ( __param(11, ILogService)),
+    ( __param(12, IConfigurationService))
 ], MainThreadFileSystemEventService);
 registerAction2(class ResetMemento extends Action2 {
     constructor() {

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

@@ -17,10 +17,11 @@ let MainThreadInlineChat = class MainThreadInlineChat {
     dispose() {
         this._registrations.dispose();
     }
-    async $registerInteractiveEditorProvider(handle, label, debugName, supportsFeedback) {
+    async $registerInteractiveEditorProvider(handle, label, debugName, supportsFeedback, supportsFollowups, supportIssueReporting) {
         const unreg = this._inlineChatService.addProvider({
             debugName,
             label,
+            supportIssueReporting,
             prepareInlineChatSession: async (model, range, token) => {
                 const session = await this._proxy.$prepareSession(handle, model.uri, range, token);
                 if (!session) {
@@ -46,6 +47,9 @@ let MainThreadInlineChat = class MainThreadInlineChat {
                     this._progresses.delete(request.requestId);
                 }
             },
+            provideFollowups: !supportsFollowups ? undefined : async (session, response, token) => {
+                return this._proxy.$provideFollowups(handle, session.id, response.id, token);
+            },
             handleInlineChatResponseFeedback: !supportsFeedback ? undefined : async (session, response, kind) => {
                 this._proxy.$handleFeedback(handle, session.id, response.id, kind);
             }
@@ -53,7 +57,7 @@ let MainThreadInlineChat = class MainThreadInlineChat {
         this._registrations.set(handle, unreg);
     }
     async $handleProgressChunk(requestId, chunk) {
-        this._progresses.get(requestId)?.report(chunk);
+        await Promise.resolve(this._progresses.get(requestId)?.report(chunk));
     }
     async $unregisterInteractiveEditorProvider(handle) {
         this._registrations.deleteAndDispose(handle);

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

@@ -24,6 +24,22 @@ let MainThreadIssueReporter = class MainThreadIssueReporter extends Disposable {
     $unregisterIssueUriRequestHandler(extensionId) {
         this._registrations.deleteAndDispose(extensionId);
     }
+    $registerIssueDataProvider(extensionId) {
+        const provider = {
+            provideIssueExtensionData: async (token) => {
+                const parts = await this._proxy.$getIssueReporterData(extensionId, token);
+                return parts;
+            },
+            provideIssueExtensionTemplate: async (token) => {
+                const parts = await this._proxy.$getIssueReporterTemplate(extensionId, token);
+                return parts;
+            }
+        };
+        this._registrations.set(extensionId, this._issueService.registerIssueDataProvider(extensionId, provider));
+    }
+    $unregisterIssueDataProvider(extensionId) {
+        this._registrations.deleteAndDispose(extensionId);
+    }
 };
 MainThreadIssueReporter = __decorate([
     extHostNamedCustomer(MainContext.MainThreadIssueReporter),

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

@@ -19,6 +19,8 @@ import { WorkspaceSymbolProviderRegistry } from 'vscode/vscode/vs/workbench/cont
 import { TypeHierarchyProviderRegistry } from 'vscode/vscode/vs/workbench/contrib/typeHierarchy/common/typeHierarchy';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { isFalsyOrEmpty } from 'monaco-editor/esm/vs/base/common/arrays.js';
 
 var MainThreadLanguageFeatures_1;
 let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThreadLanguageFeatures extends Disposable {
@@ -237,6 +239,29 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         }));
     }
+    $registerMultiDocumentHighlightProvider(handle, selector) {
+        this._registrations.set(handle, this._languageFeaturesService.multiDocumentHighlightProvider.register(selector, {
+            selector: selector,
+            provideMultiDocumentHighlights: (model, position, otherModels, token) => {
+                return this._proxy.$provideMultiDocumentHighlights(handle, model.uri, position, ( otherModels.map(model => model.uri)), token).then(dto => {
+                    if (isFalsyOrEmpty(dto)) {
+                        return undefined;
+                    }
+                    const result = ( new ResourceMap());
+                    dto?.forEach(value => {
+                        const uri = URI.revive(value.uri);
+                        if (( result.has(uri))) {
+                            result.get(uri).push(...value.highlights);
+                        }
+                        else {
+                            result.set(uri, value.highlights);
+                        }
+                    });
+                    return result;
+                });
+            }
+        }));
+    }
     $registerLinkedEditingRangeProvider(handle, selector) {
         this._registrations.set(handle, this._languageFeaturesService.linkedEditingRangeProvider.register(selector, {
             provideLinkedEditingRanges: async (model, position, token) => {

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

@@ -5,6 +5,7 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { NotebookDto } from './mainThreadNotebookDto.js';
@@ -13,6 +14,8 @@ import { INotebookService, SimpleNotebookProviderInfo } from 'vscode/vscode/vs/w
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 
 let MainThreadNotebooks = class MainThreadNotebooks {
     constructor(extHostContext, _notebookService, _cellStatusBarService, _logService) {
@@ -65,6 +68,39 @@ let MainThreadNotebooks = class MainThreadNotebooks {
                     resource: uri
                 };
             },
+            searchInNotebooks: async (textQuery, token, allPriorityInfo) => {
+                const contributedType = this._notebookService.getContributedNotebookType(viewType);
+                if (!contributedType) {
+                    return { results: [], limitHit: false };
+                }
+                const fileNames = contributedType.selectors;
+                const includes = ( fileNames.map((selector) => {
+                    const globPattern = selector.include || selector;
+                    return ( globPattern.toString());
+                }));
+                if (!includes.length) {
+                    return {
+                        results: [], limitHit: false
+                    };
+                }
+                const thisPriorityInfo = coalesce([{ isFromSettings: false, filenamePatterns: includes }, ...(allPriorityInfo.get(viewType) ?? [])]);
+                const otherEditorsPriorityInfo = Array.from(( allPriorityInfo.keys()))
+                    .flatMap(key => {
+                    if (key !== viewType) {
+                        return allPriorityInfo.get(key) ?? [];
+                    }
+                    return [];
+                });
+                const searchComplete = await this._proxy.$searchInNotebooks(handle, textQuery, thisPriorityInfo, otherEditorsPriorityInfo, token);
+                const revivedResults = ( searchComplete.results.map(result => {
+                    const resource = URI.revive(result.resource);
+                    return {
+                        resource,
+                        cellResults: ( result.cellResults.map(e => revive(e)))
+                    };
+                }));
+                return { results: revivedResults, limitHit: searchComplete.limitHit };
+            }
         }));
         if (data) {
             disposables.add(this._notebookService.registerContributedNotebookType(viewType, data));

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

@@ -13,13 +13,14 @@ import { INotebookExecutionStateService, NotebookExecutionType } from 'vscode/vs
 import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { AsyncIterableSource } from 'monaco-editor/esm/vs/base/common/async.js';
 
 class MainThreadKernel {
     get preloadUris() {
         return ( this.preloads.map(p => p.uri));
     }
     get preloadProvides() {
-        return ( this.preloads.map(p => p.provides)).flat();
+        return this.preloads.flatMap(p => p.provides);
     }
     constructor(data, _languageService) {
         this._languageService = _languageService;
@@ -34,6 +35,7 @@ class MainThreadKernel {
         this.detail = data.detail;
         this.supportedLanguages = isNonEmptyArray(data.supportedLanguages) ? data.supportedLanguages : _languageService.getRegisteredLanguageIds();
         this.implementsExecutionOrder = data.supportsExecutionOrder ?? false;
+        this.hasVariableProvider = data.hasVariableProvider ?? false;
         this.localResourceRoot = URI.revive(data.extensionLocation);
         this.preloads = data.preloads?.map(u => ({ uri: URI.revive(u.uri), provides: u.provides })) ?? [];
     }
@@ -63,6 +65,10 @@ class MainThreadKernel {
             this.implementsInterrupt = data.supportsInterrupt;
             event.hasInterruptHandler = true;
         }
+        if (data.hasVariableProvider !== undefined) {
+            this.hasVariableProvider = data.hasVariableProvider;
+            event.hasVariableProvider = true;
+        }
         this._onDidChange.fire(event);
     }
 }
@@ -85,6 +91,8 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
         this._kernelSourceActionProvidersEventRegistrations = ( new Map());
         this._executions = ( new Map());
         this._notebookExecutions = ( new Map());
+        this.variableRequestIndex = 0;
+        this.variableRequestMap = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookKernels));
         notebookEditorService.listNotebookEditors().forEach(this._onEditorAdd, this);
         notebookEditorService.onDidAddNotebookEditor(this._onEditorAdd, this, this._disposables);
@@ -161,6 +169,12 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
         }
         return didSend;
     }
+    $receiveVariable(requestId, variable) {
+        const source = this.variableRequestMap.get(requestId);
+        if (source) {
+            source.emitOne(variable);
+        }
+    }
     async $addKernel(handle, data) {
         const that = this;
         const kernel = new (class extends MainThreadKernel {
@@ -170,6 +184,22 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
             async cancelNotebookCellExecution(uri, handles) {
                 await that._proxy.$cancelCells(handle, uri, handles);
             }
+            provideVariables(notebookUri, parentName, kind, start, token) {
+                const requestId = `${handle}variables${that.variableRequestIndex++}`;
+                if (( that.variableRequestMap.has(requestId))) {
+                    return that.variableRequestMap.get(requestId).asyncIterable;
+                }
+                const source = ( new AsyncIterableSource());
+                that.variableRequestMap.set(requestId, source);
+                that._proxy.$provideVariables(handle, requestId, notebookUri, parentName, kind, start, token).then(() => {
+                    source.resolve();
+                    that.variableRequestMap.delete(requestId);
+                }).catch((err) => {
+                    source.reject(err);
+                    that.variableRequestMap.delete(requestId);
+                });
+                return source.asyncIterable;
+            }
         })(data, this._languageService);
         const listener = this._notebookKernelService.onDidChangeSelectedNotebooks(e => {
             if (e.oldKernel === kernel.id) {
@@ -328,6 +358,9 @@ let MainThreadNotebookKernels = class MainThreadNotebookKernels {
             emitter.fire(undefined);
         }
     }
+    $variablesUpdated(notebookUri) {
+        this._notebookKernelService.notifyVariablesChange(URI.revive(notebookUri));
+    }
 };
 MainThreadNotebookKernels = __decorate([
     extHostNamedCustomer(MainContext.MainThreadNotebookKernels),

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
@@ -9,8 +9,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 let MainThreadQuickDiff = class MainThreadQuickDiff {
     constructor(extHostContext, quickDiffService) {
         this.quickDiffService = quickDiffService;
-        this.providers = ( new Map());
-        this.providerDisposables = ( new Map());
+        this.providerDisposables = ( new DisposableMap());
         this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostQuickDiff));
     }
     async $registerQuickDiffProvider(handle, selector, label, rootUri) {
@@ -23,22 +22,16 @@ let MainThreadQuickDiff = class MainThreadQuickDiff {
                 return URI.revive(await this.proxy.$provideOriginalResource(handle, uri, ( new CancellationTokenSource()).token));
             }
         };
-        this.providers.set(handle, provider);
         const disposable = this.quickDiffService.addQuickDiffProvider(provider);
         this.providerDisposables.set(handle, disposable);
     }
     async $unregisterQuickDiffProvider(handle) {
-        if (( this.providers.has(handle))) {
-            this.providers.delete(handle);
-        }
         if (( this.providerDisposables.has(handle))) {
-            this.providerDisposables.delete(handle);
+            this.providerDisposables.deleteAndDispose(handle);
         }
     }
     dispose() {
-        this.providers.clear();
-        dispose(( this.providerDisposables.values()));
-        this.providerDisposables.clear();
+        this.providerDisposables.dispose();
     }
 };
 MainThreadQuickDiff = __decorate([