@codingame/monaco-vscode-notebook-service-override 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookEditors.d.ts

@@ -0,0 +1,27 @@
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { ICellRange } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { INotebookDocumentShowOptions, MainThreadNotebookEditorsShape, NotebookEditorRevealType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadNotebookEditors implements MainThreadNotebookEditorsShape {
+    private readonly _editorService;
+    private readonly _notebookEditorService;
+    private readonly _editorGroupService;
+    private readonly _configurationService;
+    private readonly _disposables;
+    private readonly _proxy;
+    private readonly _mainThreadEditors;
+    private _currentViewColumnInfo?;
+    constructor(extHostContext: IExtHostContext, _editorService: IEditorService, _notebookEditorService: INotebookEditorService, _editorGroupService: IEditorGroupsService, _configurationService: IConfigurationService);
+    dispose(): void;
+    handleEditorsAdded(editors: readonly INotebookEditor[]): void;
+    handleEditorsRemoved(editorIds: readonly string[]): void;
+    private _updateEditorViewColumns;
+    $tryShowNotebookDocument(resource: UriComponents, viewType: string, options: INotebookDocumentShowOptions): Promise<string>;
+    $tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType): Promise<void>;
+    $trySetSelections(id: string, ranges: ICellRange[]): void;
+}

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

@@ -0,0 +1,149 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { editorGroupToColumn, columnToEditorGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ExtHostContext, NotebookEditorRevealType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+class MainThreadNotebook {
+    constructor(editor, disposables) {
+        this.editor = editor;
+        this.disposables = disposables;
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+let MainThreadNotebookEditors = class MainThreadNotebookEditors {
+    constructor(
+        extHostContext,
+        _editorService,
+        _notebookEditorService,
+        _editorGroupService,
+        _configurationService
+    ) {
+        this._editorService = _editorService;
+        this._notebookEditorService = _notebookEditorService;
+        this._editorGroupService = _editorGroupService;
+        this._configurationService = _configurationService;
+        this._disposables = ( new DisposableStore());
+        this._mainThreadEditors = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookEditors));
+        this._editorService.onDidActiveEditorChange(() => this._updateEditorViewColumns(), this, this._disposables);
+        this._editorGroupService.onDidRemoveGroup(() => this._updateEditorViewColumns(), this, this._disposables);
+        this._editorGroupService.onDidMoveGroup(() => this._updateEditorViewColumns(), this, this._disposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+        dispose(( this._mainThreadEditors.values()));
+    }
+    handleEditorsAdded(editors) {
+        for (const editor of editors) {
+            const editorDisposables = ( new DisposableStore());
+            editorDisposables.add(editor.onDidChangeVisibleRanges(() => {
+                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), {
+                    visibleRanges: {
+                        ranges: editor.visibleRanges
+                    }
+                });
+            }));
+            editorDisposables.add(editor.onDidChangeSelection(() => {
+                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), {
+                    selections: {
+                        selections: editor.getSelections()
+                    }
+                });
+            }));
+            const wrapper = ( new MainThreadNotebook(editor, editorDisposables));
+            this._mainThreadEditors.set(editor.getId(), wrapper);
+        }
+    }
+    handleEditorsRemoved(editorIds) {
+        for (const id of editorIds) {
+            this._mainThreadEditors.get(id)?.dispose();
+            this._mainThreadEditors.delete(id);
+        }
+    }
+    _updateEditorViewColumns() {
+        const result = Object.create(null);
+        for (const editorPane of this._editorService.visibleEditorPanes) {
+            const candidate = getNotebookEditorFromEditorPane(editorPane);
+            if (candidate && ( this._mainThreadEditors.has(candidate.getId()))) {
+                result[candidate.getId()] = editorGroupToColumn(this._editorGroupService, editorPane.group);
+            }
+        }
+        if (!equals(result, this._currentViewColumnInfo)) {
+            this._currentViewColumnInfo = result;
+            this._proxy.$acceptEditorViewColumns(result);
+        }
+    }
+    async $tryShowNotebookDocument(resource, viewType, options) {
+        const editorOptions = {
+            cellSelections: options.selections,
+            preserveFocus: options.preserveFocus,
+            pinned: options.pinned,
+            activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
+            label: options.label,
+            override: viewType
+        };
+        const editorPane = await this._editorService.openEditor({
+            resource: URI.revive(resource),
+            options: editorOptions
+        }, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
+        const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
+        if (notebookEditor) {
+            return notebookEditor.getId();
+        } else {
+            throw ( new Error(
+                `Notebook Editor creation failure for document ${JSON.stringify(resource)}`
+            ));
+        }
+    }
+    async $tryRevealRange(id, range, revealType) {
+        const editor = this._notebookEditorService.getNotebookEditor(id);
+        if (!editor) {
+            return;
+        }
+        const notebookEditor = editor;
+        if (!notebookEditor.hasModel()) {
+            return;
+        }
+        if (range.start >= notebookEditor.getLength()) {
+            return;
+        }
+        const cell = notebookEditor.cellAt(range.start);
+        switch (revealType) {
+        case NotebookEditorRevealType.Default:
+            return notebookEditor.revealCellRangeInView(range);
+        case NotebookEditorRevealType.InCenter:
+            return notebookEditor.revealInCenter(cell);
+        case NotebookEditorRevealType.InCenterIfOutsideViewport:
+            return notebookEditor.revealInCenterIfOutsideViewport(cell);
+        case NotebookEditorRevealType.AtTop:
+            return notebookEditor.revealInViewAtTop(cell);
+        }
+    }
+    $trySetSelections(id, ranges) {
+        const editor = this._notebookEditorService.getNotebookEditor(id);
+        if (!editor) {
+            return;
+        }
+        editor.setSelections(ranges);
+        if (ranges.length) {
+            editor.setFocus({
+                start: ranges[0].start,
+                end: ranges[0].start + 1
+            });
+        }
+    }
+};
+MainThreadNotebookEditors = ( __decorate([( __param(1, IEditorService)), ( __param(2, INotebookEditorService)), ( __param(3, IEditorGroupsService)), ( __param(4, IConfigurationService))], MainThreadNotebookEditors));
+
+export { MainThreadNotebookEditors };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookKernels.d.ts

@@ -0,0 +1,49 @@
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { INotebookExecutionStateService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service";
+import { VariablesResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService";
+import { INotebookKernelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service";
+import { SerializableObjectWithBuffers } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+import { ICellExecuteUpdateDto, ICellExecutionCompleteDto, INotebookKernelDto2, MainThreadNotebookKernelsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+export declare class MainThreadNotebookKernels implements MainThreadNotebookKernelsShape {
+    private readonly _languageService;
+    private readonly _notebookKernelService;
+    private readonly _notebookExecutionStateService;
+    private readonly _notebookService;
+    private readonly _editors;
+    private readonly _disposables;
+    private readonly _kernels;
+    private readonly _kernelDetectionTasks;
+    private readonly _kernelSourceActionProviders;
+    private readonly _kernelSourceActionProvidersEventRegistrations;
+    private readonly _proxy;
+    private readonly _executions;
+    private readonly _notebookExecutions;
+    constructor(extHostContext: IExtHostContext, _languageService: ILanguageService, _notebookKernelService: INotebookKernelService, _notebookExecutionStateService: INotebookExecutionStateService, _notebookService: INotebookService, notebookEditorService: INotebookEditorService);
+    dispose(): void;
+    private _onEditorAdd;
+    private _onEditorRemove;
+    $postMessage(handle: number, editorId: string | undefined, message: unknown): Promise<boolean>;
+    private variableRequestIndex;
+    private variableRequestMap;
+    $receiveVariable(requestId: string, variable: VariablesResult): void;
+    $addKernel(handle: number, data: INotebookKernelDto2): Promise<void>;
+    $updateKernel(handle: number, data: Partial<INotebookKernelDto2>): void;
+    $removeKernel(handle: number): void;
+    $updateNotebookPriority(handle: number, notebook: UriComponents, value: number | undefined): void;
+    $createExecution(handle: number, controllerId: string, rawUri: UriComponents, cellHandle: number): void;
+    $updateExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecuteUpdateDto[]>): void;
+    $completeExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecutionCompleteDto>): void;
+    $createNotebookExecution(handle: number, controllerId: string, rawUri: UriComponents): void;
+    $beginNotebookExecution(handle: number): void;
+    $completeNotebookExecution(handle: number): void;
+    $addKernelDetectionTask(handle: number, notebookType: string): Promise<void>;
+    $removeKernelDetectionTask(handle: number): void;
+    $addKernelSourceActionProvider(handle: number, eventHandle: number, notebookType: string): Promise<void>;
+    $removeKernelSourceActionProvider(handle: number, eventHandle: number): void;
+    $emitNotebookKernelSourceActionsChangeEvent(eventHandle: number): void;
+    $variablesUpdated(notebookUri: UriComponents): void;
+}

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

@@ -0,0 +1,372 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isNonEmptyArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { NotebookDto } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
+import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { AsyncIterableProducer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+
+class MainThreadKernel {
+    get preloadUris() {
+        return ( this.preloads.map(p => p.uri));
+    }
+    get preloadProvides() {
+        return this.preloads.flatMap(p => p.provides);
+    }
+    constructor(data, _languageService) {
+        this._languageService = _languageService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.id = data.id;
+        this.viewType = data.notebookType;
+        this.extension = data.extensionId;
+        this.implementsInterrupt = data.supportsInterrupt ?? false;
+        this.label = data.label;
+        this.description = data.description;
+        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
+        })) ?? [];
+    }
+    update(data) {
+        const event = Object.create(null);
+        if (data.label !== undefined) {
+            this.label = data.label;
+            event.label = true;
+        }
+        if (data.description !== undefined) {
+            this.description = data.description;
+            event.description = true;
+        }
+        if (data.detail !== undefined) {
+            this.detail = data.detail;
+            event.detail = true;
+        }
+        if (data.supportedLanguages !== undefined) {
+            this.supportedLanguages = isNonEmptyArray(data.supportedLanguages) ? data.supportedLanguages : this._languageService.getRegisteredLanguageIds();
+            event.supportedLanguages = true;
+        }
+        if (data.supportsExecutionOrder !== undefined) {
+            this.implementsExecutionOrder = data.supportsExecutionOrder;
+            event.hasExecutionOrder = true;
+        }
+        if (data.supportsInterrupt !== undefined) {
+            this.implementsInterrupt = data.supportsInterrupt;
+            event.hasInterruptHandler = true;
+        }
+        if (data.hasVariableProvider !== undefined) {
+            this.hasVariableProvider = data.hasVariableProvider;
+            event.hasVariableProvider = true;
+        }
+        this._onDidChange.fire(event);
+    }
+}
+class MainThreadKernelDetectionTask {
+    constructor(notebookType) {
+        this.notebookType = notebookType;
+    }
+}
+let MainThreadNotebookKernels = class MainThreadNotebookKernels {
+    constructor(
+        extHostContext,
+        _languageService,
+        _notebookKernelService,
+        _notebookExecutionStateService,
+        _notebookService,
+        notebookEditorService
+    ) {
+        this._languageService = _languageService;
+        this._notebookKernelService = _notebookKernelService;
+        this._notebookExecutionStateService = _notebookExecutionStateService;
+        this._notebookService = _notebookService;
+        this._editors = ( new DisposableMap());
+        this._disposables = ( new DisposableStore());
+        this._kernels = ( new Map());
+        this._kernelDetectionTasks = ( new Map());
+        this._kernelSourceActionProviders = ( new Map());
+        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);
+        notebookEditorService.onDidRemoveNotebookEditor(this._onEditorRemove, this, this._disposables);
+        this._disposables.add(toDisposable(() => {
+            this._executions.forEach(e => {
+                e.complete({});
+            });
+            this._notebookExecutions.forEach(e => e.complete());
+        }));
+        this._disposables.add(this._notebookKernelService.onDidChangeSelectedNotebooks(e => {
+            for (const [handle, [kernel]] of this._kernels) {
+                if (e.oldKernel === kernel.id) {
+                    this._proxy.$acceptNotebookAssociation(handle, e.notebook, false);
+                } else if (e.newKernel === kernel.id) {
+                    this._proxy.$acceptNotebookAssociation(handle, e.notebook, true);
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        for (const [, registration] of ( this._kernels.values())) {
+            registration.dispose();
+        }
+        for (const [, registration] of ( this._kernelDetectionTasks.values())) {
+            registration.dispose();
+        }
+        for (const [, registration] of ( this._kernelSourceActionProviders.values())) {
+            registration.dispose();
+        }
+        this._editors.dispose();
+    }
+    _onEditorAdd(editor) {
+        const ipcListener = editor.onDidReceiveMessage(e => {
+            if (!editor.hasModel()) {
+                return;
+            }
+            const {
+                selected
+            } = this._notebookKernelService.getMatchingKernel(editor.textModel);
+            if (!selected) {
+                return;
+            }
+            for (const [handle, candidate] of this._kernels) {
+                if (candidate[0] === selected) {
+                    this._proxy.$acceptKernelMessageFromRenderer(handle, editor.getId(), e.message);
+                    break;
+                }
+            }
+        });
+        this._editors.set(editor, ipcListener);
+    }
+    _onEditorRemove(editor) {
+        this._editors.deleteAndDispose(editor);
+    }
+    async $postMessage(handle, editorId, message) {
+        const tuple = this._kernels.get(handle);
+        if (!tuple) {
+            throw ( new Error("kernel already disposed"));
+        }
+        const [kernel] = tuple;
+        let didSend = false;
+        for (const [editor] of this._editors) {
+            if (!editor.hasModel()) {
+                continue;
+            }
+            if (this._notebookKernelService.getMatchingKernel(editor.textModel).selected !== kernel) {
+                continue;
+            }
+            if (editorId === undefined) {
+                editor.postMessage(message);
+                didSend = true;
+            } else if (editor.getId() === editorId) {
+                editor.postMessage(message);
+                didSend = true;
+                break;
+            }
+        }
+        return didSend;
+    }
+    $receiveVariable(requestId, variable) {
+        const emitter = this.variableRequestMap.get(requestId);
+        if (emitter) {
+            emitter.emitOne(variable);
+        }
+    }
+    async $addKernel(handle, data) {
+        const that = this;
+        const kernel = new (class extends MainThreadKernel {
+            async executeNotebookCellsRequest(uri, handles) {
+                await that._proxy.$executeCells(handle, uri, handles);
+            }
+            async cancelNotebookCellExecution(uri, handles) {
+                await that._proxy.$cancelCells(handle, uri, handles);
+            }
+            provideVariables(notebookUri, parentId, kind, start, token) {
+                const requestId = `${handle}variables${that.variableRequestIndex++}`;
+                return new AsyncIterableProducer(async emitter => {
+                    that.variableRequestMap.set(requestId, emitter);
+                    try {
+                        await that._proxy.$provideVariables(handle, requestId, notebookUri, parentId, kind, start, token);
+                    } finally {
+                        that.variableRequestMap.delete(requestId);
+                    }
+                });
+            }
+        })(data, this._languageService);
+        const disposables = this._disposables.add(( new DisposableStore()));
+        this._kernels.set(handle, [kernel, disposables]);
+        disposables.add(this._notebookKernelService.registerKernel(kernel));
+    }
+    $updateKernel(handle, data) {
+        const tuple = this._kernels.get(handle);
+        if (tuple) {
+            tuple[0].update(data);
+        }
+    }
+    $removeKernel(handle) {
+        const tuple = this._kernels.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this._kernels.delete(handle);
+        }
+    }
+    $updateNotebookPriority(handle, notebook, value) {
+        const tuple = this._kernels.get(handle);
+        if (tuple) {
+            this._notebookKernelService.updateKernelNotebookAffinity(tuple[0], URI.revive(notebook), value);
+        }
+    }
+    $createExecution(handle, controllerId, rawUri, cellHandle) {
+        const uri = URI.revive(rawUri);
+        const notebook = this._notebookService.getNotebookTextModel(uri);
+        if (!notebook) {
+            throw ( new Error(`Notebook not found: ${( uri.toString())}`));
+        }
+        const kernel = this._notebookKernelService.getMatchingKernel(notebook);
+        if (!kernel.selected || kernel.selected.id !== controllerId) {
+            throw ( new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`));
+        }
+        const execution = this._notebookExecutionStateService.createCellExecution(uri, cellHandle);
+        execution.confirm();
+        this._executions.set(handle, execution);
+    }
+    $updateExecution(handle, data) {
+        const updates = data.value;
+        try {
+            const execution = this._executions.get(handle);
+            execution?.update(( updates.map(NotebookDto.fromCellExecuteUpdateDto)));
+        } catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    $completeExecution(handle, data) {
+        try {
+            const execution = this._executions.get(handle);
+            execution?.complete(NotebookDto.fromCellExecuteCompleteDto(data.value));
+        } catch (e) {
+            onUnexpectedError(e);
+        } finally {
+            this._executions.delete(handle);
+        }
+    }
+    $createNotebookExecution(handle, controllerId, rawUri) {
+        const uri = URI.revive(rawUri);
+        const notebook = this._notebookService.getNotebookTextModel(uri);
+        if (!notebook) {
+            throw ( new Error(`Notebook not found: ${( uri.toString())}`));
+        }
+        const kernel = this._notebookKernelService.getMatchingKernel(notebook);
+        if (!kernel.selected || kernel.selected.id !== controllerId) {
+            throw ( new Error(`Kernel is not selected: ${kernel.selected?.id} !== ${controllerId}`));
+        }
+        const execution = this._notebookExecutionStateService.createExecution(uri);
+        execution.confirm();
+        this._notebookExecutions.set(handle, execution);
+    }
+    $beginNotebookExecution(handle) {
+        try {
+            const execution = this._notebookExecutions.get(handle);
+            execution?.begin();
+        } catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    $completeNotebookExecution(handle) {
+        try {
+            const execution = this._notebookExecutions.get(handle);
+            execution?.complete();
+        } catch (e) {
+            onUnexpectedError(e);
+        } finally {
+            this._notebookExecutions.delete(handle);
+        }
+    }
+    async $addKernelDetectionTask(handle, notebookType) {
+        const kernelDetectionTask = ( new MainThreadKernelDetectionTask(notebookType));
+        const registration = this._notebookKernelService.registerNotebookKernelDetectionTask(kernelDetectionTask);
+        this._kernelDetectionTasks.set(handle, [kernelDetectionTask, registration]);
+    }
+    $removeKernelDetectionTask(handle) {
+        const tuple = this._kernelDetectionTasks.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this._kernelDetectionTasks.delete(handle);
+        }
+    }
+    async $addKernelSourceActionProvider(handle, eventHandle, notebookType) {
+        const kernelSourceActionProvider = {
+            viewType: notebookType,
+            provideKernelSourceActions: async () => {
+                const actions = await this._proxy.$provideKernelSourceActions(handle, CancellationToken.None);
+                return ( actions.map(action => {
+                    let documentation = action.documentation;
+                    if (action.documentation && typeof action.documentation !== "string") {
+                        documentation = URI.revive(action.documentation);
+                    }
+                    return {
+                        label: action.label,
+                        command: action.command,
+                        description: action.description,
+                        detail: action.detail,
+                        documentation
+                    };
+                }));
+            }
+        };
+        if (typeof eventHandle === "number") {
+            const emitter = ( new Emitter());
+            this._kernelSourceActionProvidersEventRegistrations.set(eventHandle, emitter);
+            kernelSourceActionProvider.onDidChangeSourceActions = emitter.event;
+        }
+        const registration = this._notebookKernelService.registerKernelSourceActionProvider(notebookType, kernelSourceActionProvider);
+        this._kernelSourceActionProviders.set(handle, [kernelSourceActionProvider, registration]);
+    }
+    $removeKernelSourceActionProvider(handle, eventHandle) {
+        const tuple = this._kernelSourceActionProviders.get(handle);
+        if (tuple) {
+            tuple[1].dispose();
+            this._kernelSourceActionProviders.delete(handle);
+        }
+        if (typeof eventHandle === "number") {
+            this._kernelSourceActionProvidersEventRegistrations.delete(eventHandle);
+        }
+    }
+    $emitNotebookKernelSourceActionsChangeEvent(eventHandle) {
+        const emitter = this._kernelSourceActionProvidersEventRegistrations.get(eventHandle);
+        if (emitter instanceof Emitter) {
+            emitter.fire(undefined);
+        }
+    }
+    $variablesUpdated(notebookUri) {
+        this._notebookKernelService.notifyVariablesChange(URI.revive(notebookUri));
+    }
+};
+MainThreadNotebookKernels = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadNotebookKernels),
+    ( __param(1, ILanguageService)),
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, INotebookExecutionStateService)),
+    ( __param(4, INotebookService)),
+    ( __param(5, INotebookEditorService))
+], MainThreadNotebookKernels);
+
+export { MainThreadNotebookKernels };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookRenderers.d.ts

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { MainThreadNotebookRenderersShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { INotebookRendererMessagingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService.service";
+export declare class MainThreadNotebookRenderers extends Disposable implements MainThreadNotebookRenderersShape {
+    private readonly messaging;
+    private readonly proxy;
+    constructor(extHostContext: IExtHostContext, messaging: INotebookRendererMessagingService);
+    $postMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean>;
+}

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

@@ -0,0 +1,26 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { INotebookRendererMessagingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService.service';
+
+let MainThreadNotebookRenderers = class MainThreadNotebookRenderers extends Disposable {
+    constructor(extHostContext, messaging) {
+        super();
+        this.messaging = messaging;
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookRenderers));
+        this._register(messaging.onShouldPostMessage(e => {
+            this.proxy.$postRendererMessage(e.editorId, e.rendererId, e.message);
+        }));
+    }
+    $postMessage(editorId, rendererId, message) {
+        return this.messaging.receiveMessage(editorId, rendererId, message);
+    }
+};
+MainThreadNotebookRenderers = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadNotebookRenderers),
+    ( __param(1, INotebookRendererMessagingService))
+], MainThreadNotebookRenderers);
+
+export { MainThreadNotebookRenderers };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookSaveParticipant.d.ts

@@ -0,0 +1,9 @@
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { IWorkingCopyFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+export declare class SaveParticipant {
+    private readonly workingCopyFileService;
+    private _saveParticipantDisposable;
+    constructor(extHostContext: IExtHostContext, instantiationService: IInstantiationService, workingCopyFileService: IWorkingCopyFileService);
+    dispose(): void;
+}