@theia/notebook 1.42.1 → 1.43.0

package/src/browser/notebook-open-handler.ts

@@ -28,9 +28,8 @@ export class NotebookOpenHandler extends NavigatableWidgetOpenHandler<NotebookEd
 
     id: string = 'notebook';
 
-    constructor(@inject(NotebookTypeRegistry) private notebookTypeRegistry: NotebookTypeRegistry) {
-        super();
-    }
+    @inject(NotebookTypeRegistry)
+    protected notebookTypeRegistry: NotebookTypeRegistry;
 
     canHandle(uri: URI, options?: WidgetOpenerOptions | undefined): MaybePromise<number> {
         const priorities = this.notebookTypeRegistry.notebookTypes
@@ -59,7 +58,7 @@ export class NotebookOpenHandler extends NavigatableWidgetOpenHandler<NotebookEd
 
     protected calculatePriority(notebookType: NotebookTypeDescriptor | undefined): number {
         if (!notebookType) {
-            return -1;
+            return 0;
         }
         return notebookType.priority === 'option' ? 100 : 200;
     }

package/src/browser/notebook-renderer-registry.ts

@@ -33,7 +33,11 @@ export interface NotebookRendererInfo {
 @injectable()
 export class NotebookRendererRegistry {
 
-    readonly notebookRenderers: NotebookRendererInfo[] = [];
+    private readonly _notebookRenderers: NotebookRendererInfo[] = [];
+
+    get notebookRenderers(): readonly NotebookRendererInfo[] {
+        return this._notebookRenderers;
+    }
 
     registerNotebookRenderer(type: NotebookRendererDescriptor, basePath: string): Disposable {
         let entrypoint;
@@ -48,14 +52,14 @@ export class NotebookRendererRegistry {
             };
         }
 
-        this.notebookRenderers.push({
+        this._notebookRenderers.push({
             ...type,
             mimeTypes: type.mimeTypes || [],
             requiresMessaging: type.requiresMessaging === 'always' || type.requiresMessaging === 'optional',
             entrypoint
         });
         return Disposable.create(() => {
-            this.notebookRenderers.splice(this.notebookRenderers.findIndex(renderer => renderer.id === type.id), 1);
+            this._notebookRenderers.splice(this._notebookRenderers.findIndex(renderer => renderer.id === type.id), 1);
         });
     }
 }

package/src/browser/notebook-type-registry.ts

@@ -19,12 +19,16 @@ import { NotebookTypeDescriptor } from '../common/notebook-protocol';
 
 @injectable()
 export class NotebookTypeRegistry {
-    readonly notebookTypes: NotebookTypeDescriptor[] = [];
+    private readonly _notebookTypes: NotebookTypeDescriptor[] = [];
+
+    get notebookTypes(): readonly NotebookTypeDescriptor[] {
+        return this._notebookTypes;
+    }
 
     registerNotebookType(type: NotebookTypeDescriptor): Disposable {
-        this.notebookTypes.push(type);
+        this._notebookTypes.push(type);
         return Disposable.create(() => {
-            this.notebookTypes.splice(this.notebookTypes.indexOf(type), 1);
+            this._notebookTypes.splice(this._notebookTypes.indexOf(type), 1);
         });
     }
 }

package/src/browser/renderers/cell-output-webview.ts

@@ -25,7 +25,7 @@ export interface CellOutputWebview extends Disposable {
 
     readonly id: string;
 
-    render(): React.JSX.Element;
+    render(): React.ReactNode;
 
     attachWebview(): void;
     isAttached(): boolean

package/src/browser/service/notebook-cell-context-manager.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { ContextKeyService, ScopedValueStore } from '@theia/core/lib/browser/context-key-service';
+import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { NotebookCellModel } from '../view-model/notebook-cell-model';
 import { NOTEBOOK_CELL_EXECUTING, NOTEBOOK_CELL_EXECUTION_STATE, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_TYPE } from '../contributions/notebook-context-keys';
 import { Disposable, DisposableCollection, Emitter } from '@theia/core';
@@ -31,7 +31,6 @@ export class NotebookCellContextManager implements Disposable {
 
     protected readonly toDispose = new DisposableCollection();
 
-    protected currentStore: ScopedValueStore;
     protected currentContext: HTMLLIElement;
 
     protected readonly onDidChangeContextEmitter = new Emitter<void>();
@@ -40,21 +39,21 @@ export class NotebookCellContextManager implements Disposable {
     updateCellContext(cell: NotebookCellModel, newHtmlContext: HTMLLIElement): void {
         if (newHtmlContext !== this.currentContext) {
             this.toDispose.dispose();
-            this.currentStore?.dispose();
 
             this.currentContext = newHtmlContext;
-            this.currentStore = this.contextKeyService.createScoped(newHtmlContext);
+            const currentStore = this.contextKeyService.createScoped(newHtmlContext);
+            this.toDispose.push(currentStore);
 
-            this.currentStore.setContext(NOTEBOOK_CELL_TYPE, cell.cellKind === CellKind.Code ? 'code' : 'markdown');
+            currentStore.setContext(NOTEBOOK_CELL_TYPE, cell.cellKind === CellKind.Code ? 'code' : 'markdown');
 
             this.toDispose.push(cell.onDidRequestCellEditChange(cellEdit => {
-                this.currentStore?.setContext(NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, cellEdit);
+                currentStore?.setContext(NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, cellEdit);
                 this.onDidChangeContextEmitter.fire();
             }));
             this.toDispose.push(this.executionStateService.onDidChangeExecution(e => {
                 if (e.affectsCell(cell.uri)) {
-                    this.currentStore?.setContext(NOTEBOOK_CELL_EXECUTING, !!e.changed);
-                    this.currentStore?.setContext(NOTEBOOK_CELL_EXECUTION_STATE, e.changed?.state ?? 'idle');
+                    currentStore?.setContext(NOTEBOOK_CELL_EXECUTING, !!e.changed);
+                    currentStore?.setContext(NOTEBOOK_CELL_EXECUTION_STATE, e.changed?.state ?? 'idle');
                     this.onDidChangeContextEmitter.fire();
                 }
             }));
@@ -64,7 +63,6 @@ export class NotebookCellContextManager implements Disposable {
 
     dispose(): void {
         this.toDispose.dispose();
-        this.currentStore?.dispose();
         this.onDidChangeContextEmitter.dispose();
     }
 }

package/src/browser/service/{notebook-editor-service.ts → notebook-editor-widget-service.ts}

@@ -22,7 +22,7 @@
 import { Disposable, DisposableCollection, Emitter } from '@theia/core';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { ApplicationShell } from '@theia/core/lib/browser';
-import { NotebookEditorWidget, NOTEBOOK_EDITOR_ID_PREFIX } from '../notebook-editor-widget';
+import { NotebookEditorWidget } from '../notebook-editor-widget';
 
 @injectable()
 export class NotebookEditorWidgetService implements Disposable {
@@ -33,37 +33,42 @@ export class NotebookEditorWidgetService implements Disposable {
     private readonly notebookEditors = new Map<string, NotebookEditorWidget>();
 
     private readonly onNotebookEditorAddEmitter = new Emitter<NotebookEditorWidget>();
-    private readonly onNotebookEditorsRemoveEmitter = new Emitter<NotebookEditorWidget>();
+    private readonly onNotebookEditorRemoveEmitter = new Emitter<NotebookEditorWidget>();
     readonly onDidAddNotebookEditor = this.onNotebookEditorAddEmitter.event;
-    readonly onDidRemoveNotebookEditor = this.onNotebookEditorsRemoveEmitter.event;
+    readonly onDidRemoveNotebookEditor = this.onNotebookEditorRemoveEmitter.event;
 
-    private readonly onFocusedEditorChangedEmitter = new Emitter<NotebookEditorWidget>();
-    readonly onFocusedEditorChanged = this.onFocusedEditorChangedEmitter.event;
+    private readonly onDidChangeFocusedEditorEmitter = new Emitter<NotebookEditorWidget | undefined>();
+    readonly onDidChangeFocusedEditor = this.onDidChangeFocusedEditorEmitter.event;
 
     private readonly toDispose = new DisposableCollection();
 
-    currentFocusedEditor?: NotebookEditorWidget = undefined;
+    focusedEditor?: NotebookEditorWidget = undefined;
 
     @postConstruct()
     protected init(): void {
         this.toDispose.push(this.applicationShell.onDidChangeActiveWidget(event => {
-            if (event.newValue?.id.startsWith(NOTEBOOK_EDITOR_ID_PREFIX) && event.newValue !== this.currentFocusedEditor) {
-                this.currentFocusedEditor = event.newValue as NotebookEditorWidget;
-                this.onFocusedEditorChangedEmitter.fire(this.currentFocusedEditor);
+            if (event.newValue instanceof NotebookEditorWidget && event.newValue !== this.focusedEditor) {
+                this.focusedEditor = event.newValue;
+                this.onDidChangeFocusedEditorEmitter.fire(this.focusedEditor);
+            } else {
+                this.onDidChangeFocusedEditorEmitter.fire(undefined);
             }
         }));
     }
 
     dispose(): void {
         this.onNotebookEditorAddEmitter.dispose();
-        this.onNotebookEditorsRemoveEmitter.dispose();
-        this.onFocusedEditorChangedEmitter.dispose();
+        this.onNotebookEditorRemoveEmitter.dispose();
+        this.onDidChangeFocusedEditorEmitter.dispose();
         this.toDispose.dispose();
     }
 
     // --- editor management
 
     addNotebookEditor(editor: NotebookEditorWidget): void {
+        if (this.notebookEditors.has(editor.id)) {
+            console.warn('Attempting to add duplicated notebook editor: ' + editor.id);
+        }
         this.notebookEditors.set(editor.id, editor);
         this.onNotebookEditorAddEmitter.fire(editor);
     }
@@ -71,7 +76,9 @@ export class NotebookEditorWidgetService implements Disposable {
     removeNotebookEditor(editor: NotebookEditorWidget): void {
         if (this.notebookEditors.has(editor.id)) {
             this.notebookEditors.delete(editor.id);
-            this.onNotebookEditorsRemoveEmitter.fire(editor);
+            this.onNotebookEditorRemoveEmitter.fire(editor);
+        } else {
+            console.warn('Attempting to remove not registered editor: ' + editor.id);
         }
     }
 

package/src/browser/service/notebook-execution-service.ts

@@ -65,7 +65,7 @@ export class NotebookExecutionService {
         for (const cell of cellsArr) {
             const cellExe = this.notebookExecutionStateService.getCellExecution(cell.uri);
             if (!cellExe) {
-                cellExecutions.push([cell, this.notebookExecutionStateService.createCellExecution(notebook.uri, cell.handle)]);
+                cellExecutions.push([cell, this.notebookExecutionStateService.getOrCreateCellExecution(notebook.uri, cell.handle)]);
             }
         }
 

package/src/browser/service/notebook-execution-state-service.ts

@@ -18,7 +18,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable, Emitter, URI } from '@theia/core';
+import { Disposable, DisposableCollection, Emitter, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { NotebookService } from './notebook-service';
 import {
@@ -43,22 +43,6 @@ export interface CellExecutionStateUpdate {
     isPaused?: boolean;
 }
 
-export interface ICellExecutionStateUpdate {
-    editType: CellExecutionUpdateType.ExecutionState;
-    executionOrder?: number;
-    runStartTime?: number;
-    didPause?: boolean;
-    isPaused?: boolean;
-}
-
-export interface ICellExecutionStateUpdate {
-    editType: CellExecutionUpdateType.ExecutionState;
-    executionOrder?: number;
-    runStartTime?: number;
-    didPause?: boolean;
-    isPaused?: boolean;
-}
-
 export interface ICellExecutionComplete {
     runEndTime?: number;
     lastRunSuccess?: boolean;
@@ -85,7 +69,9 @@ export class NotebookExecutionStateService implements Disposable {
     @inject(NotebookService)
     protected notebookService: NotebookService;
 
-    protected readonly executions = new Map<string, CellExecution>();
+    protected toDispose: DisposableCollection = new DisposableCollection();
+
+    protected readonly executions = new Map<string, Map<number, CellExecution>>();
 
     private readonly onDidChangeExecutionEmitter = new Emitter<CellExecutionStateChangedEvent>();
     onDidChangeExecution = this.onDidChangeExecutionEmitter.event;
@@ -93,18 +79,21 @@ export class NotebookExecutionStateService implements Disposable {
     private readonly onDidChangeLastRunFailStateEmitter = new Emitter<NotebookFailStateChangedEvent>();
     onDidChangeLastRunFailState = this.onDidChangeLastRunFailStateEmitter.event;
 
-    createCellExecution(notebookUri: URI, cellHandle: number): CellExecution {
+    getOrCreateCellExecution(notebookUri: URI, cellHandle: number): CellExecution {
         const notebook = this.notebookService.getNotebookEditorModel(notebookUri);
 
         if (!notebook) {
             throw new Error(`Notebook not found: ${notebookUri.toString()}`);
         }
 
-        let execution = this.executions.get(`${notebookUri}/${cellHandle}`);
+        let execution = this.executions.get(notebookUri.toString())?.get(cellHandle);
 
         if (!execution) {
             execution = this.createNotebookCellExecution(notebook, cellHandle);
-            this.executions.set(`${notebookUri}/${cellHandle}`, execution);
+            if (!this.executions.has(notebookUri.toString())) {
+                this.executions.set(notebookUri.toString(), new Map());
+            }
+            this.executions.get(notebookUri.toString())?.set(cellHandle, execution);
             execution.initialize();
             this.onDidChangeExecutionEmitter.fire(new CellExecutionStateChangedEvent(notebookUri, cellHandle, execution));
         }
@@ -116,20 +105,20 @@ export class NotebookExecutionStateService implements Disposable {
     private createNotebookCellExecution(notebook: NotebookModel, cellHandle: number): CellExecution {
         const notebookUri = notebook.uri;
         const execution = new CellExecution(cellHandle, notebook);
-        execution.onDidUpdate(() => this.onDidChangeExecutionEmitter.fire(new CellExecutionStateChangedEvent(notebookUri, cellHandle, execution)));
-        execution.onDidComplete(lastRunSuccess => this.onCellExecutionDidComplete(notebookUri, cellHandle, execution, lastRunSuccess));
+        execution.toDispose.push(execution.onDidUpdate(() => this.onDidChangeExecutionEmitter.fire(new CellExecutionStateChangedEvent(notebookUri, cellHandle, execution))));
+        execution.toDispose.push(execution.onDidComplete(lastRunSuccess => this.onCellExecutionDidComplete(notebookUri, cellHandle, execution, lastRunSuccess)));
 
         return execution;
     }
 
     private onCellExecutionDidComplete(notebookUri: URI, cellHandle: number, exe: CellExecution, lastRunSuccess?: boolean): void {
-        const notebookExecutions = this.executions.get(`${notebookUri}/${cellHandle}`);
+        const notebookExecutions = this.executions.get(notebookUri.toString())?.get(cellHandle);
         if (!notebookExecutions) {
-            return;
+            throw new Error('Notebook Cell Execution not found while trying to complete it');
         }
 
         exe.dispose();
-        this.executions.delete(`${notebookUri}/${cellHandle}`);
+        this.executions.get(notebookUri.toString())?.delete(cellHandle);
 
         this.onDidChangeExecutionEmitter.fire(new CellExecutionStateChangedEvent(notebookUri, cellHandle));
     }
@@ -140,14 +129,14 @@ export class NotebookExecutionStateService implements Disposable {
             throw new Error(`Not a cell URI: ${cellUri}`);
         }
 
-        return this.executions.get(`${parsed.notebook.toString()}/${parsed.handle}`);
+        return this.executions.get(parsed.notebook.toString())?.get(parsed.handle);
     }
 
     dispose(): void {
         this.onDidChangeExecutionEmitter.dispose();
         this.onDidChangeLastRunFailStateEmitter.dispose();
 
-        this.executions.forEach(cellExecution => cellExecution.dispose());
+        this.executions.forEach(notebookExecutions => notebookExecutions.forEach(execution => execution.dispose()));
     }
 
 }
@@ -159,6 +148,8 @@ export class CellExecution implements Disposable {
     private readonly onDidCompleteEmitter = new Emitter<boolean | undefined>();
     readonly onDidComplete = this.onDidCompleteEmitter.event;
 
+    toDispose = new DisposableCollection();
+
     private _state: NotebookCellExecutionState = NotebookCellExecutionState.Unconfirmed;
     get state(): NotebookCellExecutionState {
         return this._state;
@@ -198,7 +189,7 @@ export class CellExecution implements Disposable {
                 renderDuration: undefined,
             }
         };
-        this.applyExecutionEdits([startExecuteEdit]);
+        this.applyCellExecutionEditsToNotebook([startExecuteEdit]);
     }
 
     private getCellLog(): string {
@@ -221,7 +212,7 @@ export class CellExecution implements Disposable {
 
         const lastIsPausedUpdate = [...updates].reverse().find(u => u.editType === CellExecutionUpdateType.ExecutionState && typeof u.isPaused === 'boolean');
         if (lastIsPausedUpdate) {
-            this._isPaused = (lastIsPausedUpdate as ICellExecutionStateUpdate).isPaused!;
+            this._isPaused = (lastIsPausedUpdate as CellExecutionStateUpdate).isPaused!;
         }
 
         const cellModel = this.notebook.cells.find(c => c.handle === this.cellHandle);
@@ -229,7 +220,7 @@ export class CellExecution implements Disposable {
             console.debug(`CellExecution#update, updating cell not in notebook: ${this.notebook.uri.toString()}, ${this.cellHandle}`);
         } else {
             const edits = updates.map(update => updateToEdit(update, this.cellHandle));
-            this.applyExecutionEdits(edits);
+            this.applyCellExecutionEditsToNotebook(edits);
         }
 
         if (updates.some(u => u.editType === CellExecutionUpdateType.ExecutionState)) {
@@ -254,7 +245,7 @@ export class CellExecution implements Disposable {
                     runEndTime: this._didPause ? null : completionData.runEndTime,
                 }
             };
-            this.applyExecutionEdits([edit]);
+            this.applyCellExecutionEditsToNotebook([edit]);
         }
 
         this.onDidCompleteEmitter.fire(completionData.lastRunSuccess);
@@ -264,9 +255,10 @@ export class CellExecution implements Disposable {
     dispose(): void {
         this.onDidUpdateEmitter.dispose();
         this.onDidCompleteEmitter.dispose();
+        this.toDispose.dispose();
     }
 
-    private applyExecutionEdits(edits: CellEditOperation[]): void {
+    private applyCellExecutionEditsToNotebook(edits: CellEditOperation[]): void {
         this.notebook.applyEdits(edits, false);
     }
 }
@@ -301,6 +293,7 @@ export function updateToEdit(update: CellExecuteUpdate, cellHandle: number): Cel
         return {
             editType: CellEditType.OutputItems,
             items: update.items,
+            outputId: update.outputId,
             append: update.append,
         };
     } else if (update.editType === CellExecutionUpdateType.ExecutionState) {

package/src/browser/service/notebook-kernel-quick-pick-service.ts

@@ -18,7 +18,6 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-
 import { ArrayUtils, Command, CommandService, DisposableCollection, Event, nls, QuickInputButton, QuickInputService, QuickPickInput, QuickPickItem, URI, } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { NotebookKernelService, NotebookKernel, NotebookKernelMatchResult, SourceCommand } from './notebook-kernel-service';
@@ -216,7 +215,7 @@ export abstract class NotebookKernelQuickPickServiceImpl {
 
         if (isSourcePick(pick)) {
             // selected explicitly, it should trigger the execution?
-            pick.action.run();
+            pick.action.run(this.commandService);
         }
 
         return true;
@@ -316,7 +315,7 @@ export class KernelPickerMRUStrategy extends NotebookKernelQuickPickServiceImpl
             quickPick.onDidTriggerItemButton(async e => {
 
                 if (isKernelSourceQuickPickItem(e.item) && e.item.documentation !== undefined) {
-                    const uri: URI | undefined = URI.isUri(e.item.documentation) ? new URI(e.item.documentation) : await this.commandService.executeCommand(e.item.documentation);
+                    const uri: URI | undefined = this.isUri(e.item.documentation) ? new URI(e.item.documentation) : await this.commandService.executeCommand(e.item.documentation);
                     if (uri) {
                         (await this.openerService.getOpener(uri, { openExternal: true })).open(uri, { openExternal: true });
                     }
@@ -386,7 +385,7 @@ export class KernelPickerMRUStrategy extends NotebookKernelQuickPickServiceImpl
             } else if (isSourcePick(selectedKernelPickItem)) {
                 // selected explicitly, it should trigger the execution?
                 try {
-                    await selectedKernelPickItem.action.run();
+                    await selectedKernelPickItem.action.run(this.commandService);
                     return true;
                 } catch (ex) {
                     return false;
@@ -416,18 +415,22 @@ export class KernelPickerMRUStrategy extends NotebookKernelQuickPickServiceImpl
         return false;
     }
 
+    private isUri(value: string): boolean {
+        return /^(?<scheme>\w[\w\d+.-]*):/.test(value);
+    }
+
     private async calculateKernelSources(editor: NotebookModel): Promise<QuickPickInput<KernelQuickPickItem>[]> {
         const notebook: NotebookModel = editor;
 
         const actions = await this.notebookKernelService.getKernelSourceActionsFromProviders(notebook);
         const matchResult = this.getMatchingResult(notebook);
 
-        const others = matchResult.all.filter(item => item.extension !== JUPYTER_EXTENSION_ID);
+        const others = matchResult.all.filter(item => item.extensionId !== JUPYTER_EXTENSION_ID);
         const quickPickItems: QuickPickInput<KernelQuickPickItem>[] = [];
 
         // group controllers by extension
-        for (const group of ArrayUtils.groupBy(others, (a, b) => a.extension === b.extension ? 0 : 1)) {
-            const source = group[0].extension;
+        for (const group of ArrayUtils.groupBy(others, (a, b) => a.extensionId === b.extensionId ? 0 : 1)) {
+            const source = group[0].extensionId;
             if (group.length > 1) {
                 quickPickItems.push({
                     label: source,

package/src/browser/service/notebook-kernel-service.ts

@@ -18,7 +18,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Command, CommandRegistry, Disposable, Emitter, Event, URI } from '@theia/core';
+import { Command, CommandService, Disposable, Emitter, Event, URI } from '@theia/core';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { StorageService } from '@theia/core/lib/browser';
 import { NotebookKernelSourceAction } from '../../common';
@@ -51,11 +51,8 @@ export interface NotebookKernel {
     readonly id: string;
     readonly viewType: string;
     readonly onDidChange: Event<Readonly<NotebookKernelChangeEvent>>;
-    readonly extension: string;
-
-    readonly localResourceRoot: URI;
-    readonly preloadUris: URI[];
-    readonly preloadProvides: string[];
+    // ID of the extension providing this kernel
+    readonly extensionId: string;
 
     label: string;
     description?: string;
@@ -78,24 +75,20 @@ export interface INotebookProxyKernelChangeEvent extends NotebookKernelChangeEve
     connectionState?: true;
 }
 
-export interface NotebookKernelDetectionTask {
-    readonly notebookType: string;
-}
-
 export interface NotebookTextModelLike { uri: URI; viewType: string }
 
 class KernelInfo {
 
-    private static logicClock = 0;
+    private static instanceCounter = 0;
 
+    score: number;
     readonly kernel: NotebookKernel;
-    public score: number;
-    readonly time: number;
+    readonly handle: number;
 
     constructor(kernel: NotebookKernel) {
         this.kernel = kernel;
         this.score = -1;
-        this.time = KernelInfo.logicClock++;
+        this.handle = KernelInfo.instanceCounter++;
     }
 }
 
@@ -116,27 +109,25 @@ export class SourceCommand implements Disposable {
     readonly onDidChangeState = this.onDidChangeStateEmitter.event;
 
     constructor(
-        readonly commandRegistry: CommandRegistry,
         readonly command: Command,
         readonly model: NotebookTextModelLike,
-        readonly isPrimary: boolean
     ) { }
 
-    async run(): Promise<void> {
+    async run(commandService: CommandService): Promise<void> {
         if (this.execution) {
             return this.execution;
         }
 
-        this.execution = this.runCommand();
+        this.execution = this.runCommand(commandService);
         this.onDidChangeStateEmitter.fire();
         await this.execution;
         this.execution = undefined;
         this.onDidChangeStateEmitter.fire();
     }
 
-    private async runCommand(): Promise<void> {
+    private async runCommand(commandService: CommandService): Promise<void> {
         try {
-            await this.commandRegistry.executeCommand(this.command.id, {
+            await commandService.executeCommand(this.command.id, {
                 uri: this.model.uri,
             });
 
@@ -165,7 +156,7 @@ export class NotebookKernelService implements Disposable {
 
     private notebookBindings: { [key: string]: string } = {};
 
-    private readonly kernelDetectionTasks = new Map<string, NotebookKernelDetectionTask[]>();
+    private readonly kernelDetectionTasks = new Map<string, string[]>();
     private readonly onDidChangeKernelDetectionTasksEmitter = new Emitter<string>();
     readonly onDidChangeKernelDetectionTasks = this.onDidChangeKernelDetectionTasksEmitter.event;
 
@@ -196,7 +187,7 @@ export class NotebookKernelService implements Disposable {
 
     registerKernel(kernel: NotebookKernel): Disposable {
         if (this.kernels.has(kernel.id)) {
-            throw new Error(`NOTEBOOK CONTROLLER with id '${kernel.id}' already exists`);
+            throw new Error(`Notebook Controller with id '${kernel.id}' already exists`);
         }
 
         this.kernels.set(kernel.id, new KernelInfo(kernel));
@@ -215,6 +206,15 @@ export class NotebookKernelService implements Disposable {
         });
     }
 
+    /**
+     * Helps to find the best matching kernel for a notebook.
+     * @param notebook notebook to get the matching kernel for
+     * @returns and object containing:
+     *  all kernels sorted to match the notebook best first (affinity ascending, score descending, label))
+     *  the selected kernel (if any)
+     *  specific suggested kernels (if any)
+     *  hidden kernels (if any)
+     */
     getMatchingKernel(notebook: NotebookTextModelLike): NotebookKernelMatchResult {
         const kernels: { kernel: NotebookKernel; instanceAffinity: number; score: number }[] = [];
         for (const info of this.kernels.values()) {
@@ -269,10 +269,10 @@ export class NotebookKernelService implements Disposable {
     }
 
     private static score(kernel: NotebookKernel, notebook: NotebookTextModelLike): number {
-        if (kernel.viewType === '*') {
-            return 5;
-        } else if (kernel.viewType === notebook.viewType) {
+        if (kernel.viewType === notebook.viewType) {
             return 10;
+        } else if (kernel.viewType === '*') {
+            return 5;
         } else {
             return 0;
         }
@@ -295,15 +295,14 @@ export class NotebookKernelService implements Disposable {
         }
     }
 
-    registerNotebookKernelDetectionTask(task: NotebookKernelDetectionTask): Disposable {
-        const notebookType = task.notebookType;
+    registerNotebookKernelDetectionTask(notebookType: string): Disposable {
         const all = this.kernelDetectionTasks.get(notebookType) ?? [];
-        all.push(task);
+        all.push(notebookType);
         this.kernelDetectionTasks.set(notebookType, all);
         this.onDidChangeKernelDetectionTasksEmitter.fire(notebookType);
         return Disposable.create(() => {
             const allTasks = this.kernelDetectionTasks.get(notebookType) ?? [];
-            const taskIndex = allTasks.indexOf(task);
+            const taskIndex = allTasks.indexOf(notebookType);
             if (taskIndex >= 0) {
                 allTasks.splice(taskIndex, 1);
                 this.kernelDetectionTasks.set(notebookType, allTasks);
@@ -312,7 +311,7 @@ export class NotebookKernelService implements Disposable {
         });
     }
 
-    getKernelDetectionTasks(notebook: NotebookTextModelLike): NotebookKernelDetectionTask[] {
+    getKernelDetectionTasks(notebook: NotebookTextModelLike): string[] {
         return this.kernelDetectionTasks.get(notebook.viewType) ?? [];
     }