chore(vscode): update to 1.55.2

lib/vscode/src/vs/workbench/api/browser/mainThreadCLICommands.ts

@@ -15,12 +15,11 @@ import { getExtensionId } from 'vs/platform/extensionManagement/common/extension
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
 import { ILabelService } from 'vs/platform/label/common/label';
-import { ILocalizationsService } from 'vs/platform/localizations/common/localizations';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { IProductService } from 'vs/platform/product/common/productService';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { IExtensionManagementServerService } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
-import { canExecuteOnWorkspace } from 'vs/workbench/services/extensions/common/extensionsUtil';
+import { ExtensionKindController } from 'vs/workbench/services/extensions/common/extensionsUtil';
 import { IExtensionManifest } from 'vs/workbench/workbench.web.api';
 
 
@@ -78,19 +77,22 @@ class RemoteExtensionCLIManagementService extends ExtensionManagementCLIService
 
 	private _location: string | undefined;
 
+	private readonly _extensionKindController: ExtensionKindController;
+
 	constructor(
 		@IExtensionManagementService extensionManagementService: IExtensionManagementService,
-		@IProductService private readonly productService: IProductService,
-		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IProductService productService: IProductService,
+		@IConfigurationService configurationService: IConfigurationService,
 		@IExtensionGalleryService extensionGalleryService: IExtensionGalleryService,
-		@ILocalizationsService localizationsService: ILocalizationsService,
 		@ILabelService labelService: ILabelService,
 		@IWorkbenchEnvironmentService envService: IWorkbenchEnvironmentService
 	) {
-		super(extensionManagementService, extensionGalleryService, localizationsService);
+		super(extensionManagementService, extensionGalleryService);
 
 		const remoteAuthority = envService.remoteAuthority;
 		this._location = remoteAuthority ? labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority) : undefined;
+
+		this._extensionKindController = new ExtensionKindController(productService, configurationService);
 	}
 
 	protected get location(): string | undefined {
@@ -98,7 +100,7 @@ class RemoteExtensionCLIManagementService extends ExtensionManagementCLIService
 	}
 
 	protected validateExtensionKind(manifest: IExtensionManifest, output: CLIOutput): boolean {
-		if (!canExecuteOnWorkspace(manifest, this.productService, this.configurationService)) {
+		if (!this._extensionKindController.canExecuteOnWorkspace(manifest)) {
 			output.log(localize('cannot be installed', "Cannot install the '{0}' extension because it is declared to not run in this setup.", getExtensionId(manifest.publisher, manifest.name)));
 			return false;
 		}

lib/vscode/src/vs/workbench/api/browser/mainThreadCodeInsets.ts

@@ -3,16 +3,16 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { UriComponents, URI } from 'vs/base/common/uri';
-import * as modes from 'vs/editor/common/modes';
-import { MainContext, MainThreadEditorInsetsShape, IExtHostContext, ExtHostEditorInsetsShape, ExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
-import { extHostNamedCustomer } from '../common/extHostCustomers';
-import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
-import { IWebviewService, WebviewElement } from 'vs/workbench/contrib/webview/browser/webview';
 import { DisposableStore } from 'vs/base/common/lifecycle';
-import { IActiveCodeEditor, IViewZone } from 'vs/editor/browser/editorBrowser';
-import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { isEqual } from 'vs/base/common/resources';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IActiveCodeEditor, IViewZone } from 'vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { reviveWebviewContentOptions } from 'vs/workbench/api/browser/mainThreadWebviews';
+import { ExtHostContext, ExtHostEditorInsetsShape, IExtHostContext, IWebviewOptions, MainContext, MainThreadEditorInsetsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IWebviewService, WebviewElement } from 'vs/workbench/contrib/webview/browser/webview';
+import { extHostNamedCustomer } from '../common/extHostCustomers';
 
 // todo@jrieken move these things back into something like contrib/insets
 class EditorWebviewZone implements IViewZone {
@@ -70,7 +70,7 @@ export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
 		this._disposables.dispose();
 	}
 
-	async $createEditorInset(handle: number, id: string, uri: UriComponents, line: number, height: number, options: modes.IWebviewOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): Promise<void> {
+	async $createEditorInset(handle: number, id: string, uri: UriComponents, line: number, height: number, options: IWebviewOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): Promise<void> {
 
 		let editor: IActiveCodeEditor | undefined;
 		id = id.substr(0, id.indexOf(',')); //todo@jrieken HACK
@@ -91,10 +91,7 @@ export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
 
 		const webview = this._webviewService.createWebviewElement('' + handle, {
 			enableFindWidget: false,
-		}, {
-			allowScripts: options.enableScripts,
-			localResourceRoots: options.localResourceRoots ? options.localResourceRoots.map(uri => URI.revive(uri)) : undefined
-		}, { id: extensionId, location: URI.revive(extensionLocation) });
+		}, reviveWebviewContentOptions(options), { id: extensionId, location: URI.revive(extensionLocation) });
 
 		const webviewZone = new EditorWebviewZone(editor, line, height, webview);
 
@@ -117,7 +114,6 @@ export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
 		const inset = this.getInset(handle);
 		this._insets.delete(handle);
 		inset.dispose();
-
 	}
 
 	$setHtml(handle: number, value: string): void {
@@ -125,12 +121,9 @@ export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
 		inset.webview.html = value;
 	}
 
-	$setOptions(handle: number, options: modes.IWebviewOptions): void {
+	$setOptions(handle: number, options: IWebviewOptions): void {
 		const inset = this.getInset(handle);
-		inset.webview.contentOptions = {
-			...options,
-			localResourceRoots: options.localResourceRoots?.map(components => URI.from(components)),
-		};
+		inset.webview.contentOptions = reviveWebviewContentOptions(options);
 	}
 
 	async $postMessage(handle: number, value: any): Promise<boolean> {

lib/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.ts

@@ -4,7 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { multibyteAwareBtoa } from 'vs/base/browser/dom';
-import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
+import { CancelablePromise, createCancelablePromise, timeout } from 'vs/base/common/async';
+import { VSBuffer } from 'vs/base/common/buffer';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { isPromiseCanceledError, onUnexpectedError } from 'vs/base/common/errors';
 import { Emitter, Event } from 'vs/base/common/event';
@@ -13,10 +14,9 @@ import { Schemas } from 'vs/base/common/network';
 import { basename } from 'vs/base/common/path';
 import { isEqual, isEqualOrParent, toLocalResource } from 'vs/base/common/resources';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import * as modes from 'vs/editor/common/modes';
 import { localize } from 'vs/nls';
 import { IFileDialogService } from 'vs/platform/dialogs/common/dialogs';
-import { IFileService } from 'vs/platform/files/common/files';
+import { FileChangesEvent, FileChangeType, FileSystemProviderCapabilities, IFileService } from 'vs/platform/files/common/files';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ILabelService } from 'vs/platform/label/common/label';
 import { IUndoRedoService, UndoRedoElementType } from 'vs/platform/undoRedo/common/undoRedo';
@@ -99,11 +99,11 @@ export class MainThreadCustomEditors extends Disposable implements extHostProtoc
 		this._editorProviders.clear();
 	}
 
-	public $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions, capabilities: extHostProtocol.CustomTextEditorCapabilities): void {
+	public $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, capabilities: extHostProtocol.CustomTextEditorCapabilities): void {
 		this.registerEditorProvider(CustomEditorModelType.Text, reviveWebviewExtension(extensionData), viewType, options, capabilities, true);
 	}
 
-	public $registerCustomEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: modes.IWebviewPanelOptions, supportsMultipleEditorsPerDocument: boolean): void {
+	public $registerCustomEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, supportsMultipleEditorsPerDocument: boolean): void {
 		this.registerEditorProvider(CustomEditorModelType.Custom, reviveWebviewExtension(extensionData), viewType, options, {}, supportsMultipleEditorsPerDocument);
 	}
 
@@ -111,7 +111,7 @@ export class MainThreadCustomEditors extends Disposable implements extHostProtoc
 		modelType: CustomEditorModelType,
 		extension: WebviewExtensionDescription,
 		viewType: string,
-		options: modes.IWebviewPanelOptions,
+		options: extHostProtocol.IWebviewPanelOptions,
 		capabilities: extHostProtocol.CustomTextEditorCapabilities,
 		supportsMultipleEditorsPerDocument: boolean,
 	): void {
@@ -176,7 +176,11 @@ export class MainThreadCustomEditors extends Disposable implements extHostProtoc
 				}
 
 				try {
-					await this._proxyCustomEditors.$resolveWebviewEditor(resource, handle, viewType, webviewInput.getTitle(), editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), webviewInput.webview.options, cancellation);
+					await this._proxyCustomEditors.$resolveWebviewEditor(resource, handle, viewType, {
+						title: webviewInput.getTitle(),
+						webviewOptions: webviewInput.webview.contentOptions,
+						panelOptions: webviewInput.webview.options,
+					}, editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), cancellation);
 				} catch (error) {
 					onUnexpectedError(error);
 					webviewInput.webview.html = this.mainThreadWebview.getWebviewResolvedFailedContent(viewType);
@@ -274,6 +278,8 @@ namespace HotExitState {
 
 class MainThreadCustomEditorModel extends Disposable implements ICustomEditorModel, IWorkingCopy {
 
+	#isDisposed = false;
+
 	private _fromBackup: boolean = false;
 	private _hotExitState: HotExitState.State = HotExitState.Allowed;
 	private _backupId: string | undefined;
@@ -282,9 +288,13 @@ class MainThreadCustomEditorModel extends Disposable implements ICustomEditorMod
 	private _savePoint: number = -1;
 	private readonly _edits: Array<number> = [];
 	private _isDirtyFromContentChange = false;
+	private _inOrphaned = false;
 
 	private _ongoingSave?: CancelablePromise<void>;
 
+	private readonly _onDidChangeOrphaned = this._register(new Emitter<void>());
+	public readonly onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+
 	public static async create(
 		instantiationService: IInstantiationService,
 		proxy: extHostProtocol.ExtHostCustomEditorsShape,
@@ -294,8 +304,13 @@ class MainThreadCustomEditorModel extends Disposable implements ICustomEditorMod
 		getEditors: () => CustomEditorInput[],
 		cancellation: CancellationToken,
 		_backupFileService: IBackupFileService,
-	) {
-		const { editable } = await proxy.$createCustomDocument(resource, viewType, options.backupId, cancellation);
+	): Promise<MainThreadCustomEditorModel> {
+		const editors = getEditors();
+		let untitledDocumentData: VSBuffer | undefined;
+		if (editors.length !== 0) {
+			untitledDocumentData = editors[0].untitledDocumentData;
+		}
+		const { editable } = await proxy.$createCustomDocument(resource, viewType, options.backupId, untitledDocumentData, cancellation);
 		return instantiationService.createInstance(MainThreadCustomEditorModel, proxy, viewType, resource, !!options.backupId, editable, getEditors);
 	}
 
@@ -321,6 +336,8 @@ class MainThreadCustomEditorModel extends Disposable implements ICustomEditorMod
 		if (_editable) {
 			this._register(workingCopyService.registerWorkingCopy(this));
 		}
+
+		this._register(_fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
 	}
 
 	get editorResource() {
@@ -328,10 +345,14 @@ class MainThreadCustomEditorModel extends Disposable implements ICustomEditorMod
 	}
 
 	dispose() {
+		this.#isDisposed = true;
+
 		if (this._editable) {
 			this._undoService.removeElements(this._editorResource);
 		}
+
 		this._proxy.$disposeCustomDocument(this._editorResource, this._viewType);
+
 		super.dispose();
 	}
 
@@ -371,6 +392,10 @@ class MainThreadCustomEditorModel extends Disposable implements ICustomEditorMod
 		return this._fromBackup;
 	}
 
+	public isOrphaned(): boolean {
+		return this._inOrphaned;
+	}
+
 	private isUntitled() {
 		return this._editorResource.scheme === Schemas.untitled;
 	}
@@ -383,8 +408,64 @@ class MainThreadCustomEditorModel extends Disposable implements ICustomEditorMod
 
 	//#endregion
 
-	public isReadonly() {
-		return !this._editable;
+	private async onDidFilesChange(e: FileChangesEvent): Promise<void> {
+		let fileEventImpactsModel = false;
+		let newInOrphanModeGuess: boolean | undefined;
+
+		// If we are currently orphaned, we check if the model file was added back
+		if (this._inOrphaned) {
+			const modelFileAdded = e.contains(this.editorResource, FileChangeType.ADDED);
+			if (modelFileAdded) {
+				newInOrphanModeGuess = false;
+				fileEventImpactsModel = true;
+			}
+		}
+
+		// Otherwise we check if the model file was deleted
+		else {
+			const modelFileDeleted = e.contains(this.editorResource, FileChangeType.DELETED);
+			if (modelFileDeleted) {
+				newInOrphanModeGuess = true;
+				fileEventImpactsModel = true;
+			}
+		}
+
+		if (fileEventImpactsModel && this._inOrphaned !== newInOrphanModeGuess) {
+			let newInOrphanModeValidated: boolean = false;
+			if (newInOrphanModeGuess) {
+				// We have received reports of users seeing delete events even though the file still
+				// exists (network shares issue: https://github.com/microsoft/vscode/issues/13665).
+				// Since we do not want to mark the model as orphaned, we have to check if the
+				// file is really gone and not just a faulty file event.
+				await timeout(100);
+
+				if (this.#isDisposed) {
+					newInOrphanModeValidated = true;
+				} else {
+					const exists = await this._fileService.exists(this.editorResource);
+					newInOrphanModeValidated = !exists;
+				}
+			}
+
+			if (this._inOrphaned !== newInOrphanModeValidated && !this.#isDisposed) {
+				this.setOrphaned(newInOrphanModeValidated);
+			}
+		}
+	}
+
+	private setOrphaned(orphaned: boolean): void {
+		if (this._inOrphaned !== orphaned) {
+			this._inOrphaned = orphaned;
+			this._onDidChangeOrphaned.fire();
+		}
+	}
+
+	public isEditable(): boolean {
+		return this._editable;
+	}
+
+	public isOnReadonlyFileSystem(): boolean {
+		return this._fileService.hasCapability(this.editorResource, FileSystemProviderCapabilities.Readonly);
 	}
 
 	public get viewType() {

lib/vscode/src/vs/workbench/api/browser/mainThreadDebugService.ts

@@ -142,7 +142,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 			} else if (dto.type === 'function') {
 				this.debugService.addFunctionBreakpoint(dto.functionName, dto.id);
 			} else if (dto.type === 'data') {
-				this.debugService.addDataBreakpoint(dto.label, dto.dataId, dto.canPersist, dto.accessTypes);
+				this.debugService.addDataBreakpoint(dto.label, dto.dataId, dto.canPersist, dto.accessTypes, dto.accessType);
 			}
 		}
 		return Promise.resolve();

lib/vscode/src/vs/workbench/api/browser/mainThreadDocuments.ts

@@ -202,12 +202,12 @@ export class MainThreadDocuments extends Disposable implements MainThreadDocumen
 	}
 
 	private _onModelModeChanged(event: { model: ITextModel; oldModeId: string; }): void {
-		let { model, oldModeId } = event;
+		let { model } = event;
 		const modelUrl = model.uri;
 		if (!this._modelIsSynced.has(modelUrl.toString())) {
 			return;
 		}
-		this._proxy.$acceptModelModeChanged(model.uri, oldModeId, model.getLanguageIdentifier().language);
+		this._proxy.$acceptModelModeChanged(model.uri, model.getLanguageIdentifier().language);
 	}
 
 	private _onModelRemoved(modelUrl: URI): void {

lib/vscode/src/vs/workbench/api/browser/mainThreadExtensionService.ts

@@ -15,7 +15,7 @@ import { Action } from 'vs/base/common/actions';
 import { IWorkbenchExtensionEnablementService, EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IHostService } from 'vs/workbench/services/host/browser/host';
-import { IExtensionsWorkbenchService } from 'vs/workbench/contrib/extensions/common/extensions';
+import { IExtension, IExtensionsWorkbenchService } from 'vs/workbench/contrib/extensions/common/extensions';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { ILocalExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { ExtensionActivationReason } from 'vs/workbench/api/common/extHostExtensionActivator';
@@ -106,26 +106,26 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 
 	private async _handleMissingNotInstalledDependency(extension: IExtensionDescription, missingDependency: string): Promise<void> {
 		const extName = extension.displayName || extension.name;
-		const dependencyExtension = (await this._extensionsWorkbenchService.queryGallery({ names: [missingDependency] }, CancellationToken.None)).firstPage[0];
+		let dependencyExtension: IExtension | null = null;
+		try {
+			dependencyExtension = (await this._extensionsWorkbenchService.queryGallery({ names: [missingDependency] }, CancellationToken.None)).firstPage[0];
+		} catch (err) {
+		}
 		if (dependencyExtension) {
 			this._notificationService.notify({
 				severity: Severity.Error,
 				message: localize('uninstalledDep', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not installed. Would you like to install the extension and reload the window?", extName, dependencyExtension.displayName),
 				actions: {
 					primary: [new Action('install', localize('install missing dep', "Install and Reload"), '', true,
-						() => this._extensionsWorkbenchService.install(dependencyExtension)
+						() => this._extensionsWorkbenchService.install(dependencyExtension!)
 							.then(() => this._hostService.reload(), e => this._notificationService.error(e)))]
 				}
 			});
 		} else {
-			this._notificationService.error(localize('unknownDep', "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension .", extName, missingDependency));
+			this._notificationService.error(localize('unknownDep', "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.", extName, missingDependency));
 		}
 	}
 
-	async $onExtensionHostExit(code: number): Promise<void> {
-		this._extensionService._onExtensionHostExit(code);
-	}
-
 	async $setPerformanceMarks(marks: PerformanceMark[]): Promise<void> {
 		if (this._extensionHostKind === ExtensionHostKind.LocalProcess) {
 			this._timerService.setPerformanceMarks('localExtHost', marks);

lib/vscode/src/vs/workbench/api/browser/mainThreadMessageService.ts

@@ -66,9 +66,12 @@ export class MainThreadMessageService implements MainThreadMessageServiceShape {
 				primaryActions.push(new MessageItemAction('_extension_message_handle_' + command.handle, command.title, command.handle));
 			});
 
-			let source: string | undefined;
+			let source: string | { label: string, id: string } | undefined;
 			if (extension) {
-				source = nls.localize('extensionSource', "{0} (Extension)", extension.displayName || extension.name);
+				source = {
+					label: nls.localize('extensionSource', "{0} (Extension)", extension.displayName || extension.name),
+					id: extension.identifier.value
+				};
 			}
 
 			if (!source) {

lib/vscode/src/vs/workbench/api/browser/mainThreadNotebook.ts

@@ -3,56 +3,54 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { VSBuffer } from 'vs/base/common/buffer';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { diffMaps, diffSets } from 'vs/base/common/collections';
 import { Emitter } from 'vs/base/common/event';
 import { IRelativePattern } from 'vs/base/common/glob';
-import { combinedDisposable, Disposable, DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { ResourceMap } from 'vs/base/common/map';
 import { Schemas } from 'vs/base/common/network';
 import { isEqual } from 'vs/base/common/resources';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { EditorActivation, ITextEditorOptions, EditorOverride } from 'vs/platform/editor/common/editor';
+import { EditorActivation, EditorOverride } from 'vs/platform/editor/common/editor';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vs/platform/log/common/log';
 import { BoundModelReferenceCollection } from 'vs/workbench/api/browser/mainThreadDocuments';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
-import { viewColumnToEditorGroup } from 'vs/workbench/common/editor';
-import { INotebookEditor } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { getNotebookEditorFromEditorPane, IActiveNotebookEditor, INotebookEditor, NotebookEditorOptions } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { NotebookEditorInput } from 'vs/workbench/contrib/notebook/browser/notebookEditorInput';
+import { INotebookEditorService } from 'vs/workbench/contrib/notebook/browser/notebookEditorService';
 import { NotebookCellTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
 import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel';
 import { INotebookCellStatusBarService } from 'vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
-import { ICellEditOperation, ICellRange, IEditor, IMainCellDto, INotebookDecorationRenderOptions, INotebookDocumentFilter, INotebookExclusiveDocumentFilter, INotebookKernel, NotebookCellsChangeType, TransientMetadata } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import { ICellEditOperation, ICellRange, IImmediateCellEditOperation, IMainCellDto, INotebookDecorationRenderOptions, INotebookDocumentFilter, INotebookExclusiveDocumentFilter, INotebookKernel, NotebookCellsChangeType, NotebookDataDto, TransientMetadata, TransientOptions } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import { INotebookEditorModelResolverService } from 'vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
 import { IMainNotebookController, INotebookService } from 'vs/workbench/contrib/notebook/common/notebookService';
-import { IEditorGroup, IEditorGroupsService, preferredSideBySideGroupDirection } from 'vs/workbench/services/editor/common/editorGroupsService';
-import { IEditorService, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
 import { IWorkingCopyService } from 'vs/workbench/services/workingCopy/common/workingCopyService';
 import { ExtHostContext, ExtHostNotebookShape, IExtHostContext, INotebookCellStatusBarEntryDto, INotebookDocumentsAndEditorsDelta, INotebookDocumentShowOptions, INotebookEditorAddData, INotebookModelAddedData, MainContext, MainThreadNotebookShape, NotebookEditorRevealType, NotebookExtensionDescription } from '../common/extHost.protocol';
 
-class DocumentAndEditorState {
-	static compute(before: DocumentAndEditorState | undefined, after: DocumentAndEditorState): INotebookDocumentsAndEditorsDelta {
+class NotebookAndEditorState {
+	static compute(before: NotebookAndEditorState | undefined, after: NotebookAndEditorState): INotebookDocumentsAndEditorsDelta {
 		if (!before) {
 			return {
-				addedDocuments: [...after.documents].map(DocumentAndEditorState._asModelAddData),
-				addedEditors: [...after.textEditors.values()].map(DocumentAndEditorState._asEditorAddData),
+				addedDocuments: [...after.documents].map(NotebookAndEditorState._asModelAddData),
+				addedEditors: [...after.textEditors.values()].map(NotebookAndEditorState._asEditorAddData),
 				visibleEditors: [...after.visibleEditors].map(editor => editor[0])
 			};
 		}
 		const documentDelta = diffSets(before.documents, after.documents);
 		const editorDelta = diffMaps(before.textEditors, after.textEditors);
-		const addedAPIEditors = editorDelta.added.map(DocumentAndEditorState._asEditorAddData);
+		const addedAPIEditors = editorDelta.added.map(NotebookAndEditorState._asEditorAddData);
 
 		const removedAPIEditors = editorDelta.removed.map(removed => removed.getId());
-
-		// const oldActiveEditor = before.activeEditor !== after.activeEditor ? before.activeEditor : undefined;
 		const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
-
 		const visibleEditorDelta = diffMaps(before.visibleEditors, after.visibleEditors);
 
 		return {
-			addedDocuments: documentDelta.added.map(DocumentAndEditorState._asModelAddData),
+			addedDocuments: documentDelta.added.map(NotebookAndEditorState._asModelAddData),
 			removedDocuments: documentDelta.removed.map(e => e.uri),
 			addedEditors: addedAPIEditors,
 			removedEditors: removedAPIEditors,
@@ -65,9 +63,9 @@ class DocumentAndEditorState {
 
 	constructor(
 		readonly documents: Set<NotebookTextModel>,
-		readonly textEditors: Map<string, IEditor>,
+		readonly textEditors: Map<string, IActiveNotebookEditor>,
 		readonly activeEditor: string | null | undefined,
-		readonly visibleEditors: Map<string, IEditor>
+		readonly visibleEditors: Map<string, IActiveNotebookEditor>
 	) {
 		//
 	}
@@ -87,71 +85,72 @@ class DocumentAndEditorState {
 				cellKind: cell.cellKind,
 				outputs: cell.outputs,
 				metadata: cell.metadata
-			})),
-			contentOptions: e.transientOptions,
+			}))
 		};
 	}
 
-	private static _asEditorAddData(add: IEditor): INotebookEditorAddData {
+	private static _asEditorAddData(add: IActiveNotebookEditor): INotebookEditorAddData {
 		return {
 			id: add.getId(),
-			documentUri: add.uri!,
+			documentUri: add.viewModel.uri,
 			selections: add.getSelections(),
-			visibleRanges: add.visibleRanges
+			visibleRanges: add.visibleRanges,
+			viewColumn: undefined
 		};
 	}
 }
 
 @extHostNamedCustomer(MainContext.MainThreadNotebook)
-export class MainThreadNotebooks extends Disposable implements MainThreadNotebookShape {
+export class MainThreadNotebooks implements MainThreadNotebookShape {
+
+	private readonly _disposables = new DisposableStore();
 
 	private readonly _proxy: ExtHostNotebookShape;
 	private readonly _notebookProviders = new Map<string, { controller: IMainNotebookController, disposable: IDisposable }>();
+	private readonly _notebookSerializer = new Map<number, IDisposable>();
 	private readonly _notebookKernelProviders = new Map<number, { extension: NotebookExtensionDescription, emitter: Emitter<URI | undefined>, provider: IDisposable }>();
-	private readonly _toDisposeOnEditorRemove = new Map<string, IDisposable>();
-	private readonly _editorEventListenersMapping: Map<string, DisposableStore> = new Map();
-	private readonly _documentEventListenersMapping: ResourceMap<DisposableStore> = new ResourceMap();
-	private readonly _cellStatusBarEntries: Map<number, IDisposable> = new Map();
+	private readonly _editorEventListenersMapping = new Map<string, DisposableStore>();
+	private readonly _documentEventListenersMapping = new ResourceMap<DisposableStore>();
+	private readonly _cellStatusBarEntries = new Map<number, IDisposable>();
 	private readonly _modelReferenceCollection: BoundModelReferenceCollection;
 
-	private _currentState?: DocumentAndEditorState;
+	private _currentState?: NotebookAndEditorState;
 
 	constructor(
 		extHostContext: IExtHostContext,
+		@IInstantiationService private readonly _instantiationService: IInstantiationService,
 		@IWorkingCopyService private readonly _workingCopyService: IWorkingCopyService,
-		@INotebookService private _notebookService: INotebookService,
-		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@INotebookService private readonly _notebookService: INotebookService,
+		@INotebookEditorService private readonly _notebookEditorService: INotebookEditorService,
 		@IEditorService private readonly _editorService: IEditorService,
-		@IEditorGroupsService private readonly _editorGroupsService: IEditorGroupsService,
 		@ILogService private readonly _logService: ILogService,
 		@INotebookCellStatusBarService private readonly _cellStatusBarService: INotebookCellStatusBarService,
-		@INotebookEditorModelResolverService private readonly _notebookModelResolverService: INotebookEditorModelResolverService,
+		@INotebookEditorModelResolverService private readonly _notebookEditorModelResolverService: INotebookEditorModelResolverService,
 		@IUriIdentityService private readonly _uriIdentityService: IUriIdentityService
 	) {
-		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostNotebook);
 		this._modelReferenceCollection = new BoundModelReferenceCollection(this._uriIdentityService.extUri);
-		this.registerListeners();
+		this._registerListeners();
 	}
 
 	dispose(): void {
-		super.dispose();
+		this._disposables.dispose();
 
 		this._modelReferenceCollection.dispose();
 
 		// remove all notebook providers
-		for (let item of this._notebookProviders.values()) {
+		for (const item of this._notebookProviders.values()) {
 			item.disposable.dispose();
 		}
 
 		// remove all kernel providers
-		for (let item of this._notebookKernelProviders.values()) {
+		for (const item of this._notebookKernelProviders.values()) {
 			item.emitter.dispose();
 			item.provider.dispose();
 		}
+		dispose(this._notebookSerializer.values());
 		dispose(this._editorEventListenersMapping.values());
 		dispose(this._documentEventListenersMapping.values());
-		dispose(this._toDisposeOnEditorRemove.values());
 		dispose(this._cellStatusBarEntries.values());
 	}
 
@@ -160,51 +159,27 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		if (!textModel) {
 			return false;
 		}
-		return textModel.applyEdits(modelVersionId, cellEdits, true, undefined, () => undefined, undefined);
+		if (textModel.versionId !== modelVersionId) {
+			return false;
+		}
+		return textModel.applyEdits(cellEdits, true, undefined, () => undefined, undefined);
 	}
 
-	private _isDeltaEmpty(delta: INotebookDocumentsAndEditorsDelta) {
-		if (delta.addedDocuments !== undefined && delta.addedDocuments.length > 0) {
-			return false;
+	async $applyEdits(resource: UriComponents, cellEdits: IImmediateCellEditOperation[], computeUndoRedo = true): Promise<void> {
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		if (!textModel) {
+			throw new Error(`Can't apply edits to unknown notebook model: ${resource}`);
 		}
 
-		if (delta.removedDocuments !== undefined && delta.removedDocuments.length > 0) {
-			return false;
-		}
-
-		if (delta.addedEditors !== undefined && delta.addedEditors.length > 0) {
-			return false;
-		}
-
-		if (delta.removedEditors !== undefined && delta.removedEditors.length > 0) {
-			return false;
-		}
-
-		if (delta.visibleEditors !== undefined && delta.visibleEditors.length > 0) {
-			return false;
-		}
-
-		if (delta.newActiveEditor !== undefined) {
-			return false;
-		}
-
-		return true;
+		textModel.applyEdits(cellEdits, true, undefined, () => undefined, undefined, computeUndoRedo);
 	}
 
-	private _emitDelta(delta: INotebookDocumentsAndEditorsDelta) {
-		if (this._isDeltaEmpty(delta)) {
-			return;
-		}
-
-		return this._proxy.$acceptDocumentAndEditorsDelta(delta);
-	}
-
-	registerListeners() {
+	private _registerListeners(): void {
 
 		// forward changes to dirty state
 		// todo@rebornix todo@mjbvz this seem way too complicated... is there an easy way to
 		// the actual resource from a working copy?
-		this._register(this._workingCopyService.onDidChangeDirty(e => {
+		this._disposables.add(this._workingCopyService.onDidChangeDirty(e => {
 			if (e.resource.scheme !== Schemas.vscodeNotebook) {
 				return;
 			}
@@ -216,16 +191,13 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			}
 		}));
 
-		this._notebookService.listNotebookEditors().forEach((e) => {
-			this._addNotebookEditor(e);
-		});
 
-		this._register(this._notebookService.onDidChangeActiveEditor(e => {
+		this._disposables.add(this._editorService.onDidActiveEditorChange(e => {
 			this._updateState();
 		}));
 
-		this._register(this._notebookService.onDidChangeVisibleEditors(e => {
-			if (this._notebookProviders.size > 0) {
+		this._disposables.add(this._editorService.onDidVisibleEditorsChange(e => {
+			if (this._notebookProviders.size > 0) { // TODO@rebornix propably wrong, what about providers from another host
 				if (!this._currentState) {
 					// no current state means we didn't even create editors in ext host yet.
 					return;
@@ -236,38 +208,49 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			}
 		}));
 
-		const notebookEditorAddedHandler = (editor: IEditor) => {
-			if (!this._editorEventListenersMapping.has(editor.getId())) {
-				const disposableStore = new DisposableStore();
-				disposableStore.add(editor.onDidChangeVisibleRanges(() => {
-					this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges }, selections: null });
-				}));
-
-				disposableStore.add(editor.onDidChangeSelection(() => {
-					this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: null, selections: { selections: editor.getSelections() } });
-				}));
-
-				this._editorEventListenersMapping.set(editor.getId(), disposableStore);
+		const handleNotebookEditorAdded = (editor: INotebookEditor) => {
+			if (this._editorEventListenersMapping.has(editor.getId())) {
+				//todo@jrieken a bug when this happens?
+				return;
 			}
+			const disposableStore = new DisposableStore();
+			disposableStore.add(editor.onDidChangeVisibleRanges(() => {
+				this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges } });
+			}));
+
+			disposableStore.add(editor.onDidChangeSelection(() => {
+				this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { selections: { selections: editor.getSelections() } });
+			}));
+
+			disposableStore.add(editor.onDidChangeKernel(() => {
+				if (!editor.hasModel()) {
+					return;
+				}
+				this._proxy.$acceptNotebookActiveKernelChange({
+					uri: editor.viewModel.uri,
+					providerHandle: editor.activeKernel?.providerHandle,
+					kernelFriendlyId: editor.activeKernel?.friendlyId
+				});
+			}));
+
+			disposableStore.add(editor.onDidChangeModel(() => this._updateState()));
+			disposableStore.add(editor.onDidFocusEditorWidget(() => this._updateState(editor)));
+
+			this._editorEventListenersMapping.set(editor.getId(), disposableStore);
+
+			const activeNotebookEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+			this._updateState(activeNotebookEditor);
 		};
 
-		this._register(this._notebookService.onNotebookEditorAdd(editor => {
-			notebookEditorAddedHandler(editor);
-			this._addNotebookEditor(editor);
+		this._notebookEditorService.listNotebookEditors().forEach(handleNotebookEditorAdded);
+		this._disposables.add(this._notebookEditorService.onDidAddNotebookEditor(handleNotebookEditorAdded));
+
+		this._disposables.add(this._notebookEditorService.onDidRemoveNotebookEditor(editor => {
+			this._editorEventListenersMapping.get(editor.getId())?.dispose();
+			this._editorEventListenersMapping.delete(editor.getId());
+			this._updateState();
 		}));
 
-		this._register(this._notebookService.onNotebookEditorsRemove(editors => {
-			this._removeNotebookEditor(editors);
-
-			editors.forEach(editor => {
-				this._editorEventListenersMapping.get(editor.getId())?.dispose();
-				this._editorEventListenersMapping.delete(editor.getId());
-			});
-		}));
-
-		this._notebookService.listNotebookEditors().forEach(editor => {
-			notebookEditorAddedHandler(editor);
-		});
 
 		const cellToDto = (cell: NotebookCellTextModel): IMainCellDto => {
 			return {
@@ -283,157 +266,136 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		};
 
 
-		const notebookDocumentAddedHandler = (textModel: NotebookTextModel) => {
-			if (!this._documentEventListenersMapping.has(textModel.uri)) {
-				const disposableStore = new DisposableStore();
-				disposableStore.add(textModel!.onDidChangeContent(event => {
-					const dto = event.rawEvents.map(e => {
-						const data =
-							e.kind === NotebookCellsChangeType.ModelChange || e.kind === NotebookCellsChangeType.Initialize
-								? {
-									kind: e.kind,
-									versionId: event.versionId,
-									changes: e.changes.map(diff => [diff[0], diff[1], diff[2].map(cell => cellToDto(cell as NotebookCellTextModel))] as [number, number, IMainCellDto[]])
-								}
-								: (
-									e.kind === NotebookCellsChangeType.Move
-										? {
-											kind: e.kind,
-											index: e.index,
-											length: e.length,
-											newIdx: e.newIdx,
-											versionId: event.versionId,
-											cells: e.cells.map(cell => cellToDto(cell as NotebookCellTextModel))
-										}
-										: e
-								);
-
-						return data;
-					});
-
-					/**
-					 * TODO@rebornix, @jrieken
-					 * When a document is modified, it will trigger onDidChangeContent events.
-					 * The first event listener is this one, which doesn't know if the text model is dirty or not. It can ask `workingCopyService` but get the wrong result
-					 * The second event listener is `NotebookEditorModel`, which will then set `isDirty` to `true`.
-					 * Since `e.transient` decides if the model should be dirty or not, we will use the same logic here.
-					 */
-					const hasNonTransientEvent = event.rawEvents.find(e => !e.transient);
-					this._proxy.$acceptModelChanged(textModel.uri, {
-						rawEvents: dto,
-						versionId: event.versionId
-					}, !!hasNonTransientEvent);
-
-					const hasDocumentMetadataChangeEvent = event.rawEvents.find(e => e.kind === NotebookCellsChangeType.ChangeDocumentMetadata);
-					if (!!hasDocumentMetadataChangeEvent) {
-						this._proxy.$acceptDocumentPropertiesChanged(textModel.uri, { metadata: textModel.metadata });
-					}
-				}));
-				this._documentEventListenersMapping.set(textModel!.uri, disposableStore);
+		const handleNotebookDocumentAdded = (textModel: NotebookTextModel) => {
+			if (this._documentEventListenersMapping.has(textModel.uri)) {
+				//todo@jrieken a bug when this happens?
+				return;
 			}
+			const disposableStore = new DisposableStore();
+			disposableStore.add(textModel!.onDidChangeContent(event => {
+				const dto = event.rawEvents.map(e => {
+					const data =
+						e.kind === NotebookCellsChangeType.ModelChange || e.kind === NotebookCellsChangeType.Initialize
+							? {
+								kind: e.kind,
+								versionId: event.versionId,
+								changes: e.changes.map(diff => [diff[0], diff[1], diff[2].map(cell => cellToDto(cell as NotebookCellTextModel))] as [number, number, IMainCellDto[]])
+							}
+							: (
+								e.kind === NotebookCellsChangeType.Move
+									? {
+										kind: e.kind,
+										index: e.index,
+										length: e.length,
+										newIdx: e.newIdx,
+										versionId: event.versionId,
+										cells: e.cells.map(cell => cellToDto(cell as NotebookCellTextModel))
+									}
+									: e
+							);
+
+					return data;
+				});
+
+				/**
+				 * TODO@rebornix, @jrieken
+				 * When a document is modified, it will trigger onDidChangeContent events.
+				 * The first event listener is this one, which doesn't know if the text model is dirty or not. It can ask `workingCopyService` but get the wrong result
+				 * The second event listener is `NotebookEditorModel`, which will then set `isDirty` to `true`.
+				 * Since `e.transient` decides if the model should be dirty or not, we will use the same logic here.
+				 */
+				const hasNonTransientEvent = event.rawEvents.find(e => !e.transient);
+				this._proxy.$acceptModelChanged(textModel.uri, {
+					rawEvents: dto,
+					versionId: event.versionId
+				}, !!hasNonTransientEvent);
+
+				const hasDocumentMetadataChangeEvent = event.rawEvents.find(e => e.kind === NotebookCellsChangeType.ChangeDocumentMetadata);
+				if (!!hasDocumentMetadataChangeEvent) {
+					this._proxy.$acceptDocumentPropertiesChanged(textModel.uri, { metadata: textModel.metadata });
+				}
+			}));
+			this._documentEventListenersMapping.set(textModel!.uri, disposableStore);
 		};
 
-		this._notebookService.listNotebookDocuments().forEach(notebookDocumentAddedHandler);
-		this._register(this._notebookService.onDidAddNotebookDocument(document => {
-			notebookDocumentAddedHandler(document);
+		this._notebookService.listNotebookDocuments().forEach(handleNotebookDocumentAdded);
+		this._disposables.add(this._notebookService.onDidAddNotebookDocument(document => {
+			handleNotebookDocumentAdded(document);
 			this._updateState();
 		}));
 
-		this._register(this._notebookService.onDidRemoveNotebookDocument(uri => {
+		this._disposables.add(this._notebookService.onDidRemoveNotebookDocument(uri => {
 			this._documentEventListenersMapping.get(uri)?.dispose();
 			this._documentEventListenersMapping.delete(uri);
 			this._updateState();
 		}));
 
-		this._register(this._notebookService.onDidChangeNotebookActiveKernel(e => {
+		this._disposables.add(this._notebookService.onDidChangeNotebookActiveKernel(e => {
 			this._proxy.$acceptNotebookActiveKernelChange(e);
 		}));
 
-		this._register(this._notebookService.onNotebookDocumentSaved(e => {
+		this._disposables.add(this._notebookEditorModelResolverService.onDidSaveNotebook(e => {
 			this._proxy.$acceptModelSaved(e);
 		}));
 
-		const activeEditorPane = this._editorService.activeEditorPane as any | undefined;
-		const notebookEditor = activeEditorPane?.isNotebookEditor ? activeEditorPane.getControl() : undefined;
+		const notebookEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
 		this._updateState(notebookEditor);
 	}
 
-	private _addNotebookEditor(e: IEditor) {
-		this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable(
-			e.onDidChangeModel(() => this._updateState()),
-			e.onDidFocusEditorWidget(() => {
-				this._updateState(e);
-			}),
-		));
+	private _updateState(focusedNotebookEditor?: INotebookEditor): void {
 
-		const activeEditorPane = this._editorService.activeEditorPane as any | undefined;
-		const notebookEditor = activeEditorPane?.isNotebookEditor ? activeEditorPane.getControl() : undefined;
-		this._updateState(notebookEditor);
-	}
+		const activeNotebookEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+		let activeEditor = activeNotebookEditor?.hasModel() ? activeNotebookEditor.getId() : null;
 
-	private _removeNotebookEditor(editors: IEditor[]) {
-		editors.forEach(e => {
-			const sub = this._toDisposeOnEditorRemove.get(e.getId());
-			if (sub) {
-				this._toDisposeOnEditorRemove.delete(e.getId());
-				sub.dispose();
+		const editors = new Map<string, IActiveNotebookEditor>();
+		const visibleEditorsMap = new Map<string, IActiveNotebookEditor>();
+
+		for (const editor of this._notebookEditorService.listNotebookEditors()) {
+			if (editor.hasModel()) {
+				editors.set(editor.getId(), editor);
 			}
-		});
-
-		this._updateState();
-	}
-
-	private async _updateState(focusedNotebookEditor?: IEditor) {
-		let activeEditor: string | null = null;
-
-		const activeEditorPane = this._editorService.activeEditorPane as any | undefined;
-		if (activeEditorPane?.isNotebookEditor) {
-			const notebookEditor = (activeEditorPane.getControl() as INotebookEditor);
-			activeEditor = notebookEditor && notebookEditor.hasModel() ? notebookEditor!.getId() : null;
 		}
 
-		const documentEditorsMap = new Map<string, IEditor>();
-
-		const editors = new Map<string, IEditor>();
-		this._notebookService.listNotebookEditors().forEach(editor => {
-			if (editor.textModel) {
-				editors.set(editor.getId(), editor);
-				documentEditorsMap.set(editor.textModel.uri.toString(), editor);
+		this._editorService.visibleEditorPanes.forEach(editorPane => {
+			const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
+			if (notebookEditor?.hasModel() && editors.has(notebookEditor.getId())) {
+				visibleEditorsMap.set(notebookEditor.getId(), notebookEditor);
 			}
 		});
 
-		const visibleEditorsMap = new Map<string, IEditor>();
-		this._editorService.visibleEditorPanes.forEach(editor => {
-			if ((editor as any).isNotebookEditor) {
-				const nbEditorWidget = (editor as any).getControl() as INotebookEditor;
-				if (nbEditorWidget && editors.has(nbEditorWidget.getId())) {
-					visibleEditorsMap.set(nbEditorWidget.getId(), nbEditorWidget);
-				}
-			}
-		});
-
-		const documents = new Set<NotebookTextModel>();
-		this._notebookService.listNotebookDocuments().forEach(document => {
-			documents.add(document);
-		});
-
-		if (!activeEditor && focusedNotebookEditor && focusedNotebookEditor.textModel) {
+		if (!activeEditor && focusedNotebookEditor?.textModel) {
 			activeEditor = focusedNotebookEditor.getId();
 		}
 
-		// editors always have view model attached, which means there is already a document in exthost.
-		const newState = new DocumentAndEditorState(documents, editors, activeEditor, visibleEditorsMap);
-		const delta = DocumentAndEditorState.compute(this._currentState, newState);
-		// const isEmptyChange = (!delta.addedDocuments || delta.addedDocuments.length === 0)
-		// 	&& (!delta.removedDocuments || delta.removedDocuments.length === 0)
-		// 	&& (!delta.addedEditors || delta.addedEditors.length === 0)
-		// 	&& (!delta.removedEditors || delta.removedEditors.length === 0)
-		// 	&& (delta.newActiveEditor === undefined)
+		const newState = new NotebookAndEditorState(new Set(this._notebookService.listNotebookDocuments()), editors, activeEditor, visibleEditorsMap);
+		const delta = NotebookAndEditorState.compute(this._currentState, newState);
 
-		// if (!isEmptyChange) {
 		this._currentState = newState;
-		this._emitDelta(delta);
-		// }
+		if (!this._isDeltaEmpty(delta)) {
+			return this._proxy.$acceptDocumentAndEditorsDelta(delta);
+		}
+	}
+
+	private _isDeltaEmpty(delta: INotebookDocumentsAndEditorsDelta): boolean {
+		if (delta.addedDocuments !== undefined && delta.addedDocuments.length > 0) {
+			return false;
+		}
+		if (delta.removedDocuments !== undefined && delta.removedDocuments.length > 0) {
+			return false;
+		}
+		if (delta.addedEditors !== undefined && delta.addedEditors.length > 0) {
+			return false;
+		}
+		if (delta.removedEditors !== undefined && delta.removedEditors.length > 0) {
+			return false;
+		}
+		if (delta.visibleEditors !== undefined && delta.visibleEditors.length > 0) {
+			return false;
+		}
+		if (delta.newActiveEditor !== undefined) {
+			return false;
+		}
+		return true;
 	}
 
 	async $registerNotebookProvider(extension: NotebookExtensionDescription, viewType: string, options: {
@@ -452,8 +414,8 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 				contentOptions.transientOutputs = newOptions.transientOutputs;
 			},
 			viewOptions: options.viewOptions,
-			openNotebook: async (viewType: string, uri: URI, backupId?: string) => {
-				const data = await this._proxy.$openNotebook(viewType, uri, backupId);
+			open: async (uri: URI, backupId: string | undefined, untitledDocumentData: VSBuffer | undefined, token: CancellationToken) => {
+				const data = await this._proxy.$openNotebook(viewType, uri, backupId, untitledDocumentData, token);
 				return {
 					data,
 					transientOptions: contentOptions
@@ -501,6 +463,24 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		}
 	}
 
+	$registerNotebookSerializer(handle: number, extension: NotebookExtensionDescription, viewType: string, options: TransientOptions): void {
+		const registration = this._notebookService.registerNotebookSerializer(viewType, extension, {
+			options,
+			dataToNotebook: (data: VSBuffer): Promise<NotebookDataDto> => {
+				return this._proxy.$dataToNotebook(handle, data);
+			},
+			notebookToData: (data: NotebookDataDto): Promise<VSBuffer> => {
+				return this._proxy.$notebookToData(handle, data);
+			}
+		});
+		this._notebookSerializer.set(handle, registration);
+	}
+
+	$unregisterNotebookSerializer(handle: number): void {
+		this._notebookSerializer.get(handle)?.dispose();
+		this._notebookSerializer.delete(handle);
+	}
+
 	async $registerNotebookKernelProvider(extension: NotebookExtensionDescription, handle: number, documentFilter: INotebookDocumentFilter): Promise<void> {
 		const emitter = new Emitter<URI | undefined>();
 		const that = this;
@@ -526,17 +506,18 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 						isPreferred: dto.isPreferred,
 						preloads: dto.preloads?.map(u => URI.revive(u)),
 						supportedLanguages: dto.supportedLanguages,
+						implementsInterrupt: dto.implementsInterrupt,
 						resolve: (uri: URI, editorId: string, token: CancellationToken): Promise<void> => {
 							this._logService.debug('MainthreadNotebooks.resolveNotebookKernel', uri.path, dto.friendlyId);
 							return this._proxy.$resolveNotebookKernel(handle, editorId, uri, dto.friendlyId, token);
 						},
-						executeNotebookCell: (uri: URI, cellHandle: number | undefined): Promise<void> => {
-							this._logService.debug('MainthreadNotebooks.executeNotebookCell', uri.path, dto.friendlyId, cellHandle);
-							return this._proxy.$executeNotebookKernelFromProvider(handle, uri, dto.friendlyId, cellHandle);
+						executeNotebookCellsRequest: (uri: URI, cellRanges: ICellRange[]): Promise<void> => {
+							this._logService.debug('MainthreadNotebooks.executeNotebookCell', uri.path, dto.friendlyId, cellRanges);
+							return this._proxy.$executeNotebookKernelFromProvider(handle, uri, dto.friendlyId, cellRanges);
 						},
-						cancelNotebookCell: (uri: URI, cellHandle: number | undefined): Promise<void> => {
-							this._logService.debug('MainthreadNotebooks.cancelNotebookCell', uri.path, dto.friendlyId, cellHandle);
-							return this._proxy.$cancelNotebookKernelFromProvider(handle, uri, dto.friendlyId, cellHandle);
+						cancelNotebookCellExecution: (uri: URI, cellRanges: ICellRange[]): Promise<void> => {
+							this._logService.debug('MainthreadNotebooks.cancelNotebookCellExecution', uri.path, dto.friendlyId, cellRanges);
+							return this._proxy.$cancelNotebookCellExecution(handle, uri, dto.friendlyId, cellRanges);
 						}
 					});
 				}
@@ -563,55 +544,53 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		entry?.emitter.fire(uriComponents ? URI.revive(uriComponents) : undefined);
 	}
 
-	async $postMessage(editorId: string, forRendererId: string | undefined, value: any): Promise<boolean> {
-		const editor = this._notebookService.getNotebookEditor(editorId) as INotebookEditor | undefined;
-		if (editor?.isNotebookEditor) {
-			editor.postMessage(forRendererId, value);
-			return true;
+	async $postMessage(id: string, forRendererId: string | undefined, value: any): Promise<boolean> {
+		const editor = this._notebookEditorService.getNotebookEditor(id);
+		if (!editor) {
+			return false;
 		}
-
-		return false;
+		editor.postMessage(forRendererId, value);
+		return true;
 	}
 
-	async $tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType) {
-		const editor = this._notebookService.listNotebookEditors().find(editor => editor.getId() === id);
-		if (editor && editor.isNotebookEditor) {
-			const notebookEditor = editor as INotebookEditor;
-			if (!notebookEditor.hasModel()) {
-				return;
-			}
-			const viewModel = notebookEditor.viewModel;
-			const cell = viewModel.viewCells[range.start];
-			if (!cell) {
-				return;
-			}
+	async $tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType): Promise<void> {
+		const editor = this._notebookEditorService.getNotebookEditor(id);
+		if (!editor) {
+			return;
+		}
+		const notebookEditor = editor as INotebookEditor;
+		if (!notebookEditor.hasModel()) {
+			return;
+		}
+		const viewModel = notebookEditor.viewModel;
+		const cell = viewModel.viewCells[range.start];
+		if (!cell) {
+			return;
+		}
 
-			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);
-				default:
-					break;
-			}
+		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);
 		}
 	}
 
-	$registerNotebookEditorDecorationType(key: string, options: INotebookDecorationRenderOptions) {
-		this._notebookService.registerEditorDecorationType(key, options);
+	$registerNotebookEditorDecorationType(key: string, options: INotebookDecorationRenderOptions): void {
+		this._notebookEditorService.registerEditorDecorationType(key, options);
 	}
 
-	$removeNotebookEditorDecorationType(key: string) {
-		this._notebookService.removeEditorDecorationType(key);
+	$removeNotebookEditorDecorationType(key: string): void {
+		this._notebookEditorService.removeEditorDecorationType(key);
 	}
 
-	$trySetDecorations(id: string, range: ICellRange, key: string) {
-		const editor = this._notebookService.listNotebookEditors().find(editor => editor.getId() === id);
-		if (editor && editor.isNotebookEditor) {
+	$trySetDecorations(id: string, range: ICellRange, key: string): void {
+		const editor = this._notebookEditorService.getNotebookEditor(id);
+		if (editor) {
 			const notebookEditor = editor as INotebookEditor;
 			notebookEditor.setEditorDecorations(key, range);
 		}
@@ -634,25 +613,25 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 	}
 
 
-	async $tryOpenDocument(uriComponents: UriComponents, viewType?: string): Promise<URI> {
+	async $tryOpenDocument(uriComponents: UriComponents): Promise<URI> {
 		const uri = URI.revive(uriComponents);
-		const ref = await this._notebookModelResolverService.resolve(uri, viewType);
+		const ref = await this._notebookEditorModelResolverService.resolve(uri, undefined);
 		this._modelReferenceCollection.add(uri, ref);
-
 		return uri;
 	}
 
 	async $trySaveDocument(uriComponents: UriComponents) {
 		const uri = URI.revive(uriComponents);
 
-		const ref = await this._notebookModelResolverService.resolve(uri);
+		const ref = await this._notebookEditorModelResolverService.resolve(uri);
 		const saveResult = await ref.object.save();
 		ref.dispose();
 		return saveResult;
 	}
 
 	async $tryShowNotebookDocument(resource: UriComponents, viewType: string, options: INotebookDocumentShowOptions): Promise<string> {
-		const editorOptions: ITextEditorOptions = {
+		const editorOptions = new NotebookEditorOptions({
+			cellSelections: options.selection && [options.selection],
 			preserveFocus: options.preserveFocus,
 			pinned: options.pinned,
 			// selection: options.selection,
@@ -660,36 +639,13 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			// but make sure to restore the editor to fix https://github.com/microsoft/vscode/issues/79633
 			activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
 			override: EditorOverride.DISABLED,
-		};
+		});
 
-		const columnArg = viewColumnToEditorGroup(this._editorGroupsService, options.position);
-
-		let group: IEditorGroup | undefined = undefined;
-
-		if (columnArg === SIDE_GROUP) {
-			const direction = preferredSideBySideGroupDirection(this._configurationService);
-
-			let neighbourGroup = this._editorGroupsService.findGroup({ direction });
-			if (!neighbourGroup) {
-				neighbourGroup = this._editorGroupsService.addGroup(this._editorGroupsService.activeGroup, direction);
-			}
-			group = neighbourGroup;
-		} else {
-			group = this._editorGroupsService.getGroup(viewColumnToEditorGroup(this._editorGroupsService, columnArg)) ?? this._editorGroupsService.activeGroup;
-		}
-
-		const input = this._editorService.createEditorInput({ resource: URI.revive(resource), options: editorOptions });
-
-		// TODO: handle options.selection
-		const editorPane = await this._editorService.openEditor(input, { ...options, override: viewType }, group);
-		const notebookEditor = (editorPane as unknown as { isNotebookEditor?: boolean })?.isNotebookEditor ? (editorPane!.getControl() as INotebookEditor) : undefined;
+		const input = NotebookEditorInput.create(this._instantiationService, URI.revive(resource), viewType);
+		const editorPane = await this._editorService.openEditor(input, editorOptions, options.position);
+		const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
 
 		if (notebookEditor) {
-			if (notebookEditor.viewModel && options.selection && notebookEditor.viewModel.viewCells[options.selection.start]) {
-				const focusedCell = notebookEditor.viewModel.viewCells[options.selection.start];
-				notebookEditor.revealInCenterIfOutsideViewport(focusedCell);
-				notebookEditor.focusElement(focusedCell);
-			}
 			return notebookEditor.getId();
 		} else {
 			throw new Error(`Notebook Editor creation failure for documenet ${resource}`);

lib/vscode/src/vs/workbench/api/browser/mainThreadQuickOpen.ts

@@ -89,6 +89,7 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
 		const inputOptions: IInputOptions = Object.create(null);
 
 		if (options) {
+			inputOptions.title = options.title;
 			inputOptions.password = options.password;
 			inputOptions.placeHolder = options.placeHolder;
 			inputOptions.valueSelection = options.valueSelection;

lib/vscode/src/vs/workbench/api/browser/mainThreadSCM.ts

@@ -242,6 +242,7 @@ class MainThreadSCMProvider implements ISCMProvider {
 
 		delete this._groupsByHandle[handle];
 		this.groups.splice(this.groups.elements.indexOf(group), 1);
+		this._onDidChangeResources.fire();
 	}
 
 	async getOriginalResource(uri: URI): Promise<URI | null> {

lib/vscode/src/vs/workbench/api/browser/mainThreadStatusBar.ts

@@ -15,7 +15,7 @@ import { IAccessibilityInformation } from 'vs/platform/accessibility/common/acce
 export class MainThreadStatusBar implements MainThreadStatusBarShape {
 
 	private readonly entries: Map<number, { accessor: IStatusbarEntryAccessor, alignment: MainThreadStatusBarAlignment, priority: number }> = new Map();
-	static readonly CODICON_REGEXP = /\$\((.*?)\)/g;
+	private static readonly CODICON_REGEXP = /\$\((.*?)\)/g;
 
 	constructor(
 		_extHostContext: IExtHostContext,

lib/vscode/src/vs/workbench/api/browser/mainThreadTelemetry.ts

@@ -4,24 +4,46 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { MainThreadTelemetryShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { MainThreadTelemetryShape, MainContext, IExtHostContext, ExtHostTelemetryShape, ExtHostContext } from '../common/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { ClassifiedEvent, StrictPropertyCheck, GDPRClassification } from 'vs/platform/telemetry/common/gdprTypings';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 
 @extHostNamedCustomer(MainContext.MainThreadTelemetry)
-export class MainThreadTelemetry implements MainThreadTelemetryShape {
+export class MainThreadTelemetry extends Disposable implements MainThreadTelemetryShape {
+	private readonly _proxy: ExtHostTelemetryShape;
 
 	private static readonly _name = 'pluginHostTelemetry';
 
 	constructor(
 		extHostContext: IExtHostContext,
-		@ITelemetryService private readonly _telemetryService: ITelemetryService
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IEnvironmentService private readonly _environmenService: IEnvironmentService,
 	) {
-		//
+		super();
+
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTelemetry);
+
+		if (!this._environmenService.disableTelemetry) {
+			this._register(this._configurationService.onDidChangeConfiguration(e => {
+				if (e.affectedKeys.includes('telemetry.enableTelemetry')) {
+					this._proxy.$onDidChangeTelemetryEnabled(this.telemetryEnabled);
+				}
+			}));
+		}
+
+		this._proxy.$initializeTelemetryEnabled(this.telemetryEnabled);
 	}
 
-	dispose(): void {
-		//
+	private get telemetryEnabled(): boolean {
+		if (this._environmenService.disableTelemetry) {
+			return false;
+		}
+
+		return !!this._configurationService.getValue('telemetry.enableTelemetry');
 	}
 
 	$publicLog(eventName: string, data: any = Object.create(null)): void {

lib/vscode/src/vs/workbench/api/browser/mainThreadTerminalService.ts

@@ -3,21 +3,21 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DisposableStore, Disposable, IDisposable } from 'vs/base/common/lifecycle';
-import { ITerminalProcessExtHostProxy, ISpawnExtHostProcessRequest, IAvailableShellsRequest, IDefaultShellAndArgsRequest, IStartExtensionTerminalRequest, ITerminalConfiguration, TERMINAL_CONFIG_SECTION } from 'vs/workbench/contrib/terminal/common/terminal';
-import { ExtHostContext, ExtHostTerminalServiceShape, MainThreadTerminalServiceShape, MainContext, IExtHostContext, IShellLaunchConfigDto, TerminalLaunchConfig, ITerminalDimensionsDto, TerminalIdentifier } from 'vs/workbench/api/common/extHost.protocol';
-import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
-import { URI } from 'vs/base/common/uri';
+import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { StopWatch } from 'vs/base/common/stopwatch';
-import { ITerminalInstanceService, ITerminalService, ITerminalInstance, ITerminalExternalLinkProvider, ITerminalLink } from 'vs/workbench/contrib/terminal/browser/terminal';
-import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
+import { URI } from 'vs/base/common/uri';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { TerminalDataBufferer } from 'vs/platform/terminal/common/terminalDataBuffering';
-import { deserializeEnvironmentVariableCollection, serializeEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariableShared';
 import { ILogService } from 'vs/platform/log/common/log';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { IEnvironmentVariableService, ISerializableEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariable';
 import { IShellLaunchConfig, ITerminalDimensions } from 'vs/platform/terminal/common/terminal';
+import { TerminalDataBufferer } from 'vs/platform/terminal/common/terminalDataBuffering';
+import { ExtHostContext, ExtHostTerminalServiceShape, IExtHostContext, IShellLaunchConfigDto, ITerminalDimensionsDto, MainContext, MainThreadTerminalServiceShape, TerminalIdentifier, TerminalLaunchConfig } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ITerminalExternalLinkProvider, ITerminalInstance, ITerminalInstanceService, ITerminalLink, ITerminalService } from 'vs/workbench/contrib/terminal/browser/terminal';
+import { IEnvironmentVariableService, ISerializableEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariable';
+import { deserializeEnvironmentVariableCollection, serializeEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariableShared';
+import { IAvailableProfilesRequest as IAvailableProfilesRequest, IDefaultShellAndArgsRequest, IStartExtensionTerminalRequest, ITerminalProcessExtHostProxy } from 'vs/workbench/contrib/terminal/common/terminal';
+import { ExtensionHostKind } from 'vs/workbench/services/extensions/common/extensions';
+import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
 
 @extHostNamedCustomer(MainContext.MainThreadTerminalService)
 export class MainThreadTerminalService implements MainThreadTerminalServiceShape {
@@ -33,6 +33,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 	private readonly _toDispose = new DisposableStore();
 	private readonly _terminalProcessProxies = new Map<number, ITerminalProcessExtHostProxy>();
 	private _dataEventTracker: TerminalDataEventTracker | undefined;
+	private _extHostKind: ExtensionHostKind;
 	/**
 	 * A single shared terminal link provider for the exthost. When an ext registers a link
 	 * provider, this is registered with the terminal on the renderer side and all links are
@@ -48,7 +49,6 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		@IRemoteAgentService private readonly _remoteAgentService: IRemoteAgentService,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
 		@IEnvironmentVariableService private readonly _environmentVariableService: IEnvironmentVariableService,
-		@IConfigurationService private readonly _configurationService: IConfigurationService,
 		@ILogService private readonly _logService: ILogService,
 	) {
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTerminalService);
@@ -60,16 +60,17 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			this._onInstanceDimensionsChanged(instance);
 		}));
 
+		this._extHostKind = extHostContext.extensionHostKind;
+
 		this._toDispose.add(_terminalService.onInstanceDisposed(instance => this._onTerminalDisposed(instance)));
 		this._toDispose.add(_terminalService.onInstanceProcessIdReady(instance => this._onTerminalProcessIdReady(instance)));
 		this._toDispose.add(_terminalService.onInstanceDimensionsChanged(instance => this._onInstanceDimensionsChanged(instance)));
 		this._toDispose.add(_terminalService.onInstanceMaximumDimensionsChanged(instance => this._onInstanceMaximumDimensionsChanged(instance)));
-		this._toDispose.add(_terminalService.onInstanceRequestSpawnExtHostProcess(request => this._onRequestSpawnExtHostProcess(request)));
 		this._toDispose.add(_terminalService.onInstanceRequestStartExtensionTerminal(e => this._onRequestStartExtensionTerminal(e)));
-		this._toDispose.add(_terminalService.onActiveInstanceChanged(instance => this._onActiveTerminalChanged(instance ? instance.id : null)));
-		this._toDispose.add(_terminalService.onInstanceTitleChanged(instance => instance && this._onTitleChanged(instance.id, instance.title)));
+		this._toDispose.add(_terminalService.onActiveInstanceChanged(instance => this._onActiveTerminalChanged(instance ? instance.instanceId : null)));
+		this._toDispose.add(_terminalService.onInstanceTitleChanged(instance => instance && this._onTitleChanged(instance.instanceId, instance.title)));
 		this._toDispose.add(_terminalService.configHelper.onWorkspacePermissionsChanged(isAllowed => this._onWorkspacePermissionsChanged(isAllowed)));
-		this._toDispose.add(_terminalService.onRequestAvailableShells(e => this._onRequestAvailableShells(e)));
+		this._toDispose.add(_terminalService.onRequestAvailableProfiles(e => this._onRequestAvailableProfiles(e)));
 
 		// ITerminalInstanceService listeners
 		if (terminalInstanceService.onRequestDefaultShellAndArgs) {
@@ -83,7 +84,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		});
 		const activeInstance = this._terminalService.getActiveInstance();
 		if (activeInstance) {
-			this._proxy.$acceptActiveTerminalChanged(activeInstance.id);
+			this._proxy.$acceptActiveTerminalChanged(activeInstance.instanceId);
 		}
 		if (this._environmentVariableService.collections.size > 0) {
 			const collectionAsArray = [...this._environmentVariableService.collections.entries()];
@@ -130,13 +131,13 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			env: launchConfig.env,
 			strictEnv: launchConfig.strictEnv,
 			hideFromUser: launchConfig.hideFromUser,
-			isExtensionTerminal: launchConfig.isExtensionTerminal,
-			isExtensionOwnedTerminal: launchConfig.isExtensionOwnedTerminal,
+			isExtensionCustomPtyTerminal: launchConfig.isExtensionCustomPtyTerminal,
 			extHostTerminalId: extHostTerminalId,
-			isFeatureTerminal: launchConfig.isFeatureTerminal
+			isFeatureTerminal: launchConfig.isFeatureTerminal,
+			isExtensionOwnedTerminal: launchConfig.isExtensionOwnedTerminal
 		};
 		const terminal = this._terminalService.createTerminal(shellLaunchConfig);
-		this._extHostTerminalIds.set(extHostTerminalId, terminal.id);
+		this._extHostTerminalIds.set(extHostTerminalId, terminal.instanceId);
 	}
 
 	public $show(id: TerminalIdentifier, preserveFocus: boolean): void {
@@ -150,7 +151,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 	public $hide(id: TerminalIdentifier): void {
 		const rendererId = this._getTerminalId(id);
 		const instance = this._terminalService.getActiveInstance();
-		if (instance && instance.id === rendererId) {
+		if (instance && instance.instanceId === rendererId) {
 			this._terminalService.hidePanel();
 		}
 	}
@@ -176,7 +177,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			});
 			// Send initial events if they exist
 			this._terminalService.terminalInstances.forEach(t => {
-				t.initialDataEvents?.forEach(d => this._onTerminalData(t.id, d));
+				t.initialDataEvents?.forEach(d => this._onTerminalData(t.instanceId, d));
 			});
 		}
 	}
@@ -219,7 +220,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 	}
 
 	private _onTerminalDisposed(terminalInstance: ITerminalInstance): void {
-		this._proxy.$acceptTerminalClosed(terminalInstance.id, terminalInstance.exitCode);
+		this._proxy.$acceptTerminalClosed(terminalInstance.instanceId, terminalInstance.exitCode);
 	}
 
 	private _onTerminalOpened(terminalInstance: ITerminalInstance): void {
@@ -232,63 +233,28 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			env: terminalInstance.shellLaunchConfig.env,
 			hideFromUser: terminalInstance.shellLaunchConfig.hideFromUser
 		};
-		this._proxy.$acceptTerminalOpened(terminalInstance.id, extHostTerminalId, terminalInstance.title, shellLaunchConfigDto);
+		this._proxy.$acceptTerminalOpened(terminalInstance.instanceId, extHostTerminalId, terminalInstance.title, shellLaunchConfigDto);
 	}
 
 	private _onTerminalProcessIdReady(terminalInstance: ITerminalInstance): void {
 		if (terminalInstance.processId === undefined) {
 			return;
 		}
-		this._proxy.$acceptTerminalProcessId(terminalInstance.id, terminalInstance.processId);
+		this._proxy.$acceptTerminalProcessId(terminalInstance.instanceId, terminalInstance.processId);
 	}
 
 	private _onInstanceDimensionsChanged(instance: ITerminalInstance): void {
-		this._proxy.$acceptTerminalDimensions(instance.id, instance.cols, instance.rows);
+		this._proxy.$acceptTerminalDimensions(instance.instanceId, instance.cols, instance.rows);
 	}
 
 	private _onInstanceMaximumDimensionsChanged(instance: ITerminalInstance): void {
-		this._proxy.$acceptTerminalMaximumDimensions(instance.id, instance.maxCols, instance.maxRows);
+		this._proxy.$acceptTerminalMaximumDimensions(instance.instanceId, instance.maxCols, instance.maxRows);
 	}
 
-	private _onRequestSpawnExtHostProcess(request: ISpawnExtHostProcessRequest): void {
-		// Only allow processes on remote ext hosts
-		if (!this._remoteAuthority) {
-			return;
-		}
-
-		const proxy = request.proxy;
-		this._terminalProcessProxies.set(proxy.terminalId, proxy);
-		const shellLaunchConfigDto: IShellLaunchConfigDto = {
-			name: request.shellLaunchConfig.name,
-			executable: request.shellLaunchConfig.executable,
-			args: request.shellLaunchConfig.args,
-			cwd: request.shellLaunchConfig.cwd,
-			env: request.shellLaunchConfig.env,
-			flowControl: this._configurationService.getValue<ITerminalConfiguration>(TERMINAL_CONFIG_SECTION).flowControl
-		};
-
-		this._logService.trace('Spawning ext host process', { terminalId: proxy.terminalId, shellLaunchConfigDto, request });
-		this._proxy.$spawnExtHostProcess(
-			proxy.terminalId,
-			shellLaunchConfigDto,
-			request.activeWorkspaceRootUri,
-			request.cols,
-			request.rows,
-			request.isWorkspaceShellAllowed
-		).then(request.callback, request.callback);
-
-		proxy.onAcknowledgeDataEvent(charCount => this._proxy.$acceptProcessAckDataEvent(proxy.terminalId, charCount));
-		proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.terminalId, data));
-		proxy.onResize(dimensions => this._proxy.$acceptProcessResize(proxy.terminalId, dimensions.cols, dimensions.rows));
-		proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.terminalId, immediate));
-		proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.terminalId));
-		proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.terminalId));
-		proxy.onRequestLatency(() => this._onRequestLatency(proxy.terminalId));
-	}
 
 	private _onRequestStartExtensionTerminal(request: IStartExtensionTerminalRequest): void {
 		const proxy = request.proxy;
-		this._terminalProcessProxies.set(proxy.terminalId, proxy);
+		this._terminalProcessProxies.set(proxy.instanceId, proxy);
 
 		// Note that onReisze is not being listened to here as it needs to fire when max dimensions
 		// change, excluding the dimension override
@@ -298,15 +264,15 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		} : undefined;
 
 		this._proxy.$startExtensionTerminal(
-			proxy.terminalId,
+			proxy.instanceId,
 			initialDimensions
 		).then(request.callback);
 
-		proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.terminalId, data));
-		proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.terminalId, immediate));
-		proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.terminalId));
-		proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.terminalId));
-		proxy.onRequestLatency(() => this._onRequestLatency(proxy.terminalId));
+		proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.instanceId, data));
+		proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.instanceId, immediate));
+		proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.instanceId));
+		proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.instanceId));
+		proxy.onRequestLatency(() => this._onRequestLatency(proxy.instanceId));
 	}
 
 	public $sendProcessTitle(terminalId: number, title: string): void {
@@ -387,9 +353,9 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		return true;
 	}
 
-	private async _onRequestAvailableShells(req: IAvailableShellsRequest): Promise<void> {
-		if (this._isPrimaryExtHost()) {
-			req.callback(await this._proxy.$getAvailableShells());
+	private async _onRequestAvailableProfiles(req: IAvailableProfilesRequest): Promise<void> {
+		if (this._isPrimaryExtHost() && this._extHostKind !== ExtensionHostKind.LocalWebWorker) {
+			req.callback(await this._proxy.$getAvailableProfiles(req.quickLaunchOnly));
 		}
 	}
 
@@ -439,12 +405,12 @@ class TerminalDataEventTracker extends Disposable {
 
 		this._terminalService.terminalInstances.forEach(instance => this._registerInstance(instance));
 		this._register(this._terminalService.onInstanceCreated(instance => this._registerInstance(instance)));
-		this._register(this._terminalService.onInstanceDisposed(instance => this._bufferer.stopBuffering(instance.id)));
+		this._register(this._terminalService.onInstanceDisposed(instance => this._bufferer.stopBuffering(instance.instanceId)));
 	}
 
 	private _registerInstance(instance: ITerminalInstance): void {
 		// Buffer data events to reduce the amount of messages going to the extension host
-		this._register(this._bufferer.startBuffering(instance.id, instance.onData));
+		this._register(this._bufferer.startBuffering(instance.instanceId, instance.onData));
 	}
 }
 
@@ -456,13 +422,13 @@ class ExtensionTerminalLinkProvider implements ITerminalExternalLinkProvider {
 
 	async provideLinks(instance: ITerminalInstance, line: string): Promise<ITerminalLink[] | undefined> {
 		const proxy = this._proxy;
-		const extHostLinks = await proxy.$provideLinks(instance.id, line);
+		const extHostLinks = await proxy.$provideLinks(instance.instanceId, line);
 		return extHostLinks.map(dto => ({
 			id: dto.id,
 			startIndex: dto.startIndex,
 			length: dto.length,
 			label: dto.label,
-			activate: () => proxy.$activateLink(instance.id, dto.id)
+			activate: () => proxy.$activateLink(instance.instanceId, dto.id)
 		}));
 	}
 }

lib/vscode/src/vs/workbench/api/browser/mainThreadTesting.ts

@@ -11,23 +11,25 @@ import { Range } from 'vs/editor/common/core/range';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { getTestSubscriptionKey, ISerializedTestResults, ITestState, RunTestsRequest, TestDiffOpType, TestsDiff } from 'vs/workbench/contrib/testing/common/testCollection';
 import { HydratedTestResult, ITestResultService, LiveTestResult } from 'vs/workbench/contrib/testing/common/testResultService';
-import { ITestService } from 'vs/workbench/contrib/testing/common/testService';
+import { ITestRootProvider, ITestService } from 'vs/workbench/contrib/testing/common/testService';
 import { ExtHostContext, ExtHostTestingResource, ExtHostTestingShape, IExtHostContext, MainContext, MainThreadTestingShape } from '../common/extHost.protocol';
 
 const reviveDiff = (diff: TestsDiff) => {
 	for (const entry of diff) {
 		if (entry[0] === TestDiffOpType.Add || entry[0] === TestDiffOpType.Update) {
 			const item = entry[1];
-			if (item.item.location) {
-				item.item.location.uri = URI.revive(item.item.location.uri);
-				item.item.location.range = Range.lift(item.item.location.range);
+			if (item.item?.uri) {
+				item.item.uri = URI.revive(item.item.uri);
+			}
+			if (item.item?.range) {
+				item.item.range = Range.lift(item.item.range);
 			}
 		}
 	}
 };
 
 @extHostNamedCustomer(MainContext.MainThreadTesting)
-export class MainThreadTesting extends Disposable implements MainThreadTestingShape {
+export class MainThreadTesting extends Disposable implements MainThreadTestingShape, ITestRootProvider {
 	private readonly proxy: ExtHostTestingShape;
 	private readonly testSubscriptions = new Map<string, IDisposable>();
 	private readonly testProviderRegistrations = new Map<string, IDisposable>();
@@ -56,7 +58,7 @@ export class MainThreadTesting extends Disposable implements MainThreadTestingSh
 			}
 		}));
 
-		testService.updateRootProviderCount(1);
+		this._register(testService.registerRootProvider(this));
 
 		for (const { resource, uri } of this.testService.subscriptions) {
 			this.proxy.$subscribeToTests(resource, uri);
@@ -66,25 +68,14 @@ export class MainThreadTesting extends Disposable implements MainThreadTestingSh
 	/**
 	 * @inheritdoc
 	 */
-	$publishExtensionProvidedResults(results: ISerializedTestResults, persist: boolean): void {
+	public $publishExtensionProvidedResults(results: ISerializedTestResults, persist: boolean): void {
 		this.resultService.push(new HydratedTestResult(results, persist));
 	}
 
 	/**
 	 * @inheritdoc
 	 */
-	$retireTest(extId: string): void {
-		for (const result of this.resultService.results) {
-			if (result instanceof LiveTestResult) {
-				result.retire(extId);
-			}
-		}
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	$updateTestStateInRun(runId: string, testId: string, state: ITestState): void {
+	public $updateTestStateInRun(runId: string, testId: string, state: ITestState): void {
 		const r = this.resultService.getResult(runId);
 		if (r && r instanceof LiveTestResult) {
 			for (const message of state.messages) {
@@ -105,6 +96,7 @@ export class MainThreadTesting extends Disposable implements MainThreadTestingSh
 		const disposable = this.testService.registerTestController(id, {
 			runTests: (req, token) => this.proxy.$runTestsForProvider(req, token),
 			lookupTest: test => this.proxy.$lookupTest(test),
+			expandTest: (src, levels) => this.proxy.$expandTest(src, isFinite(levels) ? levels : -1),
 		});
 
 		this.testProviderRegistrations.set(id, disposable);
@@ -121,7 +113,7 @@ export class MainThreadTesting extends Disposable implements MainThreadTestingSh
 	/**
 	 * @inheritdoc
 	 */
-	$subscribeToDiffs(resource: ExtHostTestingResource, uriComponents: UriComponents): void {
+	public $subscribeToDiffs(resource: ExtHostTestingResource, uriComponents: UriComponents): void {
 		const uri = URI.revive(uriComponents);
 		const disposable = this.testService.subscribeToDiffs(resource, uri,
 			diff => this.proxy.$acceptDiff(resource, uriComponents, diff));
@@ -152,7 +144,6 @@ export class MainThreadTesting extends Disposable implements MainThreadTestingSh
 
 	public dispose() {
 		super.dispose();
-		this.testService.updateRootProviderCount(-1);
 		for (const subscription of this.testSubscriptions.values()) {
 			subscription.dispose();
 		}

lib/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.ts

@@ -4,22 +4,24 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as nls from 'vs/nls';
-import { MainThreadTunnelServiceShape, IExtHostContext, MainContext, ExtHostContext, ExtHostTunnelServiceShape, CandidatePortSource } from 'vs/workbench/api/common/extHost.protocol';
+import { MainThreadTunnelServiceShape, IExtHostContext, MainContext, ExtHostContext, ExtHostTunnelServiceShape, CandidatePortSource, PortAttributesProviderSelector } from 'vs/workbench/api/common/extHost.protocol';
 import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
-import { CandidatePort, IRemoteExplorerService, makeAddress, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vs/workbench/services/remote/common/remoteExplorerService';
-import { ITunnelProvider, ITunnelService, TunnelCreationOptions, TunnelProviderFeatures, TunnelOptions, RemoteTunnel, isPortPrivileged } from 'vs/platform/remote/common/tunnel';
+import { CandidatePort, IRemoteExplorerService, makeAddress, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, PORT_AUTO_SOURCE_SETTING_PROCESS } from 'vs/workbench/services/remote/common/remoteExplorerService';
+import { ITunnelProvider, ITunnelService, TunnelCreationOptions, TunnelProviderFeatures, TunnelOptions, RemoteTunnel, isPortPrivileged, ProvidedPortAttributes, PortAttributesProvider } from 'vs/platform/remote/common/tunnel';
 import { Disposable } from 'vs/base/common/lifecycle';
 import type { TunnelDescription } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
 import { ConfigurationTarget, IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
+import { CancellationToken } from 'vs/base/common/cancellation';
 
 @extHostNamedCustomer(MainContext.MainThreadTunnelService)
-export class MainThreadTunnelService extends Disposable implements MainThreadTunnelServiceShape {
+export class MainThreadTunnelService extends Disposable implements MainThreadTunnelServiceShape, PortAttributesProvider {
 	private readonly _proxy: ExtHostTunnelServiceShape;
 	private elevateionRetry: boolean = false;
+	private portsAttributesProviders: Map<number, PortAttributesProviderSelector> = new Map();
 
 	constructor(
 		extHostContext: IExtHostContext,
@@ -36,20 +38,57 @@ export class MainThreadTunnelService extends Disposable implements MainThreadTun
 		this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
 	}
 
+	private processFindingEnabled(): boolean {
+		return (!!this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING)) && (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) === PORT_AUTO_SOURCE_SETTING_PROCESS);
+	}
+
 	async $setRemoteTunnelService(processId: number): Promise<void> {
 		this.remoteExplorerService.namedProcesses.set(processId, 'Code Extension Host');
 		if (this.remoteExplorerService.portsFeaturesEnabled) {
-			this._proxy.$registerCandidateFinder(this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING));
+			this._proxy.$registerCandidateFinder(this.processFindingEnabled());
 		} else {
 			this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING))));
 		}
 		this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
-			if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING)) {
-				return this._proxy.$registerCandidateFinder((this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING)));
+			if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING)) {
+				return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
 			}
 		}));
 	}
 
+	private _alreadyRegistered: boolean = false;
+	async $registerPortsAttributesProvider(selector: PortAttributesProviderSelector, providerHandle: number): Promise<void> {
+		this.portsAttributesProviders.set(providerHandle, selector);
+		if (!this._alreadyRegistered) {
+			this.remoteExplorerService.tunnelModel.addAttributesProvider(this);
+			this._alreadyRegistered = true;
+		}
+	}
+
+	async $unregisterPortsAttributesProvider(providerHandle: number): Promise<void> {
+		this.portsAttributesProviders.delete(providerHandle);
+	}
+
+	async providePortAttributes(ports: number[], pid: number | undefined, commandLine: string | undefined, token: CancellationToken): Promise<ProvidedPortAttributes[]> {
+		if (this.portsAttributesProviders.size === 0) {
+			return [];
+		}
+
+		// Check all the selectors to make sure it's worth going to the extension host.
+		const appropriateHandles = Array.from(this.portsAttributesProviders.entries()).filter(entry => {
+			const selector = entry[1];
+			const portRange = selector.portRange;
+			const portInRange = portRange ? ports.some(port => portRange[0] <= port && port < portRange[1]) : true;
+			const pidMatches = !selector.pid || (selector.pid === pid);
+			return portInRange || pidMatches;
+		}).map(entry => entry[0]);
+
+		if (appropriateHandles.length === 0) {
+			return [];
+		}
+		return this._proxy.$providePortAttributes(appropriateHandles, ports, pid, commandLine, token);
+	}
+
 	async $openTunnel(tunnelOptions: TunnelOptions, source: string): Promise<TunnelDto | undefined> {
 		const tunnel = await this.remoteExplorerService.forward(tunnelOptions.remoteAddress, tunnelOptions.localAddressPort, tunnelOptions.label, source, false);
 		if (tunnel) {
@@ -102,26 +141,23 @@ export class MainThreadTunnelService extends Disposable implements MainThreadTun
 		const tunnelProvider: ITunnelProvider = {
 			forwardPort: (tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions) => {
 				const forward = this._proxy.$forwardPort(tunnelOptions, tunnelCreationOptions);
-				if (forward) {
-					return forward.then(tunnel => {
-						this.logService.trace(`MainThreadTunnelService: New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-						if (!tunnel) {
-							return undefined;
+				return forward.then(tunnel => {
+					this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
+					if (!tunnel) {
+						return undefined;
+					}
+					return {
+						tunnelRemotePort: tunnel.remoteAddress.port,
+						tunnelRemoteHost: tunnel.remoteAddress.host,
+						localAddress: typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
+						tunnelLocalPort: typeof tunnel.localAddress !== 'string' ? tunnel.localAddress.port : undefined,
+						public: tunnel.public,
+						dispose: async (silent?: boolean) => {
+							this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
+							return this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port }, silent);
 						}
-						return {
-							tunnelRemotePort: tunnel.remoteAddress.port,
-							tunnelRemoteHost: tunnel.remoteAddress.host,
-							localAddress: typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
-							tunnelLocalPort: typeof tunnel.localAddress !== 'string' ? tunnel.localAddress.port : undefined,
-							public: tunnel.public,
-							dispose: async (silent?: boolean) => {
-								this.logService.trace(`MainThreadTunnelService: Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-								return this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port }, silent);
-							}
-						};
-					});
-				}
-				return undefined;
+					};
+				});
 			}
 		};
 		this.tunnelService.setTunnelProvider(tunnelProvider, features);

lib/vscode/src/vs/workbench/api/browser/mainThreadWebviewPanels.ts

@@ -7,13 +7,14 @@ import { onUnexpectedError } from 'vs/base/common/errors';
 import { Disposable, DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { MainThreadWebviews, reviveWebviewExtension, reviveWebviewOptions } from 'vs/workbench/api/browser/mainThreadWebviews';
+import { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension } from 'vs/workbench/api/browser/mainThreadWebviews';
 import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
-import { editorGroupToViewColumn, EditorGroupColumn, IEditorInput, viewColumnToEditorGroup } from 'vs/workbench/common/editor';
+import { EditorGroupColumn, editorGroupToViewColumn, IEditorInput, viewColumnToEditorGroup } from 'vs/workbench/common/editor';
 import { DiffEditorInput } from 'vs/workbench/common/editor/diffEditorInput';
-import { WebviewIcons } from 'vs/workbench/contrib/webview/browser/webview';
+import { WebviewOptions } from 'vs/workbench/contrib/webview/browser/webview';
 import { WebviewInput } from 'vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
-import { ICreateWebViewShowOptions, IWebviewWorkbenchService, WebviewInputOptions } from 'vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { WebviewIcons } from 'vs/workbench/contrib/webviewPanel/browser/webviewIconManager';
+import { ICreateWebViewShowOptions, IWebviewWorkbenchService } from 'vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
 import { IEditorGroup, IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
@@ -151,9 +152,12 @@ export class MainThreadWebviewPanels extends Disposable implements extHostProtoc
 		extensionData: extHostProtocol.WebviewExtensionDescription,
 		handle: extHostProtocol.WebviewHandle,
 		viewType: string,
-		title: string,
+		initData: {
+			title: string;
+			webviewOptions: extHostProtocol.IWebviewOptions;
+			panelOptions: extHostProtocol.IWebviewPanelOptions;
+		},
 		showOptions: { viewColumn?: EditorGroupColumn, preserveFocus?: boolean; },
-		options: WebviewInputOptions
 	): void {
 		const mainThreadShowOptions: ICreateWebViewShowOptions = Object.create(null);
 		if (showOptions) {
@@ -163,7 +167,7 @@ export class MainThreadWebviewPanels extends Disposable implements extHostProtoc
 
 		const extension = reviveWebviewExtension(extensionData);
 
-		const webview = this._webviewWorkbenchService.createWebview(handle, this.webviewPanelViewType.fromExternal(viewType), title, mainThreadShowOptions, reviveWebviewOptions(options), extension);
+		const webview = this._webviewWorkbenchService.createWebview(handle, this.webviewPanelViewType.fromExternal(viewType), initData.title, mainThreadShowOptions, reviveWebviewOptions(initData.panelOptions), reviveWebviewContentOptions(initData.webviewOptions), extension);
 		this.addWebviewInput(handle, webview);
 
 		/* __GDPR__
@@ -231,7 +235,12 @@ export class MainThreadWebviewPanels extends Disposable implements extHostProtoc
 				}
 
 				try {
-					await this._proxy.$deserializeWebviewPanel(handle, viewType, webviewInput.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), webviewInput.webview.options);
+					await this._proxy.$deserializeWebviewPanel(handle, viewType, {
+						title: webviewInput.getTitle(),
+						state,
+						panelOptions: webviewInput.webview.options,
+						webviewOptions: webviewInput.webview.contentOptions,
+					}, editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0));
 				} catch (error) {
 					onUnexpectedError(error);
 					webviewInput.webview.html = this._mainThreadWebviews.getWebviewResolvedFailedContent(viewType);
@@ -324,7 +333,6 @@ export class MainThreadWebviewPanels extends Disposable implements extHostProtoc
 	}
 }
 
-
 function reviveWebviewIcon(
 	value: { light: UriComponents, dark: UriComponents; } | undefined
 ): WebviewIcons | undefined {
@@ -333,3 +341,9 @@ function reviveWebviewIcon(
 		: undefined;
 }
 
+function reviveWebviewOptions(panelOptions: extHostProtocol.IWebviewPanelOptions): WebviewOptions {
+	return {
+		enableFindWidget: panelOptions.enableFindWidget,
+		retainContextWhenHidden: panelOptions.retainContextWhenHidden,
+	};
+}

lib/vscode/src/vs/workbench/api/browser/mainThreadWebviews.ts

@@ -8,14 +8,12 @@ import { Schemas } from 'vs/base/common/network';
 import { isWeb } from 'vs/base/common/platform';
 import { escape } from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
-import { IWebviewOptions } from 'vs/editor/common/modes';
 import { localize } from 'vs/nls';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { IProductService } from 'vs/platform/product/common/productService';
 import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
-import { Webview, WebviewExtensionDescription, WebviewOverlay } from 'vs/workbench/contrib/webview/browser/webview';
-import { WebviewInputOptions } from 'vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { Webview, WebviewContentOptions, WebviewExtensionDescription, WebviewOverlay } from 'vs/workbench/contrib/webview/browser/webview';
 
 export class MainThreadWebviews extends Disposable implements extHostProtocol.MainThreadWebviewsShape {
 
@@ -42,6 +40,10 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 	}
 
 	public addWebview(handle: extHostProtocol.WebviewHandle, webview: WebviewOverlay): void {
+		if (this._webviews.has(handle)) {
+			throw new Error('Webview already registered');
+		}
+
 		this._webviews.set(handle, webview);
 		this.hookupWebviewEventDelegate(handle, webview);
 	}
@@ -51,9 +53,9 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 		webview.html = value;
 	}
 
-	public $setOptions(handle: extHostProtocol.WebviewHandle, options: IWebviewOptions): void {
+	public $setOptions(handle: extHostProtocol.WebviewHandle, options: extHostProtocol.IWebviewOptions): void {
 		const webview = this.getWebview(handle);
-		webview.contentOptions = reviveWebviewOptions(options);
+		webview.contentOptions = reviveWebviewContentOptions(options);
 	}
 
 	public async $postMessage(handle: extHostProtocol.WebviewHandle, message: any): Promise<boolean> {
@@ -116,10 +118,11 @@ export function reviveWebviewExtension(extensionData: extHostProtocol.WebviewExt
 	return { id: extensionData.id, location: URI.revive(extensionData.location) };
 }
 
-export function reviveWebviewOptions(options: IWebviewOptions): WebviewInputOptions {
+export function reviveWebviewContentOptions(webviewOptions: extHostProtocol.IWebviewOptions): WebviewContentOptions {
 	return {
-		...options,
-		allowScripts: options.enableScripts,
-		localResourceRoots: Array.isArray(options.localResourceRoots) ? options.localResourceRoots.map(r => URI.revive(r)) : undefined,
+		allowScripts: webviewOptions.enableScripts,
+		enableCommandUris: webviewOptions.enableCommandUris,
+		localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? webviewOptions.localResourceRoots.map(r => URI.revive(r)) : undefined,
+		portMapping: webviewOptions.portMapping,
 	};
 }

lib/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.ts

@@ -16,7 +16,7 @@ import { IInstantiationService } from 'vs/platform/instantiation/common/instanti
 import { ILabelService } from 'vs/platform/label/common/label';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { IRequestService } from 'vs/platform/request/common/request';
-import { WorkspaceTrustStateChangeEvent, IWorkspaceTrustService, WorkspaceTrustState } from 'vs/platform/workspace/common/workspaceTrust';
+import { WorkspaceTrustStateChangeEvent, IWorkspaceTrustService, WorkspaceTrustRequestOptions, WorkspaceTrustState } from 'vs/platform/workspace/common/workspaceTrust';
 import { IWorkspace, IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { isUntitledWorkspace } from 'vs/platform/workspaces/common/workspaces';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
@@ -208,8 +208,8 @@ export class MainThreadWorkspace implements MainThreadWorkspaceShape {
 
 	// --- trust ---
 
-	$requireWorkspaceTrust(modal?: boolean): Promise<WorkspaceTrustState> {
-		return this._workspaceTrustService.requireWorkspaceTrust({ modal: modal ?? true });
+	$requireWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<WorkspaceTrustState> {
+		return this._workspaceTrustService.requireWorkspaceTrust(options);
 	}
 
 	private getWorkspaceTrustState(): WorkspaceTrustState {