Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/src/vs/workbench/api/browser/extensionHost.contribution.ts

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IWorkbenchContribution, IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions } from 'vs/workbench/common/contributions';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle';
+
+// --- other interested parties
+import { JSONValidationExtensionPoint } from 'vs/workbench/api/common/jsonValidationExtensionPoint';
+import { ColorExtensionPoint } from 'vs/workbench/services/themes/common/colorExtensionPoint';
+import { TokenClassificationExtensionPoints } from 'vs/workbench/services/themes/common/tokenClassificationExtensionPoint';
+import { LanguageConfigurationFileHandler } from 'vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint';
+
+// --- mainThread participants
+import './mainThreadBulkEdits';
+import './mainThreadCodeInsets';
+import './mainThreadClipboard';
+import './mainThreadCommands';
+import './mainThreadConfiguration';
+import './mainThreadConsole';
+import './mainThreadDebugService';
+import './mainThreadDecorations';
+import './mainThreadDiagnostics';
+import './mainThreadDialogs';
+import './mainThreadDocumentContentProviders';
+import './mainThreadDocuments';
+import './mainThreadDocumentsAndEditors';
+import './mainThreadEditor';
+import './mainThreadEditors';
+import './mainThreadErrors';
+import './mainThreadExtensionService';
+import './mainThreadFileSystem';
+import './mainThreadFileSystemEventService';
+import './mainThreadKeytar';
+import './mainThreadLanguageFeatures';
+import './mainThreadLanguages';
+import './mainThreadLogService';
+import './mainThreadMessageService';
+import './mainThreadOutputService';
+import './mainThreadProgress';
+import './mainThreadQuickOpen';
+import './mainThreadRemoteConnectionData';
+import './mainThreadSaveParticipant';
+import './mainThreadSCM';
+import './mainThreadSearch';
+import './mainThreadStatusBar';
+import './mainThreadStorage';
+import './mainThreadTelemetry';
+import './mainThreadTerminalService';
+import './mainThreadTheming';
+import './mainThreadTreeViews';
+import './mainThreadDownloadService';
+import './mainThreadUrls';
+import './mainThreadWindow';
+import './mainThreadWebviewManager';
+import './mainThreadWorkspace';
+import './mainThreadComments';
+import './mainThreadNotebook';
+import './mainThreadTask';
+import './mainThreadLabelService';
+import './mainThreadTunnelService';
+import './mainThreadAuthentication';
+import './mainThreadTimeline';
+import 'vs/workbench/api/common/apiCommands';
+
+export class ExtensionPoints implements IWorkbenchContribution {
+
+	constructor(
+		@IInstantiationService private readonly instantiationService: IInstantiationService
+	) {
+		// Classes that handle extension points...
+		this.instantiationService.createInstance(JSONValidationExtensionPoint);
+		this.instantiationService.createInstance(ColorExtensionPoint);
+		this.instantiationService.createInstance(TokenClassificationExtensionPoints);
+		this.instantiationService.createInstance(LanguageConfigurationFileHandler);
+	}
+}
+
+Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).registerWorkbenchContribution(ExtensionPoints, LifecyclePhase.Starting);

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

@@ -0,0 +1,508 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import * as modes from 'vs/editor/common/modes';
+import * as nls from 'vs/nls';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IAuthenticationService, AllowedExtension, readAllowedExtensions, getAuthenticationProviderActivationEvent } from 'vs/workbench/services/authentication/browser/authenticationService';
+import { ExtHostAuthenticationShape, ExtHostContext, IExtHostContext, MainContext, MainThreadAuthenticationShape } from '../common/extHost.protocol';
+import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import Severity from 'vs/base/common/severity';
+import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { IStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
+import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
+import { fromNow } from 'vs/base/common/date';
+import { ActivationKind, IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { isWeb } from 'vs/base/common/platform';
+import { IEncryptionService } from 'vs/workbench/services/encryption/common/encryptionService';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { ICredentialsService } from 'vs/workbench/services/credentials/common/credentials';
+
+const VSO_ALLOWED_EXTENSIONS = ['github.vscode-pull-request-github', 'github.vscode-pull-request-github-insiders', 'vscode.git', 'ms-vsonline.vsonline', 'vscode.github-browser', 'ms-vscode.github-browser'];
+
+interface IAccountUsage {
+	extensionId: string;
+	extensionName: string;
+	lastUsed: number;
+}
+
+function readAccountUsages(storageService: IStorageService, providerId: string, accountName: string,): IAccountUsage[] {
+	const accountKey = `${providerId}-${accountName}-usages`;
+	const storedUsages = storageService.get(accountKey, StorageScope.GLOBAL);
+	let usages: IAccountUsage[] = [];
+	if (storedUsages) {
+		try {
+			usages = JSON.parse(storedUsages);
+		} catch (e) {
+			// ignore
+		}
+	}
+
+	return usages;
+}
+
+function removeAccountUsage(storageService: IStorageService, providerId: string, accountName: string): void {
+	const accountKey = `${providerId}-${accountName}-usages`;
+	storageService.remove(accountKey, StorageScope.GLOBAL);
+}
+
+function addAccountUsage(storageService: IStorageService, providerId: string, accountName: string, extensionId: string, extensionName: string) {
+	const accountKey = `${providerId}-${accountName}-usages`;
+	const usages = readAccountUsages(storageService, providerId, accountName);
+
+	const existingUsageIndex = usages.findIndex(usage => usage.extensionId === extensionId);
+	if (existingUsageIndex > -1) {
+		usages.splice(existingUsageIndex, 1, {
+			extensionId,
+			extensionName,
+			lastUsed: Date.now()
+		});
+	} else {
+		usages.push({
+			extensionId,
+			extensionName,
+			lastUsed: Date.now()
+		});
+	}
+
+	storageService.store(accountKey, JSON.stringify(usages), StorageScope.GLOBAL);
+}
+
+export class MainThreadAuthenticationProvider extends Disposable {
+	private _accounts = new Map<string, string[]>(); // Map account name to session ids
+	private _sessions = new Map<string, string>(); // Map account id to name
+
+	constructor(
+		private readonly _proxy: ExtHostAuthenticationShape,
+		public readonly id: string,
+		public readonly label: string,
+		public readonly supportsMultipleAccounts: boolean,
+		private readonly notificationService: INotificationService,
+		private readonly storageKeysSyncRegistryService: IStorageKeysSyncRegistryService,
+		private readonly storageService: IStorageService,
+		private readonly quickInputService: IQuickInputService,
+		private readonly dialogService: IDialogService
+	) {
+		super();
+	}
+
+	public async initialize(): Promise<void> {
+		return this.registerCommandsAndContextMenuItems();
+	}
+
+	public hasSessions(): boolean {
+		return !!this._sessions.size;
+	}
+
+	public manageTrustedExtensions(accountName: string) {
+		const quickPick = this.quickInputService.createQuickPick<{ label: string, description: string, extension: AllowedExtension }>();
+		quickPick.canSelectMany = true;
+		const allowedExtensions = readAllowedExtensions(this.storageService, this.id, accountName);
+		const usages = readAccountUsages(this.storageService, this.id, accountName);
+		const items = allowedExtensions.map(extension => {
+			const usage = usages.find(usage => extension.id === usage.extensionId);
+			return {
+				label: extension.name,
+				description: usage
+					? nls.localize({ key: 'accountLastUsedDate', comment: ['The placeholder {0} is a string with time information, such as "3 days ago"'] }, "Last used this account {0}", fromNow(usage.lastUsed, true))
+					: nls.localize('notUsed', "Has not used this account"),
+				extension
+			};
+		});
+
+		quickPick.items = items;
+		quickPick.selectedItems = items;
+		quickPick.title = nls.localize('manageTrustedExtensions', "Manage Trusted Extensions");
+		quickPick.placeholder = nls.localize('manageExensions', "Choose which extensions can access this account");
+
+		quickPick.onDidAccept(() => {
+			const updatedAllowedList = quickPick.selectedItems.map(item => item.extension);
+			this.storageService.store(`${this.id}-${accountName}`, JSON.stringify(updatedAllowedList), StorageScope.GLOBAL);
+
+			quickPick.dispose();
+		});
+
+		quickPick.onDidHide(() => {
+			quickPick.dispose();
+		});
+
+		quickPick.show();
+	}
+
+	private async registerCommandsAndContextMenuItems(): Promise<void> {
+		try {
+			const sessions = await this._proxy.$getSessions(this.id);
+			sessions.forEach(session => this.registerSession(session));
+		} catch (_) {
+			// Ignore
+		}
+	}
+
+	private registerSession(session: modes.AuthenticationSession) {
+		this._sessions.set(session.id, session.account.label);
+
+		const existingSessionsForAccount = this._accounts.get(session.account.label);
+		if (existingSessionsForAccount) {
+			this._accounts.set(session.account.label, existingSessionsForAccount.concat(session.id));
+			return;
+		} else {
+			this._accounts.set(session.account.label, [session.id]);
+		}
+
+		this.storageKeysSyncRegistryService.registerStorageKey({ key: `${this.id}-${session.account.label}`, version: 1 });
+	}
+
+	async signOut(accountName: string): Promise<void> {
+		const accountUsages = readAccountUsages(this.storageService, this.id, accountName);
+		const sessionsForAccount = this._accounts.get(accountName);
+
+		const result = await this.dialogService.confirm({
+			title: nls.localize('signOutConfirm', "Sign out of {0}", accountName),
+			message: accountUsages.length
+				? nls.localize('signOutMessagve', "The account {0} has been used by: \n\n{1}\n\n Sign out of these features?", accountName, accountUsages.map(usage => usage.extensionName).join('\n'))
+				: nls.localize('signOutMessageSimple', "Sign out of {0}?", accountName)
+		});
+
+		if (result.confirmed) {
+			sessionsForAccount?.forEach(sessionId => this.logout(sessionId));
+			removeAccountUsage(this.storageService, this.id, accountName);
+		}
+	}
+
+	async getSessions(): Promise<ReadonlyArray<modes.AuthenticationSession>> {
+		return this._proxy.$getSessions(this.id);
+	}
+
+	async updateSessionItems(event: modes.AuthenticationSessionsChangeEvent): Promise<void> {
+		const { added, removed } = event;
+		const session = await this._proxy.$getSessions(this.id);
+		const addedSessions = session.filter(session => added.some(id => id === session.id));
+
+		removed.forEach(sessionId => {
+			const accountName = this._sessions.get(sessionId);
+			if (accountName) {
+				this._sessions.delete(sessionId);
+				let sessionsForAccount = this._accounts.get(accountName) || [];
+				const sessionIndex = sessionsForAccount.indexOf(sessionId);
+				sessionsForAccount.splice(sessionIndex);
+
+				if (!sessionsForAccount.length) {
+					this._accounts.delete(accountName);
+				}
+			}
+		});
+
+		addedSessions.forEach(session => this.registerSession(session));
+	}
+
+	login(scopes: string[]): Promise<modes.AuthenticationSession> {
+		return this._proxy.$login(this.id, scopes);
+	}
+
+	async logout(sessionId: string): Promise<void> {
+		await this._proxy.$logout(this.id, sessionId);
+		this.notificationService.info(nls.localize('signedOut', "Successfully signed out."));
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadAuthentication)
+export class MainThreadAuthentication extends Disposable implements MainThreadAuthenticationShape {
+	private readonly _proxy: ExtHostAuthenticationShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IAuthenticationService private readonly authenticationService: IAuthenticationService,
+		@IDialogService private readonly dialogService: IDialogService,
+		@IStorageService private readonly storageService: IStorageService,
+		@INotificationService private readonly notificationService: INotificationService,
+		@IStorageKeysSyncRegistryService private readonly storageKeysSyncRegistryService: IStorageKeysSyncRegistryService,
+		@IRemoteAgentService private readonly remoteAgentService: IRemoteAgentService,
+		@IQuickInputService private readonly quickInputService: IQuickInputService,
+		@IExtensionService private readonly extensionService: IExtensionService,
+		@ICredentialsService private readonly credentialsService: ICredentialsService,
+		@IEncryptionService private readonly encryptionService: IEncryptionService,
+		@IProductService private readonly productService: IProductService
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostAuthentication);
+
+		this._register(this.authenticationService.onDidChangeSessions(e => {
+			this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label, e.event);
+		}));
+
+		this._register(this.authenticationService.onDidRegisterAuthenticationProvider(info => {
+			this._proxy.$onDidChangeAuthenticationProviders([info], []);
+		}));
+
+		this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(info => {
+			this._proxy.$onDidChangeAuthenticationProviders([], [info]);
+		}));
+
+		this._proxy.$setProviders(this.authenticationService.declaredProviders);
+
+		this._register(this.authenticationService.onDidChangeDeclaredProviders(e => {
+			this._proxy.$setProviders(e);
+		}));
+
+		this._register(this.credentialsService.onDidChangePassword(_ => {
+			this._proxy.$onDidChangePassword();
+		}));
+	}
+
+	$getProviderIds(): Promise<string[]> {
+		return Promise.resolve(this.authenticationService.getProviderIds());
+	}
+
+	async $registerAuthenticationProvider(id: string, label: string, supportsMultipleAccounts: boolean): Promise<void> {
+		const provider = new MainThreadAuthenticationProvider(this._proxy, id, label, supportsMultipleAccounts, this.notificationService, this.storageKeysSyncRegistryService, this.storageService, this.quickInputService, this.dialogService);
+		await provider.initialize();
+		this.authenticationService.registerAuthenticationProvider(id, provider);
+	}
+
+	$unregisterAuthenticationProvider(id: string): void {
+		this.authenticationService.unregisterAuthenticationProvider(id);
+	}
+
+	$ensureProvider(id: string): Promise<void> {
+		return this.extensionService.activateByEvent(getAuthenticationProviderActivationEvent(id), ActivationKind.Immediate);
+	}
+
+	$sendDidChangeSessions(id: string, event: modes.AuthenticationSessionsChangeEvent): void {
+		this.authenticationService.sessionsUpdate(id, event);
+	}
+
+	$getSessions(id: string): Promise<ReadonlyArray<modes.AuthenticationSession>> {
+		return this.authenticationService.getSessions(id);
+	}
+
+	$login(providerId: string, scopes: string[]): Promise<modes.AuthenticationSession> {
+		return this.authenticationService.login(providerId, scopes);
+	}
+
+	$logout(providerId: string, sessionId: string): Promise<void> {
+		return this.authenticationService.logout(providerId, sessionId);
+	}
+
+	async $requestNewSession(providerId: string, scopes: string[], extensionId: string, extensionName: string): Promise<void> {
+		return this.authenticationService.requestNewSession(providerId, scopes, extensionId, extensionName);
+	}
+
+	async $getSession(providerId: string, scopes: string[], extensionId: string, extensionName: string, options: { createIfNone: boolean, clearSessionPreference: boolean }): Promise<modes.AuthenticationSession | undefined> {
+		const orderedScopes = scopes.sort().join(' ');
+		const sessions = (await this.$getSessions(providerId)).filter(session => session.scopes.slice().sort().join(' ') === orderedScopes);
+		const label = this.authenticationService.getLabel(providerId);
+
+		if (sessions.length) {
+			if (!this.authenticationService.supportsMultipleAccounts(providerId)) {
+				const session = sessions[0];
+				const allowed = await this.$getSessionsPrompt(providerId, session.account.label, label, extensionId, extensionName);
+				if (allowed) {
+					return session;
+				} else {
+					throw new Error('User did not consent to login.');
+				}
+			}
+
+			// On renderer side, confirm consent, ask user to choose between accounts if multiple sessions are valid
+			const selected = await this.$selectSession(providerId, label, extensionId, extensionName, sessions, scopes, !!options.clearSessionPreference);
+			return sessions.find(session => session.id === selected.id);
+		} else {
+			if (options.createIfNone) {
+				const isAllowed = await this.$loginPrompt(label, extensionName);
+				if (!isAllowed) {
+					throw new Error('User did not consent to login.');
+				}
+
+				const session = await this.authenticationService.login(providerId, scopes);
+				await this.$setTrustedExtensionAndAccountPreference(providerId, session.account.label, extensionId, extensionName, session.id);
+				return session;
+			} else {
+				await this.$requestNewSession(providerId, scopes, extensionId, extensionName);
+				return undefined;
+			}
+		}
+	}
+
+	async $selectSession(providerId: string, providerName: string, extensionId: string, extensionName: string, potentialSessions: modes.AuthenticationSession[], scopes: string[], clearSessionPreference: boolean): Promise<modes.AuthenticationSession> {
+		if (!potentialSessions.length) {
+			throw new Error('No potential sessions found');
+		}
+
+		if (clearSessionPreference) {
+			this.storageService.remove(`${extensionName}-${providerId}`, StorageScope.GLOBAL);
+		} else {
+			const existingSessionPreference = this.storageService.get(`${extensionName}-${providerId}`, StorageScope.GLOBAL);
+			if (existingSessionPreference) {
+				const matchingSession = potentialSessions.find(session => session.id === existingSessionPreference);
+				if (matchingSession) {
+					const allowed = await this.$getSessionsPrompt(providerId, matchingSession.account.label, providerName, extensionId, extensionName);
+					if (allowed) {
+						return matchingSession;
+					}
+				}
+			}
+		}
+
+		return new Promise((resolve, reject) => {
+			const quickPick = this.quickInputService.createQuickPick<{ label: string, session?: modes.AuthenticationSession }>();
+			quickPick.ignoreFocusOut = true;
+			const items: { label: string, session?: modes.AuthenticationSession }[] = potentialSessions.map(session => {
+				return {
+					label: session.account.label,
+					session
+				};
+			});
+
+			items.push({
+				label: nls.localize('useOtherAccount', "Sign in to another account")
+			});
+
+			quickPick.items = items;
+			quickPick.title = nls.localize(
+				{
+					key: 'selectAccount',
+					comment: ['The placeholder {0} is the name of an extension. {1} is the name of the type of account, such as Microsoft or GitHub.']
+				},
+				"The extension '{0}' wants to access a {1} account",
+				extensionName,
+				providerName);
+			quickPick.placeholder = nls.localize('getSessionPlateholder', "Select an account for '{0}' to use or Esc to cancel", extensionName);
+
+			quickPick.onDidAccept(async _ => {
+				const selected = quickPick.selectedItems[0];
+
+				const session = selected.session ?? await this.authenticationService.login(providerId, scopes);
+
+				const accountName = session.account.label;
+
+				const allowList = readAllowedExtensions(this.storageService, providerId, accountName);
+				if (!allowList.find(allowed => allowed.id === extensionId)) {
+					allowList.push({ id: extensionId, name: extensionName });
+					this.storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), StorageScope.GLOBAL);
+				}
+
+				this.storageService.store(`${extensionName}-${providerId}`, session.id, StorageScope.GLOBAL);
+
+				quickPick.dispose();
+				resolve(session);
+			});
+
+			quickPick.onDidHide(_ => {
+				if (!quickPick.selectedItems[0]) {
+					reject('User did not consent to account access');
+				}
+
+				quickPick.dispose();
+			});
+
+			quickPick.show();
+		});
+	}
+
+	async $getSessionsPrompt(providerId: string, accountName: string, providerName: string, extensionId: string, extensionName: string): Promise<boolean> {
+		const allowList = readAllowedExtensions(this.storageService, providerId, accountName);
+		const extensionData = allowList.find(extension => extension.id === extensionId);
+		if (extensionData) {
+			addAccountUsage(this.storageService, providerId, accountName, extensionId, extensionName);
+			return true;
+		}
+
+		const remoteConnection = this.remoteAgentService.getConnection();
+		const isVSO = remoteConnection !== null
+			? remoteConnection.remoteAuthority.startsWith('vsonline')
+			: isWeb;
+
+		if (isVSO && VSO_ALLOWED_EXTENSIONS.includes(extensionId)) {
+			addAccountUsage(this.storageService, providerId, accountName, extensionId, extensionName);
+			return true;
+		}
+
+		const { choice } = await this.dialogService.show(
+			Severity.Info,
+			nls.localize('confirmAuthenticationAccess', "The extension '{0}' wants to access the {1} account '{2}'.", extensionName, providerName, accountName),
+			[nls.localize('allow', "Allow"), nls.localize('cancel', "Cancel")],
+			{
+				cancelId: 1
+			}
+		);
+
+		const allow = choice === 0;
+		if (allow) {
+			addAccountUsage(this.storageService, providerId, accountName, extensionId, extensionName);
+			allowList.push({ id: extensionId, name: extensionName });
+			this.storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), StorageScope.GLOBAL);
+		}
+
+		return allow;
+	}
+
+	async $loginPrompt(providerName: string, extensionName: string): Promise<boolean> {
+		const { choice } = await this.dialogService.show(
+			Severity.Info,
+			nls.localize('confirmLogin', "The extension '{0}' wants to sign in using {1}.", extensionName, providerName),
+			[nls.localize('allow', "Allow"), nls.localize('cancel', "Cancel")],
+			{
+				cancelId: 1
+			}
+		);
+
+		return choice === 0;
+	}
+
+	async $setTrustedExtensionAndAccountPreference(providerId: string, accountName: string, extensionId: string, extensionName: string, sessionId: string): Promise<void> {
+		const allowList = readAllowedExtensions(this.storageService, providerId, accountName);
+		if (!allowList.find(allowed => allowed.id === extensionId)) {
+			allowList.push({ id: extensionId, name: extensionName });
+			this.storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), StorageScope.GLOBAL);
+		}
+
+		this.storageService.store(`${extensionName}-${providerId}`, sessionId, StorageScope.GLOBAL);
+	}
+
+	private getFullKey(extensionId: string): string {
+		return `${this.productService.urlProtocol}${extensionId}`;
+	}
+
+	async $getPassword(extensionId: string, key: string): Promise<string | undefined> {
+		const fullKey = this.getFullKey(extensionId);
+		const password = await this.credentialsService.getPassword(fullKey, key);
+		const decrypted = password && await this.encryptionService.decrypt(password);
+
+		if (decrypted) {
+			try {
+				const value = JSON.parse(decrypted);
+				if (value.extensionId === extensionId) {
+					return value.content;
+				}
+			} catch (_) {
+				throw new Error('Cannot get password');
+			}
+		}
+
+		return undefined;
+	}
+
+	async $setPassword(extensionId: string, key: string, value: string): Promise<void> {
+		const fullKey = this.getFullKey(extensionId);
+		const toEncrypt = JSON.stringify({
+			extensionId,
+			content: value
+		});
+		const encrypted = await this.encryptionService.encrypt(toEncrypt);
+		return this.credentialsService.setPassword(fullKey, key, encrypted);
+	}
+
+	async $deletePassword(extensionId: string, key: string): Promise<void> {
+		try {
+			const fullKey = this.getFullKey(extensionId);
+			await this.credentialsService.deletePassword(fullKey, key);
+		} catch (_) {
+			throw new Error('Cannot delete password');
+		}
+	}
+}

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

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IBulkEditService, ResourceEdit, ResourceFileEdit, ResourceTextEdit } from 'vs/editor/browser/services/bulkEditService';
+import { IExtHostContext, IWorkspaceEditDto, WorkspaceEditType, MainThreadBulkEditsShape, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { revive } from 'vs/base/common/marshalling';
+import { ResourceNotebookCellEdit } from 'vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+
+function reviveWorkspaceEditDto2(data: IWorkspaceEditDto | undefined): ResourceEdit[] {
+	if (!data?.edits) {
+		return [];
+	}
+
+	const result: ResourceEdit[] = [];
+	for (let edit of revive<IWorkspaceEditDto>(data).edits) {
+		if (edit._type === WorkspaceEditType.File) {
+			result.push(new ResourceFileEdit(edit.oldUri, edit.newUri, edit.options, edit.metadata));
+		} else if (edit._type === WorkspaceEditType.Text) {
+			result.push(new ResourceTextEdit(edit.resource, edit.edit, edit.modelVersionId, edit.metadata));
+		} else if (edit._type === WorkspaceEditType.Cell) {
+			result.push(new ResourceNotebookCellEdit(edit.resource, edit.edit, edit.notebookVersionId, edit.metadata));
+		}
+	}
+	return result;
+}
+
+@extHostNamedCustomer(MainContext.MainThreadBulkEdits)
+export class MainThreadBulkEdits implements MainThreadBulkEditsShape {
+
+	constructor(
+		_extHostContext: IExtHostContext,
+		@IBulkEditService private readonly _bulkEditService: IBulkEditService,
+	) { }
+
+	dispose(): void { }
+
+	$tryApplyWorkspaceEdit(dto: IWorkspaceEditDto): Promise<boolean> {
+		const edits = reviveWorkspaceEditDto2(dto);
+		return this._bulkEditService.apply(edits).then(() => true, _err => false);
+	}
+}

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

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainContext, MainThreadClipboardShape } from '../common/extHost.protocol';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+
+@extHostNamedCustomer(MainContext.MainThreadClipboard)
+export class MainThreadClipboard implements MainThreadClipboardShape {
+
+	constructor(
+		_context: any,
+		@IClipboardService private readonly _clipboardService: IClipboardService,
+	) { }
+
+	dispose(): void {
+		// nothing
+	}
+
+	$readText(): Promise<string> {
+		return this._clipboardService.readText();
+	}
+
+	$writeText(value: string): Promise<void> {
+		return this._clipboardService.writeText(value);
+	}
+}

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

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  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';
+
+// todo@joh move these things back into something like contrib/insets
+class EditorWebviewZone implements IViewZone {
+
+	readonly domNode: HTMLElement;
+	readonly afterLineNumber: number;
+	readonly afterColumn: number;
+	readonly heightInLines: number;
+
+	private _id?: string;
+	// suppressMouseDown?: boolean | undefined;
+	// heightInPx?: number | undefined;
+	// minWidthInPx?: number | undefined;
+	// marginDomNode?: HTMLElement | null | undefined;
+	// onDomNodeTop?: ((top: number) => void) | undefined;
+	// onComputedHeight?: ((height: number) => void) | undefined;
+
+	constructor(
+		readonly editor: IActiveCodeEditor,
+		readonly line: number,
+		readonly height: number,
+		readonly webview: WebviewElement,
+	) {
+		this.domNode = document.createElement('div');
+		this.domNode.style.zIndex = '10'; // without this, the webview is not interactive
+		this.afterLineNumber = line;
+		this.afterColumn = 1;
+		this.heightInLines = height;
+
+		editor.changeViewZones(accessor => this._id = accessor.addZone(this));
+		webview.mountTo(this.domNode);
+	}
+
+	dispose(): void {
+		this.editor.changeViewZones(accessor => this._id && accessor.removeZone(this._id));
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadEditorInsets)
+export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
+
+	private readonly _proxy: ExtHostEditorInsetsShape;
+	private readonly _disposables = new DisposableStore();
+	private readonly _insets = new Map<number, EditorWebviewZone>();
+
+	constructor(
+		context: IExtHostContext,
+		@ICodeEditorService private readonly _editorService: ICodeEditorService,
+		@IWebviewService private readonly _webviewService: IWebviewService,
+	) {
+		this._proxy = context.getProxy(ExtHostContext.ExtHostEditorInsets);
+	}
+
+	dispose(): void {
+		this._disposables.dispose();
+	}
+
+	async $createEditorInset(handle: number, id: string, uri: UriComponents, line: number, height: number, options: modes.IWebviewOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): Promise<void> {
+
+		let editor: IActiveCodeEditor | undefined;
+		id = id.substr(0, id.indexOf(',')); //todo@joh HACK
+
+		for (const candidate of this._editorService.listCodeEditors()) {
+			if (candidate.getId() === id && candidate.hasModel() && isEqual(candidate.getModel().uri, URI.revive(uri))) {
+				editor = candidate;
+				break;
+			}
+		}
+
+		if (!editor) {
+			setTimeout(() => this._proxy.$onDidDispose(handle));
+			return;
+		}
+
+		const disposables = new DisposableStore();
+
+		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) });
+
+		const webviewZone = new EditorWebviewZone(editor, line, height, webview);
+
+		const remove = () => {
+			disposables.dispose();
+			this._proxy.$onDidDispose(handle);
+			this._insets.delete(handle);
+		};
+
+		disposables.add(editor.onDidChangeModel(remove));
+		disposables.add(editor.onDidDispose(remove));
+		disposables.add(webviewZone);
+		disposables.add(webview);
+		disposables.add(webview.onMessage(msg => this._proxy.$onDidReceiveMessage(handle, msg)));
+
+		this._insets.set(handle, webviewZone);
+	}
+
+	$disposeEditorInset(handle: number): void {
+		const inset = this.getInset(handle);
+		this._insets.delete(handle);
+		inset.dispose();
+
+	}
+
+	$setHtml(handle: number, value: string): void {
+		const inset = this.getInset(handle);
+		inset.webview.html = value;
+	}
+
+	$setOptions(handle: number, options: modes.IWebviewOptions): void {
+		const inset = this.getInset(handle);
+		inset.webview.contentOptions = {
+			...options,
+			localResourceRoots: options.localResourceRoots?.map(components => URI.from(components)),
+		};
+	}
+
+	async $postMessage(handle: number, value: any): Promise<boolean> {
+		const inset = this.getInset(handle);
+		inset.webview.postMessage(value);
+		return true;
+	}
+
+	private getInset(handle: number): EditorWebviewZone {
+		const inset = this._insets.get(handle);
+		if (!inset) {
+			throw new Error('Unknown inset');
+		}
+		return inset;
+	}
+}

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

@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ICommandService, CommandsRegistry, ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { ExtHostContext, MainThreadCommandsShape, ExtHostCommandsShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { revive } from 'vs/base/common/marshalling';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+
+@extHostNamedCustomer(MainContext.MainThreadCommands)
+export class MainThreadCommands implements MainThreadCommandsShape {
+
+	private readonly _commandRegistrations = new Map<string, IDisposable>();
+	private readonly _generateCommandsDocumentationRegistration: IDisposable;
+	private readonly _proxy: ExtHostCommandsShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ICommandService private readonly _commandService: ICommandService,
+		@IExtensionService private readonly _extensionService: IExtensionService,
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostCommands);
+
+		this._generateCommandsDocumentationRegistration = CommandsRegistry.registerCommand('_generateCommandsDocumentation', () => this._generateCommandsDocumentation());
+	}
+
+	dispose() {
+		dispose(this._commandRegistrations.values());
+		this._commandRegistrations.clear();
+
+		this._generateCommandsDocumentationRegistration.dispose();
+	}
+
+	private _generateCommandsDocumentation(): Promise<void> {
+		return this._proxy.$getContributedCommandHandlerDescriptions().then(result => {
+			// add local commands
+			const commands = CommandsRegistry.getCommands();
+			for (const [id, command] of commands) {
+				if (command.description) {
+					result[id] = command.description;
+				}
+			}
+
+			// print all as markdown
+			const all: string[] = [];
+			for (let id in result) {
+				all.push('`' + id + '` - ' + _generateMarkdown(result[id]));
+			}
+			console.log(all.join('\n'));
+		});
+	}
+
+	$registerCommand(id: string): void {
+		this._commandRegistrations.set(
+			id,
+			CommandsRegistry.registerCommand(id, (accessor, ...args) => {
+				return this._proxy.$executeContributedCommand(id, ...args).then(result => {
+					return revive(result);
+				});
+			})
+		);
+	}
+
+	$unregisterCommand(id: string): void {
+		const command = this._commandRegistrations.get(id);
+		if (command) {
+			command.dispose();
+			this._commandRegistrations.delete(id);
+		}
+	}
+
+	async $executeCommand<T>(id: string, args: any[], retry: boolean): Promise<T | undefined> {
+		for (let i = 0; i < args.length; i++) {
+			args[i] = revive(args[i]);
+		}
+		if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
+			await this._extensionService.activateByEvent(`onCommand:${id}`);
+			throw new Error('$executeCommand:retry');
+		}
+		return this._commandService.executeCommand<T>(id, ...args);
+	}
+
+	$getCommands(): Promise<string[]> {
+		return Promise.resolve([...CommandsRegistry.getCommands().keys()]);
+	}
+}
+
+// --- command doc
+
+function _generateMarkdown(description: string | ICommandHandlerDescription): string {
+	if (typeof description === 'string') {
+		return description;
+	} else {
+		const parts = [description.description];
+		parts.push('\n\n');
+		if (description.args) {
+			for (let arg of description.args) {
+				parts.push(`* _${arg.name}_ - ${arg.description || ''}\n`);
+			}
+		}
+		if (description.returns) {
+			parts.push(`* _(returns)_ - ${description.returns}`);
+		}
+		parts.push('\n\n');
+		return parts.join('');
+	}
+}

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

@@ -0,0 +1,540 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable, DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { generateUuid } from 'vs/base/common/uuid';
+import { IRange } from 'vs/editor/common/core/range';
+import * as modes from 'vs/editor/common/modes';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ICommentInfo, ICommentService } from 'vs/workbench/contrib/comments/browser/commentService';
+import { CommentsPanel } from 'vs/workbench/contrib/comments/browser/commentsView';
+import { CommentProviderFeatures, ExtHostCommentsShape, ExtHostContext, IExtHostContext, MainContext, MainThreadCommentsShape, CommentThreadChanges } from '../common/extHost.protocol';
+import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE } from 'vs/workbench/contrib/comments/browser/commentsTreeViewer';
+import { ViewContainer, IViewContainersRegistry, Extensions as ViewExtensions, ViewContainerLocation, IViewsRegistry, IViewsService, IViewDescriptorService } from 'vs/workbench/common/views';
+import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
+import { ViewPaneContainer } from 'vs/workbench/browser/parts/views/viewPaneContainer';
+import { Codicon } from 'vs/base/common/codicons';
+
+
+export class MainThreadCommentThread implements modes.CommentThread {
+	private _input?: modes.CommentInput;
+	get input(): modes.CommentInput | undefined {
+		return this._input;
+	}
+
+	set input(value: modes.CommentInput | undefined) {
+		this._input = value;
+		this._onDidChangeInput.fire(value);
+	}
+
+	private readonly _onDidChangeInput = new Emitter<modes.CommentInput | undefined>();
+	get onDidChangeInput(): Event<modes.CommentInput | undefined> { return this._onDidChangeInput.event; }
+
+	private _label: string | undefined;
+
+	get label(): string | undefined {
+		return this._label;
+	}
+
+	set label(label: string | undefined) {
+		this._label = label;
+		this._onDidChangeLabel.fire(this._label);
+	}
+
+	private _contextValue: string | undefined;
+
+	get contextValue(): string | undefined {
+		return this._contextValue;
+	}
+
+	set contextValue(context: string | undefined) {
+		this._contextValue = context;
+	}
+
+	private readonly _onDidChangeLabel = new Emitter<string | undefined>();
+	readonly onDidChangeLabel: Event<string | undefined> = this._onDidChangeLabel.event;
+
+	private _comments: modes.Comment[] | undefined;
+
+	public get comments(): modes.Comment[] | undefined {
+		return this._comments;
+	}
+
+	public set comments(newComments: modes.Comment[] | undefined) {
+		this._comments = newComments;
+		this._onDidChangeComments.fire(this._comments);
+	}
+
+	private readonly _onDidChangeComments = new Emitter<modes.Comment[] | undefined>();
+	get onDidChangeComments(): Event<modes.Comment[] | undefined> { return this._onDidChangeComments.event; }
+
+	set range(range: IRange) {
+		this._range = range;
+		this._onDidChangeRange.fire(this._range);
+	}
+
+	get range(): IRange {
+		return this._range;
+	}
+
+	private readonly _onDidChangeCanReply = new Emitter<boolean>();
+	get onDidChangeCanReply(): Event<boolean> { return this._onDidChangeCanReply.event; }
+	set canReply(state: boolean) {
+		this._canReply = state;
+		this._onDidChangeCanReply.fire(this._canReply);
+	}
+
+	get canReply() {
+		return this._canReply;
+	}
+
+	private readonly _onDidChangeRange = new Emitter<IRange>();
+	public onDidChangeRange = this._onDidChangeRange.event;
+
+	private _collapsibleState: modes.CommentThreadCollapsibleState | undefined;
+	get collapsibleState() {
+		return this._collapsibleState;
+	}
+
+	set collapsibleState(newState: modes.CommentThreadCollapsibleState | undefined) {
+		this._collapsibleState = newState;
+		this._onDidChangeCollasibleState.fire(this._collapsibleState);
+	}
+
+	private readonly _onDidChangeCollasibleState = new Emitter<modes.CommentThreadCollapsibleState | undefined>();
+	public onDidChangeCollasibleState = this._onDidChangeCollasibleState.event;
+
+	private _isDisposed: boolean;
+
+	get isDisposed(): boolean {
+		return this._isDisposed;
+	}
+
+	constructor(
+		public commentThreadHandle: number,
+		public controllerHandle: number,
+		public extensionId: string,
+		public threadId: string,
+		public resource: string,
+		private _range: IRange,
+		private _canReply: boolean
+	) {
+		this._isDisposed = false;
+	}
+
+	batchUpdate(changes: CommentThreadChanges) {
+		const modified = (value: keyof CommentThreadChanges): boolean =>
+			Object.prototype.hasOwnProperty.call(changes, value);
+
+		if (modified('range')) { this._range = changes.range!; }
+		if (modified('label')) { this._label = changes.label; }
+		if (modified('contextValue')) { this._contextValue = changes.contextValue; }
+		if (modified('comments')) { this._comments = changes.comments; }
+		if (modified('collapseState')) { this._collapsibleState = changes.collapseState; }
+		if (modified('canReply')) { this.canReply = changes.canReply!; }
+	}
+
+	dispose() {
+		this._isDisposed = true;
+		this._onDidChangeCollasibleState.dispose();
+		this._onDidChangeComments.dispose();
+		this._onDidChangeInput.dispose();
+		this._onDidChangeLabel.dispose();
+		this._onDidChangeRange.dispose();
+	}
+
+	toJSON(): any {
+		return {
+			$mid: 7,
+			commentControlHandle: this.controllerHandle,
+			commentThreadHandle: this.commentThreadHandle,
+		};
+	}
+}
+
+export class MainThreadCommentController {
+	get handle(): number {
+		return this._handle;
+	}
+
+	get id(): string {
+		return this._id;
+	}
+
+	get contextValue(): string {
+		return this._id;
+	}
+
+	get proxy(): ExtHostCommentsShape {
+		return this._proxy;
+	}
+
+	get label(): string {
+		return this._label;
+	}
+
+	private _reactions: modes.CommentReaction[] | undefined;
+
+	get reactions() {
+		return this._reactions;
+	}
+
+	set reactions(reactions: modes.CommentReaction[] | undefined) {
+		this._reactions = reactions;
+	}
+
+	get options() {
+		return this._features.options;
+	}
+
+	private readonly _threads: Map<number, MainThreadCommentThread> = new Map<number, MainThreadCommentThread>();
+	public activeCommentThread?: MainThreadCommentThread;
+
+	get features(): CommentProviderFeatures {
+		return this._features;
+	}
+
+	constructor(
+		private readonly _proxy: ExtHostCommentsShape,
+		private readonly _commentService: ICommentService,
+		private readonly _handle: number,
+		private readonly _uniqueId: string,
+		private readonly _id: string,
+		private readonly _label: string,
+		private _features: CommentProviderFeatures
+	) { }
+
+	updateFeatures(features: CommentProviderFeatures) {
+		this._features = features;
+	}
+
+	createCommentThread(extensionId: string,
+		commentThreadHandle: number,
+		threadId: string,
+		resource: UriComponents,
+		range: IRange,
+	): modes.CommentThread {
+		let thread = new MainThreadCommentThread(
+			commentThreadHandle,
+			this.handle,
+			extensionId,
+			threadId,
+			URI.revive(resource).toString(),
+			range,
+			true
+		);
+
+		this._threads.set(commentThreadHandle, thread);
+
+		this._commentService.updateComments(this._uniqueId, {
+			added: [thread],
+			removed: [],
+			changed: []
+		});
+
+		return thread;
+	}
+
+	updateCommentThread(commentThreadHandle: number,
+		threadId: string,
+		resource: UriComponents,
+		changes: CommentThreadChanges): void {
+		let thread = this.getKnownThread(commentThreadHandle);
+		thread.batchUpdate(changes);
+
+		this._commentService.updateComments(this._uniqueId, {
+			added: [],
+			removed: [],
+			changed: [thread]
+		});
+	}
+
+	deleteCommentThread(commentThreadHandle: number) {
+		let thread = this.getKnownThread(commentThreadHandle);
+		this._threads.delete(commentThreadHandle);
+
+		this._commentService.updateComments(this._uniqueId, {
+			added: [],
+			removed: [thread],
+			changed: []
+		});
+
+		thread.dispose();
+	}
+
+	deleteCommentThreadMain(commentThreadId: string) {
+		this._threads.forEach(thread => {
+			if (thread.threadId === commentThreadId) {
+				this._proxy.$deleteCommentThread(this._handle, thread.commentThreadHandle);
+			}
+		});
+	}
+
+	updateInput(input: string) {
+		let thread = this.activeCommentThread;
+
+		if (thread && thread.input) {
+			let commentInput = thread.input;
+			commentInput.value = input;
+			thread.input = commentInput;
+		}
+	}
+
+	private getKnownThread(commentThreadHandle: number): MainThreadCommentThread {
+		const thread = this._threads.get(commentThreadHandle);
+		if (!thread) {
+			throw new Error('unknown thread');
+		}
+		return thread;
+	}
+
+	async getDocumentComments(resource: URI, token: CancellationToken) {
+		let ret: modes.CommentThread[] = [];
+		for (let thread of [...this._threads.keys()]) {
+			const commentThread = this._threads.get(thread)!;
+			if (commentThread.resource === resource.toString()) {
+				ret.push(commentThread);
+			}
+		}
+
+		let commentingRanges = await this._proxy.$provideCommentingRanges(this.handle, resource, token);
+
+		return <ICommentInfo>{
+			owner: this._uniqueId,
+			label: this.label,
+			threads: ret,
+			commentingRanges: {
+				resource: resource,
+				ranges: commentingRanges || []
+			}
+		};
+	}
+
+	async getCommentingRanges(resource: URI, token: CancellationToken): Promise<IRange[]> {
+		let commentingRanges = await this._proxy.$provideCommentingRanges(this.handle, resource, token);
+		return commentingRanges || [];
+	}
+
+	async toggleReaction(uri: URI, thread: modes.CommentThread, comment: modes.Comment, reaction: modes.CommentReaction, token: CancellationToken): Promise<void> {
+		return this._proxy.$toggleReaction(this._handle, thread.commentThreadHandle, uri, comment, reaction);
+	}
+
+	getAllComments(): MainThreadCommentThread[] {
+		let ret: MainThreadCommentThread[] = [];
+		for (let thread of [...this._threads.keys()]) {
+			ret.push(this._threads.get(thread)!);
+		}
+
+		return ret;
+	}
+
+	createCommentThreadTemplate(resource: UriComponents, range: IRange): void {
+		this._proxy.$createCommentThreadTemplate(this.handle, resource, range);
+	}
+
+	async updateCommentThreadTemplate(threadHandle: number, range: IRange) {
+		await this._proxy.$updateCommentThreadTemplate(this.handle, threadHandle, range);
+	}
+
+	toJSON(): any {
+		return {
+			$mid: 6,
+			handle: this.handle
+		};
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadComments)
+export class MainThreadComments extends Disposable implements MainThreadCommentsShape {
+	private readonly _proxy: ExtHostCommentsShape;
+	private _documentProviders = new Map<number, IDisposable>();
+	private _workspaceProviders = new Map<number, IDisposable>();
+	private _handlers = new Map<number, string>();
+	private _commentControllers = new Map<number, MainThreadCommentController>();
+
+	private _activeCommentThread?: MainThreadCommentThread;
+	private readonly _activeCommentThreadDisposables = this._register(new DisposableStore());
+
+	private _openViewListener: IDisposable | null = null;
+
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ICommentService private readonly _commentService: ICommentService,
+		@IViewsService private readonly _viewsService: IViewsService,
+		@IViewDescriptorService private readonly _viewDescriptorService: IViewDescriptorService
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostComments);
+
+		this._register(this._commentService.onDidChangeActiveCommentThread(async thread => {
+			let handle = (thread as MainThreadCommentThread).controllerHandle;
+			let controller = this._commentControllers.get(handle);
+
+			if (!controller) {
+				return;
+			}
+
+			this._activeCommentThreadDisposables.clear();
+			this._activeCommentThread = thread as MainThreadCommentThread;
+			controller.activeCommentThread = this._activeCommentThread;
+		}));
+	}
+
+	$registerCommentController(handle: number, id: string, label: string): void {
+		const providerId = generateUuid();
+		this._handlers.set(handle, providerId);
+
+		const provider = new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {});
+		this._commentService.registerCommentController(providerId, provider);
+		this._commentControllers.set(handle, provider);
+
+		const commentsPanelAlreadyConstructed = !!this._viewDescriptorService.getViewDescriptorById(COMMENTS_VIEW_ID);
+		if (!commentsPanelAlreadyConstructed) {
+			this.registerView(commentsPanelAlreadyConstructed);
+			this.registerViewOpenedListener(commentsPanelAlreadyConstructed);
+		}
+		this._commentService.setWorkspaceComments(String(handle), []);
+	}
+
+	$unregisterCommentController(handle: number): void {
+		const providerId = this._handlers.get(handle);
+		if (typeof providerId !== 'string') {
+			throw new Error('unknown handler');
+		}
+		this._commentService.unregisterCommentController(providerId);
+		this._handlers.delete(handle);
+		this._commentControllers.delete(handle);
+	}
+
+	$updateCommentControllerFeatures(handle: number, features: CommentProviderFeatures): void {
+		let provider = this._commentControllers.get(handle);
+
+		if (!provider) {
+			return undefined;
+		}
+
+		provider.updateFeatures(features);
+	}
+
+	$createCommentThread(handle: number,
+		commentThreadHandle: number,
+		threadId: string,
+		resource: UriComponents,
+		range: IRange,
+		extensionId: ExtensionIdentifier
+	): modes.CommentThread | undefined {
+		let provider = this._commentControllers.get(handle);
+
+		if (!provider) {
+			return undefined;
+		}
+
+		return provider.createCommentThread(extensionId.value, commentThreadHandle, threadId, resource, range);
+	}
+
+	$updateCommentThread(handle: number,
+		commentThreadHandle: number,
+		threadId: string,
+		resource: UriComponents,
+		changes: CommentThreadChanges): void {
+		let provider = this._commentControllers.get(handle);
+
+		if (!provider) {
+			return undefined;
+		}
+
+		return provider.updateCommentThread(commentThreadHandle, threadId, resource, changes);
+	}
+
+	$deleteCommentThread(handle: number, commentThreadHandle: number) {
+		let provider = this._commentControllers.get(handle);
+
+		if (!provider) {
+			return;
+		}
+
+		return provider.deleteCommentThread(commentThreadHandle);
+	}
+
+	private registerView(commentsViewAlreadyRegistered: boolean) {
+		if (!commentsViewAlreadyRegistered) {
+			const VIEW_CONTAINER: ViewContainer = Registry.as<IViewContainersRegistry>(ViewExtensions.ViewContainersRegistry).registerViewContainer({
+				id: COMMENTS_VIEW_ID,
+				name: COMMENTS_VIEW_TITLE,
+				ctorDescriptor: new SyncDescriptor(ViewPaneContainer, [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true, donotShowContainerTitleWhenMergedWithContainer: true }]),
+				storageId: COMMENTS_VIEW_TITLE,
+				hideIfEmpty: true,
+				icon: Codicon.commentDiscussion.classNames,
+				order: 10,
+			}, ViewContainerLocation.Panel);
+
+			Registry.as<IViewsRegistry>(ViewExtensions.ViewsRegistry).registerViews([{
+				id: COMMENTS_VIEW_ID,
+				name: COMMENTS_VIEW_TITLE,
+				canToggleVisibility: false,
+				ctorDescriptor: new SyncDescriptor(CommentsPanel),
+				canMoveView: true,
+				containerIcon: Codicon.commentDiscussion.classNames,
+				focusCommand: {
+					id: 'workbench.action.focusCommentsPanel'
+				}
+			}], VIEW_CONTAINER);
+		}
+	}
+
+	/**
+	 * If the comments view has never been opened, the constructor for it has not yet run so it has
+	 * no listeners for comment threads being set or updated. Listen for the view opening for the
+	 * first time and send it comments then.
+	 */
+	private registerViewOpenedListener(commentsPanelAlreadyConstructed: boolean) {
+		if (!commentsPanelAlreadyConstructed && !this._openViewListener) {
+			this._openViewListener = this._viewsService.onDidChangeViewVisibility(e => {
+				if (e.id === COMMENTS_VIEW_ID && e.visible) {
+					[...this._commentControllers.keys()].forEach(handle => {
+						let threads = this._commentControllers.get(handle)!.getAllComments();
+
+						if (threads.length) {
+							const providerId = this.getHandler(handle);
+							this._commentService.setWorkspaceComments(providerId, threads);
+						}
+					});
+
+					if (this._openViewListener) {
+						this._openViewListener.dispose();
+						this._openViewListener = null;
+					}
+				}
+			});
+		}
+	}
+
+	private getHandler(handle: number) {
+		if (!this._handlers.has(handle)) {
+			throw new Error('Unknown handler');
+		}
+		return this._handlers.get(handle)!;
+	}
+
+	$onDidCommentThreadsChange(handle: number, event: modes.CommentThreadChangedEvent) {
+		// notify comment service
+		const providerId = this.getHandler(handle);
+		this._commentService.updateComments(providerId, event);
+	}
+
+	dispose(): void {
+		super.dispose();
+		this._workspaceProviders.forEach(value => dispose(value));
+		this._workspaceProviders.clear();
+		this._documentProviders.forEach(value => dispose(value));
+		this._documentProviders.clear();
+	}
+}

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

@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope, getScopes } from 'vs/platform/configuration/common/configurationRegistry';
+import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
+import { MainThreadConfigurationShape, MainContext, ExtHostContext, IExtHostContext, IConfigurationInitData } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ConfigurationTarget, IConfigurationService, IConfigurationOverrides } from 'vs/platform/configuration/common/configuration';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+
+@extHostNamedCustomer(MainContext.MainThreadConfiguration)
+export class MainThreadConfiguration implements MainThreadConfigurationShape {
+
+	private readonly _configurationListener: IDisposable;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+	) {
+		const proxy = extHostContext.getProxy(ExtHostContext.ExtHostConfiguration);
+
+		proxy.$initializeConfiguration(this._getConfigurationData());
+		this._configurationListener = configurationService.onDidChangeConfiguration(e => {
+			proxy.$acceptConfigurationChanged(this._getConfigurationData(), e.change);
+		});
+	}
+
+	private _getConfigurationData(): IConfigurationInitData {
+		const configurationData: IConfigurationInitData = { ...(this.configurationService.getConfigurationData()!), configurationScopes: [] };
+		// Send configurations scopes only in development mode.
+		if (!this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment) {
+			configurationData.configurationScopes = getScopes();
+		}
+		return configurationData;
+	}
+
+	public dispose(): void {
+		this._configurationListener.dispose();
+	}
+
+	$updateConfigurationOption(target: ConfigurationTarget | null, key: string, value: any, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void> {
+		overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+		return this.writeConfiguration(target, key, value, overrides, scopeToLanguage);
+	}
+
+	$removeConfigurationOption(target: ConfigurationTarget | null, key: string, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void> {
+		overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+		return this.writeConfiguration(target, key, undefined, overrides, scopeToLanguage);
+	}
+
+	private writeConfiguration(target: ConfigurationTarget | null, key: string, value: any, overrides: IConfigurationOverrides, scopeToLanguage: boolean | undefined): Promise<void> {
+		target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, overrides);
+		const configurationValue = this.configurationService.inspect(key, overrides);
+		switch (target) {
+			case ConfigurationTarget.MEMORY:
+				return this._updateValue(key, value, target, configurationValue?.memory?.override, overrides, scopeToLanguage);
+			case ConfigurationTarget.WORKSPACE_FOLDER:
+				return this._updateValue(key, value, target, configurationValue?.workspaceFolder?.override, overrides, scopeToLanguage);
+			case ConfigurationTarget.WORKSPACE:
+				return this._updateValue(key, value, target, configurationValue?.workspace?.override, overrides, scopeToLanguage);
+			case ConfigurationTarget.USER_REMOTE:
+				return this._updateValue(key, value, target, configurationValue?.userRemote?.override, overrides, scopeToLanguage);
+			default:
+				return this._updateValue(key, value, target, configurationValue?.userLocal?.override, overrides, scopeToLanguage);
+		}
+	}
+
+	private _updateValue(key: string, value: any, configurationTarget: ConfigurationTarget, overriddenValue: any | undefined, overrides: IConfigurationOverrides, scopeToLanguage: boolean | undefined): Promise<void> {
+		overrides = scopeToLanguage === true ? overrides
+			: scopeToLanguage === false ? { resource: overrides.resource }
+				: overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
+					: { resource: overrides.resource };
+		return this.configurationService.updateValue(key, value, overrides, configurationTarget, true);
+	}
+
+	private deriveConfigurationTarget(key: string, overrides: IConfigurationOverrides): ConfigurationTarget {
+		if (overrides.resource && this._workspaceContextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
+			const configurationProperties = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).getConfigurationProperties();
+			if (configurationProperties[key] && (configurationProperties[key].scope === ConfigurationScope.RESOURCE || configurationProperties[key].scope === ConfigurationScope.LANGUAGE_OVERRIDABLE)) {
+				return ConfigurationTarget.WORKSPACE_FOLDER;
+			}
+		}
+		return ConfigurationTarget.WORKSPACE;
+	}
+}

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

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainContext, MainThreadConsoleShape, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IRemoteConsoleLog, log } from 'vs/base/common/console';
+import { logRemoteEntry } from 'vs/workbench/services/extensions/common/remoteConsoleUtil';
+import { parseExtensionDevOptions } from 'vs/workbench/services/extensions/common/extensionDevOptions';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IExtensionHostDebugService } from 'vs/platform/debug/common/extensionHostDebug';
+
+@extHostNamedCustomer(MainContext.MainThreadConsole)
+export class MainThreadConsole implements MainThreadConsoleShape {
+
+	private readonly _isExtensionDevHost: boolean;
+	private readonly _isExtensionDevTestFromCli: boolean;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+		@ILogService private readonly _logService: ILogService,
+		@IExtensionHostDebugService private readonly _extensionHostDebugService: IExtensionHostDebugService,
+	) {
+		const devOpts = parseExtensionDevOptions(this._environmentService);
+		this._isExtensionDevHost = devOpts.isExtensionDevHost;
+		this._isExtensionDevTestFromCli = devOpts.isExtensionDevTestFromCli;
+	}
+
+	dispose(): void {
+		//
+	}
+
+	$logExtensionHostMessage(entry: IRemoteConsoleLog): void {
+		// Send to local console unless we run tests from cli
+		if (!this._isExtensionDevTestFromCli) {
+			log(entry, 'Extension Host');
+		}
+
+		// Log on main side if running tests from cli
+		if (this._isExtensionDevTestFromCli) {
+			logRemoteEntry(this._logService, entry);
+		}
+
+		// Broadcast to other windows if we are in development mode
+		else if (this._environmentService.debugExtensionHost.debugId && (!this._environmentService.isBuilt || this._isExtensionDevHost)) {
+			this._extensionHostDebugService.logToSession(this._environmentService.debugExtensionHost.debugId, entry);
+		}
+	}
+}

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

@@ -0,0 +1,633 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { isPromiseCanceledError, onUnexpectedError } from 'vs/base/common/errors';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable, DisposableStore, IDisposable, IReference } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
+import { basename } from 'vs/base/common/path';
+import { isEqual, isEqualOrParent, toLocalResource } from 'vs/base/common/resources';
+import { multibyteAwareBtoa } from 'vs/base/browser/dom';
+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 { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ILabelService } from 'vs/platform/label/common/label';
+import { IUndoRedoService, UndoRedoElementType } from 'vs/platform/undoRedo/common/undoRedo';
+import { MainThreadWebviewPanels } from 'vs/workbench/api/browser/mainThreadWebviewPanels';
+import { MainThreadWebviews, reviveWebviewExtension } from 'vs/workbench/api/browser/mainThreadWebviews';
+import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
+import { editorGroupToViewColumn } from 'vs/workbench/api/common/shared/editor';
+import { IRevertOptions, ISaveOptions } from 'vs/workbench/common/editor';
+import { CustomEditorInput } from 'vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { CustomDocumentBackupData } from 'vs/workbench/contrib/customEditor/browser/customEditorInputFactory';
+import { ICustomEditorModel, ICustomEditorService } from 'vs/workbench/contrib/customEditor/common/customEditor';
+import { CustomTextEditorModel } from 'vs/workbench/contrib/customEditor/common/customTextEditorModel';
+import { WebviewExtensionDescription } from 'vs/workbench/contrib/webview/browser/webview';
+import { WebviewInput } from 'vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { IWebviewWorkbenchService } from 'vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { IBackupFileService } from 'vs/workbench/services/backup/common/backup';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { IPathService } from 'vs/workbench/services/path/common/pathService';
+import { IWorkingCopyFileService } from 'vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IWorkingCopy, IWorkingCopyBackup, IWorkingCopyService, WorkingCopyCapabilities } from 'vs/workbench/services/workingCopy/common/workingCopyService';
+
+const enum CustomEditorModelType {
+	Custom,
+	Text,
+}
+
+export class MainThreadCustomEditors extends Disposable implements extHostProtocol.MainThreadCustomEditorsShape {
+
+	private readonly _proxyCustomEditors: extHostProtocol.ExtHostCustomEditorsShape;
+
+	private readonly _editorProviders = new Map<string, IDisposable>();
+
+	constructor(
+		context: extHostProtocol.IExtHostContext,
+		private readonly mainThreadWebview: MainThreadWebviews,
+		private readonly mainThreadWebviewPanels: MainThreadWebviewPanels,
+		@IExtensionService extensionService: IExtensionService,
+		@IWorkingCopyService workingCopyService: IWorkingCopyService,
+		@IWorkingCopyFileService workingCopyFileService: IWorkingCopyFileService,
+		@ICustomEditorService private readonly _customEditorService: ICustomEditorService,
+		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
+		@IWebviewWorkbenchService private readonly _webviewWorkbenchService: IWebviewWorkbenchService,
+		@IInstantiationService private readonly _instantiationService: IInstantiationService,
+		@IBackupFileService private readonly _backupService: IBackupFileService,
+	) {
+		super();
+
+		this._proxyCustomEditors = context.getProxy(extHostProtocol.ExtHostContext.ExtHostCustomEditors);
+
+		this._register(workingCopyFileService.registerWorkingCopyProvider((editorResource) => {
+			const matchedWorkingCopies: IWorkingCopy[] = [];
+
+			for (const workingCopy of workingCopyService.workingCopies) {
+				if (workingCopy instanceof MainThreadCustomEditorModel) {
+					if (isEqualOrParent(editorResource, workingCopy.editorResource)) {
+						matchedWorkingCopies.push(workingCopy);
+					}
+				}
+			}
+			return matchedWorkingCopies;
+		}));
+
+		// This reviver's only job is to activate custom editor extensions.
+		this._register(_webviewWorkbenchService.registerResolver({
+			canResolve: (webview: WebviewInput) => {
+				if (webview instanceof CustomEditorInput) {
+					extensionService.activateByEvent(`onCustomEditor:${webview.viewType}`);
+				}
+				return false;
+			},
+			resolveWebview: () => { throw new Error('not implemented'); }
+		}));
+	}
+
+	dispose() {
+		super.dispose();
+
+		for (const disposable of this._editorProviders.values()) {
+			disposable.dispose();
+		}
+
+		this._editorProviders.clear();
+	}
+
+	public $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: modes.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 {
+		this.registerEditorProvider(CustomEditorModelType.Custom, reviveWebviewExtension(extensionData), viewType, options, {}, supportsMultipleEditorsPerDocument);
+	}
+
+	private registerEditorProvider(
+		modelType: CustomEditorModelType,
+		extension: WebviewExtensionDescription,
+		viewType: string,
+		options: modes.IWebviewPanelOptions,
+		capabilities: extHostProtocol.CustomTextEditorCapabilities,
+		supportsMultipleEditorsPerDocument: boolean,
+	): void {
+		if (this._editorProviders.has(viewType)) {
+			throw new Error(`Provider for ${viewType} already registered`);
+		}
+
+		const disposables = new DisposableStore();
+
+		disposables.add(this._customEditorService.registerCustomEditorCapabilities(viewType, {
+			supportsMultipleEditorsPerDocument
+		}));
+
+		disposables.add(this._webviewWorkbenchService.registerResolver({
+			canResolve: (webviewInput) => {
+				return webviewInput instanceof CustomEditorInput && webviewInput.viewType === viewType;
+			},
+			resolveWebview: async (webviewInput: CustomEditorInput, cancellation: CancellationToken) => {
+				const handle = webviewInput.id;
+				const resource = webviewInput.resource;
+
+				this.mainThreadWebviewPanels.addWebviewInput(handle, webviewInput);
+				webviewInput.webview.options = options;
+				webviewInput.webview.extension = extension;
+
+				let modelRef: IReference<ICustomEditorModel>;
+				try {
+					modelRef = await this.getOrCreateCustomEditorModel(modelType, resource, viewType, { backupId: webviewInput.backupId }, cancellation);
+				} catch (error) {
+					onUnexpectedError(error);
+					webviewInput.webview.html = this.mainThreadWebview.getWebviewResolvedFailedContent(viewType);
+					return;
+				}
+
+				if (cancellation.isCancellationRequested) {
+					modelRef.dispose();
+					return;
+				}
+
+				webviewInput.webview.onDidDispose(() => {
+					// If the model is still dirty, make sure we have time to save it
+					if (modelRef.object.isDirty()) {
+						const sub = modelRef.object.onDidChangeDirty(() => {
+							if (!modelRef.object.isDirty()) {
+								sub.dispose();
+								modelRef.dispose();
+							}
+						});
+						return;
+					}
+
+					modelRef.dispose();
+				});
+
+				if (capabilities.supportsMove) {
+					webviewInput.onMove(async (newResource: URI) => {
+						const oldModel = modelRef;
+						modelRef = await this.getOrCreateCustomEditorModel(modelType, newResource, viewType, {}, CancellationToken.None);
+						this._proxyCustomEditors.$onMoveCustomEditor(handle, newResource, viewType);
+						oldModel.dispose();
+					});
+				}
+
+				try {
+					await this._proxyCustomEditors.$resolveWebviewEditor(resource, handle, viewType, webviewInput.getTitle(), editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), webviewInput.webview.options, cancellation);
+				} catch (error) {
+					onUnexpectedError(error);
+					webviewInput.webview.html = this.mainThreadWebview.getWebviewResolvedFailedContent(viewType);
+					modelRef.dispose();
+					return;
+				}
+			}
+		}));
+
+		this._editorProviders.set(viewType, disposables);
+	}
+
+	public $unregisterEditorProvider(viewType: string): void {
+		const provider = this._editorProviders.get(viewType);
+		if (!provider) {
+			throw new Error(`No provider for ${viewType} registered`);
+		}
+
+		provider.dispose();
+		this._editorProviders.delete(viewType);
+
+		this._customEditorService.models.disposeAllModelsForView(viewType);
+	}
+
+	private async getOrCreateCustomEditorModel(
+		modelType: CustomEditorModelType,
+		resource: URI,
+		viewType: string,
+		options: { backupId?: string },
+		cancellation: CancellationToken,
+	): Promise<IReference<ICustomEditorModel>> {
+		const existingModel = this._customEditorService.models.tryRetain(resource, viewType);
+		if (existingModel) {
+			return existingModel;
+		}
+
+		switch (modelType) {
+			case CustomEditorModelType.Text:
+				{
+					const model = CustomTextEditorModel.create(this._instantiationService, viewType, resource);
+					return this._customEditorService.models.add(resource, viewType, model);
+				}
+			case CustomEditorModelType.Custom:
+				{
+					const model = MainThreadCustomEditorModel.create(this._instantiationService, this._proxyCustomEditors, viewType, resource, options, () => {
+						return Array.from(this.mainThreadWebviewPanels.webviewInputs)
+							.filter(editor => editor instanceof CustomEditorInput && isEqual(editor.resource, resource)) as CustomEditorInput[];
+					}, cancellation, this._backupService);
+					return this._customEditorService.models.add(resource, viewType, model);
+				}
+		}
+	}
+
+	public async $onDidEdit(resourceComponents: UriComponents, viewType: string, editId: number, label: string | undefined): Promise<void> {
+		const model = await this.getCustomEditorModel(resourceComponents, viewType);
+		model.pushEdit(editId, label);
+	}
+
+	public async $onContentChange(resourceComponents: UriComponents, viewType: string): Promise<void> {
+		const model = await this.getCustomEditorModel(resourceComponents, viewType);
+		model.changeContent();
+	}
+
+	private async getCustomEditorModel(resourceComponents: UriComponents, viewType: string) {
+		const resource = URI.revive(resourceComponents);
+		const model = await this._customEditorService.models.get(resource, viewType);
+		if (!model || !(model instanceof MainThreadCustomEditorModel)) {
+			throw new Error('Could not find model for webview editor');
+		}
+		return model;
+	}
+}
+
+namespace HotExitState {
+	export const enum Type {
+		Allowed,
+		NotAllowed,
+		Pending,
+	}
+
+	export const Allowed = Object.freeze({ type: Type.Allowed } as const);
+	export const NotAllowed = Object.freeze({ type: Type.NotAllowed } as const);
+
+	export class Pending {
+		readonly type = Type.Pending;
+
+		constructor(
+			public readonly operation: CancelablePromise<string>,
+		) { }
+	}
+
+	export type State = typeof Allowed | typeof NotAllowed | Pending;
+}
+
+
+class MainThreadCustomEditorModel extends Disposable implements ICustomEditorModel, IWorkingCopy {
+
+	private _fromBackup: boolean = false;
+	private _hotExitState: HotExitState.State = HotExitState.Allowed;
+	private _backupId: string | undefined;
+
+	private _currentEditIndex: number = -1;
+	private _savePoint: number = -1;
+	private readonly _edits: Array<number> = [];
+	private _isDirtyFromContentChange = false;
+
+	private _ongoingSave?: CancelablePromise<void>;
+
+	public static async create(
+		instantiationService: IInstantiationService,
+		proxy: extHostProtocol.ExtHostCustomEditorsShape,
+		viewType: string,
+		resource: URI,
+		options: { backupId?: string },
+		getEditors: () => CustomEditorInput[],
+		cancellation: CancellationToken,
+		_backupFileService: IBackupFileService,
+	) {
+		const { editable } = await proxy.$createCustomDocument(resource, viewType, options.backupId, cancellation);
+		return instantiationService.createInstance(MainThreadCustomEditorModel, proxy, viewType, resource, !!options.backupId, editable, getEditors);
+	}
+
+	constructor(
+		private readonly _proxy: extHostProtocol.ExtHostCustomEditorsShape,
+		private readonly _viewType: string,
+		private readonly _editorResource: URI,
+		fromBackup: boolean,
+		private readonly _editable: boolean,
+		private readonly _getEditors: () => CustomEditorInput[],
+		@IFileDialogService private readonly _fileDialogService: IFileDialogService,
+		@IFileService private readonly _fileService: IFileService,
+		@ILabelService private readonly _labelService: ILabelService,
+		@IUndoRedoService private readonly _undoService: IUndoRedoService,
+		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
+		@IWorkingCopyService workingCopyService: IWorkingCopyService,
+		@IPathService private readonly _pathService: IPathService
+	) {
+		super();
+
+		this._fromBackup = fromBackup;
+
+		if (_editable) {
+			this._register(workingCopyService.registerWorkingCopy(this));
+		}
+	}
+
+	get editorResource() {
+		return this._editorResource;
+	}
+
+	dispose() {
+		if (this._editable) {
+			this._undoService.removeElements(this._editorResource);
+		}
+		this._proxy.$disposeCustomDocument(this._editorResource, this._viewType);
+		super.dispose();
+	}
+
+	//#region IWorkingCopy
+
+	public get resource() {
+		// Make sure each custom editor has a unique resource for backup and edits
+		return MainThreadCustomEditorModel.toWorkingCopyResource(this._viewType, this._editorResource);
+	}
+
+	private static toWorkingCopyResource(viewType: string, resource: URI) {
+		const authority = viewType.replace(/[^a-z0-9\-_]/gi, '-');
+		const path = `/${multibyteAwareBtoa(resource.with({ query: null, fragment: null }).toString(true))}`;
+		return URI.from({
+			scheme: Schemas.vscodeCustomEditor,
+			authority: authority,
+			path: path,
+			query: JSON.stringify(resource.toJSON()),
+		});
+	}
+
+	public get name() {
+		return basename(this._labelService.getUriLabel(this._editorResource));
+	}
+
+	public get capabilities(): WorkingCopyCapabilities {
+		return this.isUntitled() ? WorkingCopyCapabilities.Untitled : WorkingCopyCapabilities.None;
+	}
+
+	public isDirty(): boolean {
+		if (this._isDirtyFromContentChange) {
+			return true;
+		}
+		if (this._edits.length > 0) {
+			return this._savePoint !== this._currentEditIndex;
+		}
+		return this._fromBackup;
+	}
+
+	private isUntitled() {
+		return this._editorResource.scheme === Schemas.untitled;
+	}
+
+	private readonly _onDidChangeDirty: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidChangeDirty: Event<void> = this._onDidChangeDirty.event;
+
+	private readonly _onDidChangeContent: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidChangeContent: Event<void> = this._onDidChangeContent.event;
+
+	//#endregion
+
+	public isReadonly() {
+		return !this._editable;
+	}
+
+	public get viewType() {
+		return this._viewType;
+	}
+
+	public get backupId() {
+		return this._backupId;
+	}
+
+	public pushEdit(editId: number, label: string | undefined) {
+		if (!this._editable) {
+			throw new Error('Document is not editable');
+		}
+
+		this.change(() => {
+			this.spliceEdits(editId);
+			this._currentEditIndex = this._edits.length - 1;
+		});
+
+		this._undoService.pushElement({
+			type: UndoRedoElementType.Resource,
+			resource: this._editorResource,
+			label: label ?? localize('defaultEditLabel', "Edit"),
+			undo: () => this.undo(),
+			redo: () => this.redo(),
+		});
+	}
+
+	public changeContent() {
+		this.change(() => {
+			this._isDirtyFromContentChange = true;
+		});
+	}
+
+	private async undo(): Promise<void> {
+		if (!this._editable) {
+			return;
+		}
+
+		if (this._currentEditIndex < 0) {
+			// nothing to undo
+			return;
+		}
+
+		const undoneEdit = this._edits[this._currentEditIndex];
+		this.change(() => {
+			--this._currentEditIndex;
+		});
+		await this._proxy.$undo(this._editorResource, this.viewType, undoneEdit, this.isDirty());
+	}
+
+	private async redo(): Promise<void> {
+		if (!this._editable) {
+			return;
+		}
+
+		if (this._currentEditIndex >= this._edits.length - 1) {
+			// nothing to redo
+			return;
+		}
+
+		const redoneEdit = this._edits[this._currentEditIndex + 1];
+		this.change(() => {
+			++this._currentEditIndex;
+		});
+		await this._proxy.$redo(this._editorResource, this.viewType, redoneEdit, this.isDirty());
+	}
+
+	private spliceEdits(editToInsert?: number) {
+		const start = this._currentEditIndex + 1;
+		const toRemove = this._edits.length - this._currentEditIndex;
+
+		const removedEdits = typeof editToInsert === 'number'
+			? this._edits.splice(start, toRemove, editToInsert)
+			: this._edits.splice(start, toRemove);
+
+		if (removedEdits.length) {
+			this._proxy.$disposeEdits(this._editorResource, this._viewType, removedEdits);
+		}
+	}
+
+	private change(makeEdit: () => void): void {
+		const wasDirty = this.isDirty();
+		makeEdit();
+		this._onDidChangeContent.fire();
+
+		if (this.isDirty() !== wasDirty) {
+			this._onDidChangeDirty.fire();
+		}
+	}
+
+	public async revert(_options?: IRevertOptions) {
+		if (!this._editable) {
+			return;
+		}
+
+		if (this._currentEditIndex === this._savePoint && !this._isDirtyFromContentChange && !this._fromBackup) {
+			return;
+		}
+
+		this._proxy.$revert(this._editorResource, this.viewType, CancellationToken.None);
+		this.change(() => {
+			this._isDirtyFromContentChange = false;
+			this._fromBackup = false;
+			this._currentEditIndex = this._savePoint;
+			this.spliceEdits();
+		});
+	}
+
+	public async save(options?: ISaveOptions): Promise<boolean> {
+		return !!await this.saveCustomEditor(options);
+	}
+
+	public async saveCustomEditor(options?: ISaveOptions): Promise<URI | undefined> {
+		if (!this._editable) {
+			return undefined;
+		}
+
+		if (this.isUntitled()) {
+			const targetUri = await this.suggestUntitledSavePath(options);
+			if (!targetUri) {
+				return undefined;
+			}
+
+			await this.saveCustomEditorAs(this._editorResource, targetUri, options);
+			return targetUri;
+		}
+
+		const savePromise = createCancelablePromise(token => this._proxy.$onSave(this._editorResource, this.viewType, token));
+		this._ongoingSave?.cancel();
+		this._ongoingSave = savePromise;
+
+		try {
+			await savePromise;
+
+			if (this._ongoingSave === savePromise) { // Make sure we are still doing the same save
+				this.change(() => {
+					this._isDirtyFromContentChange = false;
+					this._savePoint = this._currentEditIndex;
+					this._fromBackup = false;
+				});
+			}
+		} finally {
+			if (this._ongoingSave === savePromise) { // Make sure we are still doing the same save
+				this._ongoingSave = undefined;
+			}
+		}
+
+		return this._editorResource;
+	}
+
+	private suggestUntitledSavePath(options: ISaveOptions | undefined): Promise<URI | undefined> {
+		if (!this.isUntitled()) {
+			throw new Error('Resource is not untitled');
+		}
+
+		const remoteAuthority = this._environmentService.remoteAuthority;
+		const localResource = toLocalResource(this._editorResource, remoteAuthority, this._pathService.defaultUriScheme);
+
+		return this._fileDialogService.pickFileToSave(localResource, options?.availableFileSystems);
+	}
+
+	public async saveCustomEditorAs(resource: URI, targetResource: URI, _options?: ISaveOptions): Promise<boolean> {
+		if (this._editable) {
+			// TODO: handle cancellation
+			await createCancelablePromise(token => this._proxy.$onSaveAs(this._editorResource, this.viewType, targetResource, token));
+			this.change(() => {
+				this._savePoint = this._currentEditIndex;
+			});
+			return true;
+		} else {
+			// Since the editor is readonly, just copy the file over
+			await this._fileService.copy(resource, targetResource, false /* overwrite */);
+			return true;
+		}
+	}
+
+	public async backup(token: CancellationToken): Promise<IWorkingCopyBackup> {
+		const editors = this._getEditors();
+		if (!editors.length) {
+			throw new Error('No editors found for resource, cannot back up');
+		}
+		const primaryEditor = editors[0];
+
+		const backupData: IWorkingCopyBackup<CustomDocumentBackupData> = {
+			meta: {
+				viewType: this.viewType,
+				editorResource: this._editorResource,
+				backupId: '',
+				extension: primaryEditor.extension ? {
+					id: primaryEditor.extension.id.value,
+					location: primaryEditor.extension.location,
+				} : undefined,
+				webview: {
+					id: primaryEditor.id,
+					options: primaryEditor.webview.options,
+					state: primaryEditor.webview.state,
+				}
+			}
+		};
+
+		if (!this._editable) {
+			return backupData;
+		}
+
+		if (this._hotExitState.type === HotExitState.Type.Pending) {
+			this._hotExitState.operation.cancel();
+		}
+
+		const pendingState = new HotExitState.Pending(
+			createCancelablePromise(token =>
+				this._proxy.$backup(this._editorResource.toJSON(), this.viewType, token)));
+		this._hotExitState = pendingState;
+
+		try {
+			const backupId = await pendingState.operation;
+			// Make sure state has not changed in the meantime
+			if (this._hotExitState === pendingState) {
+				this._hotExitState = HotExitState.Allowed;
+				backupData.meta!.backupId = backupId;
+				this._backupId = backupId;
+			}
+		} catch (e) {
+			if (isPromiseCanceledError(e)) {
+				// This is expected
+				throw e;
+			}
+
+			// Otherwise it could be a real error. Make sure state has not changed in the meantime.
+			if (this._hotExitState === pendingState) {
+				this._hotExitState = HotExitState.NotAllowed;
+			}
+		}
+
+		if (this._hotExitState === HotExitState.Allowed) {
+			return backupData;
+		}
+
+		throw new Error('Cannot back up in this state');
+	}
+}

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

@@ -0,0 +1,418 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { URI as uri, UriComponents } from 'vs/base/common/uri';
+import { IDebugService, IConfig, IDebugConfigurationProvider, IBreakpoint, IFunctionBreakpoint, IBreakpointData, IDebugAdapter, IDebugAdapterDescriptorFactory, IDebugSession, IDebugAdapterFactory, IDataBreakpoint, IDebugSessionOptions } from 'vs/workbench/contrib/debug/common/debug';
+import {
+	ExtHostContext, ExtHostDebugServiceShape, MainThreadDebugServiceShape, DebugSessionUUID, MainContext,
+	IExtHostContext, IBreakpointsDeltaDto, ISourceMultiBreakpointDto, ISourceBreakpointDto, IFunctionBreakpointDto, IDebugSessionDto, IDataBreakpointDto, IStartDebuggingOptions, IDebugConfiguration
+} from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import severity from 'vs/base/common/severity';
+import { AbstractDebugAdapter } from 'vs/workbench/contrib/debug/common/abstractDebugAdapter';
+import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
+import { convertToVSCPaths, convertToDAPaths } from 'vs/workbench/contrib/debug/common/debugUtils';
+import { DebugConfigurationProviderTriggerKind } from 'vs/workbench/api/common/extHostTypes';
+
+@extHostNamedCustomer(MainContext.MainThreadDebugService)
+export class MainThreadDebugService implements MainThreadDebugServiceShape, IDebugAdapterFactory {
+
+	private readonly _proxy: ExtHostDebugServiceShape;
+	private readonly _toDispose = new DisposableStore();
+	private _breakpointEventsActive: boolean | undefined;
+	private readonly _debugAdapters: Map<number, ExtensionHostDebugAdapter>;
+	private _debugAdaptersHandleCounter = 1;
+	private readonly _debugConfigurationProviders: Map<number, IDebugConfigurationProvider>;
+	private readonly _debugAdapterDescriptorFactories: Map<number, IDebugAdapterDescriptorFactory>;
+	private readonly _sessions: Set<DebugSessionUUID>;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IDebugService private readonly debugService: IDebugService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDebugService);
+		this._toDispose.add(debugService.onDidNewSession(session => {
+			this._proxy.$acceptDebugSessionStarted(this.getSessionDto(session));
+			this._toDispose.add(session.onDidChangeName(name => {
+				this._proxy.$acceptDebugSessionNameChanged(this.getSessionDto(session), name);
+			}));
+		}));
+		// Need to start listening early to new session events because a custom event can come while a session is initialising
+		this._toDispose.add(debugService.onWillNewSession(session => {
+			this._toDispose.add(session.onDidCustomEvent(event => this._proxy.$acceptDebugSessionCustomEvent(this.getSessionDto(session), event)));
+		}));
+		this._toDispose.add(debugService.onDidEndSession(session => {
+			this._proxy.$acceptDebugSessionTerminated(this.getSessionDto(session));
+			this._sessions.delete(session.getId());
+		}));
+		this._toDispose.add(debugService.getViewModel().onDidFocusSession(session => {
+			this._proxy.$acceptDebugSessionActiveChanged(this.getSessionDto(session));
+		}));
+
+		this._debugAdapters = new Map();
+		this._debugConfigurationProviders = new Map();
+		this._debugAdapterDescriptorFactories = new Map();
+		this._sessions = new Set();
+	}
+
+	public dispose(): void {
+		this._toDispose.dispose();
+	}
+
+	// interface IDebugAdapterProvider
+
+	createDebugAdapter(session: IDebugSession): IDebugAdapter {
+		const handle = this._debugAdaptersHandleCounter++;
+		const da = new ExtensionHostDebugAdapter(this, handle, this._proxy, session);
+		this._debugAdapters.set(handle, da);
+		return da;
+	}
+
+	substituteVariables(folder: IWorkspaceFolder | undefined, config: IConfig): Promise<IConfig> {
+		return Promise.resolve(this._proxy.$substituteVariables(folder ? folder.uri : undefined, config));
+	}
+
+	runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments): Promise<number | undefined> {
+		return this._proxy.$runInTerminal(args);
+	}
+
+	// RPC methods (MainThreadDebugServiceShape)
+
+	public $registerDebugTypes(debugTypes: string[]) {
+		this._toDispose.add(this.debugService.getConfigurationManager().registerDebugAdapterFactory(debugTypes, this));
+	}
+
+	public $startBreakpointEvents(): void {
+
+		if (!this._breakpointEventsActive) {
+			this._breakpointEventsActive = true;
+
+			// set up a handler to send more
+			this._toDispose.add(this.debugService.getModel().onDidChangeBreakpoints(e => {
+				// Ignore session only breakpoint events since they should only reflect in the UI
+				if (e && !e.sessionOnly) {
+					const delta: IBreakpointsDeltaDto = {};
+					if (e.added) {
+						delta.added = this.convertToDto(e.added);
+					}
+					if (e.removed) {
+						delta.removed = e.removed.map(x => x.getId());
+					}
+					if (e.changed) {
+						delta.changed = this.convertToDto(e.changed);
+					}
+
+					if (delta.added || delta.removed || delta.changed) {
+						this._proxy.$acceptBreakpointsDelta(delta);
+					}
+				}
+			}));
+
+			// send all breakpoints
+			const bps = this.debugService.getModel().getBreakpoints();
+			const fbps = this.debugService.getModel().getFunctionBreakpoints();
+			const dbps = this.debugService.getModel().getDataBreakpoints();
+			if (bps.length > 0 || fbps.length > 0) {
+				this._proxy.$acceptBreakpointsDelta({
+					added: this.convertToDto(bps).concat(this.convertToDto(fbps)).concat(this.convertToDto(dbps))
+				});
+			}
+		}
+	}
+
+	public $registerBreakpoints(DTOs: Array<ISourceMultiBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto>): Promise<void> {
+
+		for (let dto of DTOs) {
+			if (dto.type === 'sourceMulti') {
+				const rawbps = dto.lines.map(l =>
+					<IBreakpointData>{
+						id: l.id,
+						enabled: l.enabled,
+						lineNumber: l.line + 1,
+						column: l.character > 0 ? l.character + 1 : undefined, // a column value of 0 results in an omitted column attribute; see #46784
+						condition: l.condition,
+						hitCondition: l.hitCondition,
+						logMessage: l.logMessage
+					}
+				);
+				this.debugService.addBreakpoints(uri.revive(dto.uri), rawbps);
+			} 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);
+			}
+		}
+		return Promise.resolve();
+	}
+
+	public $unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[], dataBreakpointIds: string[]): Promise<void> {
+		breakpointIds.forEach(id => this.debugService.removeBreakpoints(id));
+		functionBreakpointIds.forEach(id => this.debugService.removeFunctionBreakpoints(id));
+		dataBreakpointIds.forEach(id => this.debugService.removeDataBreakpoints(id));
+		return Promise.resolve();
+	}
+
+	public $registerDebugConfigurationProvider(debugType: string, providerTriggerKind: DebugConfigurationProviderTriggerKind, hasProvide: boolean, hasResolve: boolean, hasResolve2: boolean, hasProvideDebugAdapter: boolean, handle: number): Promise<void> {
+
+		const provider = <IDebugConfigurationProvider>{
+			type: debugType,
+			triggerKind: providerTriggerKind
+		};
+		if (hasProvide) {
+			provider.provideDebugConfigurations = (folder, token) => {
+				return this._proxy.$provideDebugConfigurations(handle, folder, token);
+			};
+		}
+		if (hasResolve) {
+			provider.resolveDebugConfiguration = (folder, config, token) => {
+				return this._proxy.$resolveDebugConfiguration(handle, folder, config, token);
+			};
+		}
+		if (hasResolve2) {
+			provider.resolveDebugConfigurationWithSubstitutedVariables = (folder, config, token) => {
+				return this._proxy.$resolveDebugConfigurationWithSubstitutedVariables(handle, folder, config, token);
+			};
+		}
+		if (hasProvideDebugAdapter) {
+			console.info('DebugConfigurationProvider.debugAdapterExecutable is deprecated and will be removed soon; please use DebugAdapterDescriptorFactory.createDebugAdapterDescriptor instead.');
+			provider.debugAdapterExecutable = (folder) => {
+				return this._proxy.$legacyDebugAdapterExecutable(handle, folder);
+			};
+		}
+		this._debugConfigurationProviders.set(handle, provider);
+		this._toDispose.add(this.debugService.getConfigurationManager().registerDebugConfigurationProvider(provider));
+
+		return Promise.resolve(undefined);
+	}
+
+	public $unregisterDebugConfigurationProvider(handle: number): void {
+		const provider = this._debugConfigurationProviders.get(handle);
+		if (provider) {
+			this._debugConfigurationProviders.delete(handle);
+			this.debugService.getConfigurationManager().unregisterDebugConfigurationProvider(provider);
+		}
+	}
+
+	public $registerDebugAdapterDescriptorFactory(debugType: string, handle: number): Promise<void> {
+
+		const provider = <IDebugAdapterDescriptorFactory>{
+			type: debugType,
+			createDebugAdapterDescriptor: session => {
+				return Promise.resolve(this._proxy.$provideDebugAdapter(handle, this.getSessionDto(session)));
+			}
+		};
+		this._debugAdapterDescriptorFactories.set(handle, provider);
+		this._toDispose.add(this.debugService.getConfigurationManager().registerDebugAdapterDescriptorFactory(provider));
+
+		return Promise.resolve(undefined);
+	}
+
+	public $unregisterDebugAdapterDescriptorFactory(handle: number): void {
+		const provider = this._debugAdapterDescriptorFactories.get(handle);
+		if (provider) {
+			this._debugAdapterDescriptorFactories.delete(handle);
+			this.debugService.getConfigurationManager().unregisterDebugAdapterDescriptorFactory(provider);
+		}
+	}
+
+	private getSession(sessionId: DebugSessionUUID | undefined): IDebugSession | undefined {
+		if (sessionId) {
+			return this.debugService.getModel().getSession(sessionId, true);
+		}
+		return undefined;
+	}
+
+	public $startDebugging(folder: UriComponents | undefined, nameOrConfig: string | IDebugConfiguration, options: IStartDebuggingOptions): Promise<boolean> {
+		const folderUri = folder ? uri.revive(folder) : undefined;
+		const launch = this.debugService.getConfigurationManager().getLaunch(folderUri);
+		const parentSession = this.getSession(options.parentSessionID);
+		const debugOptions: IDebugSessionOptions = {
+			noDebug: options.noDebug,
+			parentSession,
+			repl: options.repl,
+			compact: options.compact,
+			compoundRoot: parentSession?.compoundRoot
+		};
+		return this.debugService.startDebugging(launch, nameOrConfig, debugOptions).then(success => {
+			return success;
+		}, err => {
+			return Promise.reject(new Error(err && err.message ? err.message : 'cannot start debugging'));
+		});
+	}
+
+	public $setDebugSessionName(sessionId: DebugSessionUUID, name: string): void {
+		const session = this.debugService.getModel().getSession(sessionId);
+		if (session) {
+			session.setName(name);
+		}
+	}
+
+	public $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Promise<any> {
+		const session = this.debugService.getModel().getSession(sessionId, true);
+		if (session) {
+			return session.customRequest(request, args).then(response => {
+				if (response && response.success) {
+					return response.body;
+				} else {
+					return Promise.reject(new Error(response ? response.message : 'custom request failed'));
+				}
+			});
+		}
+		return Promise.reject(new Error('debug session not found'));
+	}
+
+	public $getDebugProtocolBreakpoint(sessionId: DebugSessionUUID, breakpoinId: string): Promise<DebugProtocol.Breakpoint | undefined> {
+		const session = this.debugService.getModel().getSession(sessionId, true);
+		if (session) {
+			return Promise.resolve(session.getDebugProtocolBreakpoint(breakpoinId));
+		}
+		return Promise.reject(new Error('debug session not found'));
+	}
+
+	public $stopDebugging(sessionId: DebugSessionUUID | undefined): Promise<void> {
+		if (sessionId) {
+			const session = this.debugService.getModel().getSession(sessionId, true);
+			if (session) {
+				return this.debugService.stopSession(session);
+			}
+		} else {	// stop all
+			return this.debugService.stopSession(undefined);
+		}
+		return Promise.reject(new Error('debug session not found'));
+	}
+
+	public $appendDebugConsole(value: string): void {
+		// Use warning as severity to get the orange color for messages coming from the debug extension
+		const session = this.debugService.getViewModel().focusedSession;
+		if (session) {
+			session.appendToRepl(value, severity.Warning);
+		}
+	}
+
+	public $acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage) {
+		this.getDebugAdapter(handle).acceptMessage(convertToVSCPaths(message, false));
+	}
+
+	public $acceptDAError(handle: number, name: string, message: string, stack: string) {
+		this.getDebugAdapter(handle).fireError(handle, new Error(`${name}: ${message}\n${stack}`));
+	}
+
+	public $acceptDAExit(handle: number, code: number, signal: string) {
+		this.getDebugAdapter(handle).fireExit(handle, code, signal);
+	}
+
+	private getDebugAdapter(handle: number): ExtensionHostDebugAdapter {
+		const adapter = this._debugAdapters.get(handle);
+		if (!adapter) {
+			throw new Error('Invalid debug adapter');
+		}
+		return adapter;
+	}
+
+	// dto helpers
+
+	public $sessionCached(sessionID: string) {
+		// remember that the EH has cached the session and we do not have to send it again
+		this._sessions.add(sessionID);
+	}
+
+
+	getSessionDto(session: undefined): undefined;
+	getSessionDto(session: IDebugSession): IDebugSessionDto;
+	getSessionDto(session: IDebugSession | undefined): IDebugSessionDto | undefined;
+	getSessionDto(session: IDebugSession | undefined): IDebugSessionDto | undefined {
+		if (session) {
+			const sessionID = <DebugSessionUUID>session.getId();
+			if (this._sessions.has(sessionID)) {
+				return sessionID;
+			} else {
+				// this._sessions.add(sessionID); 	// #69534: see $sessionCached above
+				return {
+					id: sessionID,
+					type: session.configuration.type,
+					name: session.configuration.name,
+					folderUri: session.root ? session.root.uri : undefined,
+					configuration: session.configuration
+				};
+			}
+		}
+		return undefined;
+	}
+
+	private convertToDto(bps: (ReadonlyArray<IBreakpoint | IFunctionBreakpoint | IDataBreakpoint>)): Array<ISourceBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto> {
+		return bps.map(bp => {
+			if ('name' in bp) {
+				const fbp = <IFunctionBreakpoint>bp;
+				return <IFunctionBreakpointDto>{
+					type: 'function',
+					id: fbp.getId(),
+					enabled: fbp.enabled,
+					condition: fbp.condition,
+					hitCondition: fbp.hitCondition,
+					logMessage: fbp.logMessage,
+					functionName: fbp.name
+				};
+			} else if ('dataId' in bp) {
+				const dbp = <IDataBreakpoint>bp;
+				return <IDataBreakpointDto>{
+					type: 'data',
+					id: dbp.getId(),
+					dataId: dbp.dataId,
+					enabled: dbp.enabled,
+					condition: dbp.condition,
+					hitCondition: dbp.hitCondition,
+					logMessage: dbp.logMessage,
+					label: dbp.description,
+					canPersist: dbp.canPersist
+				};
+			} else {
+				const sbp = <IBreakpoint>bp;
+				return <ISourceBreakpointDto>{
+					type: 'source',
+					id: sbp.getId(),
+					enabled: sbp.enabled,
+					condition: sbp.condition,
+					hitCondition: sbp.hitCondition,
+					logMessage: sbp.logMessage,
+					uri: sbp.uri,
+					line: sbp.lineNumber > 0 ? sbp.lineNumber - 1 : 0,
+					character: (typeof sbp.column === 'number' && sbp.column > 0) ? sbp.column - 1 : 0,
+				};
+			}
+		});
+	}
+}
+
+/**
+ * DebugAdapter that communicates via extension protocol with another debug adapter.
+ */
+class ExtensionHostDebugAdapter extends AbstractDebugAdapter {
+
+	constructor(private readonly _ds: MainThreadDebugService, private _handle: number, private _proxy: ExtHostDebugServiceShape, private _session: IDebugSession) {
+		super();
+	}
+
+	fireError(handle: number, err: Error) {
+		this._onError.fire(err);
+	}
+
+	fireExit(handle: number, code: number, signal: string) {
+		this._onExit.fire(code);
+	}
+
+	startSession(): Promise<void> {
+		return Promise.resolve(this._proxy.$startDASession(this._handle, this._ds.getSessionDto(this._session)));
+	}
+
+	sendMessage(message: DebugProtocol.ProtocolMessage): void {
+		this._proxy.$sendDAMessage(this._handle, convertToDAPaths(message, true));
+	}
+
+	async stopSession(): Promise<void> {
+		await this.cancelPendingRequests();
+		return Promise.resolve(this._proxy.$stopDASession(this._handle));
+	}
+}

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

@@ -0,0 +1,123 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { Emitter } from 'vs/base/common/event';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { ExtHostContext, MainContext, IExtHostContext, MainThreadDecorationsShape, ExtHostDecorationsShape, DecorationData, DecorationRequest } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDecorationsService, IDecorationData } from 'vs/workbench/services/decorations/browser/decorations';
+import { CancellationToken } from 'vs/base/common/cancellation';
+
+class DecorationRequestsQueue {
+
+	private _idPool = 0;
+	private _requests = new Map<number, DecorationRequest>();
+	private _resolver = new Map<number, (data: DecorationData) => any>();
+
+	private _timer: any;
+
+	constructor(
+		private readonly _proxy: ExtHostDecorationsShape,
+		private readonly _handle: number
+	) {
+		//
+	}
+
+	enqueue(uri: URI, token: CancellationToken): Promise<DecorationData> {
+		const id = ++this._idPool;
+		const result = new Promise<DecorationData>(resolve => {
+			this._requests.set(id, { id, uri });
+			this._resolver.set(id, resolve);
+			this._processQueue();
+		});
+		token.onCancellationRequested(() => {
+			this._requests.delete(id);
+			this._resolver.delete(id);
+		});
+		return result;
+	}
+
+	private _processQueue(): void {
+		if (typeof this._timer === 'number') {
+			// already queued
+			return;
+		}
+		this._timer = setTimeout(() => {
+			// make request
+			const requests = this._requests;
+			const resolver = this._resolver;
+			this._proxy.$provideDecorations(this._handle, [...requests.values()], CancellationToken.None).then(data => {
+				for (let [id, resolve] of resolver) {
+					resolve(data[id]);
+				}
+			});
+
+			// reset
+			this._requests = new Map();
+			this._resolver = new Map();
+			this._timer = undefined;
+		}, 0);
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadDecorations)
+export class MainThreadDecorations implements MainThreadDecorationsShape {
+
+	private readonly _provider = new Map<number, [Emitter<URI[]>, IDisposable]>();
+	private readonly _proxy: ExtHostDecorationsShape;
+
+	constructor(
+		context: IExtHostContext,
+		@IDecorationsService private readonly _decorationsService: IDecorationsService
+	) {
+		this._proxy = context.getProxy(ExtHostContext.ExtHostDecorations);
+	}
+
+	dispose() {
+		this._provider.forEach(value => dispose(value));
+		this._provider.clear();
+	}
+
+	$registerDecorationProvider(handle: number, label: string): void {
+		const emitter = new Emitter<URI[]>();
+		const queue = new DecorationRequestsQueue(this._proxy, handle);
+		const registration = this._decorationsService.registerDecorationsProvider({
+			label,
+			onDidChange: emitter.event,
+			provideDecorations: async (uri, token) => {
+				const data = await queue.enqueue(uri, token);
+				if (!data) {
+					return undefined;
+				}
+				const [bubble, tooltip, letter, themeColor] = data;
+				return <IDecorationData>{
+					weight: 10,
+					bubble: bubble ?? false,
+					color: themeColor?.id,
+					tooltip,
+					letter
+				};
+			}
+		});
+		this._provider.set(handle, [emitter, registration]);
+	}
+
+	$onDidChange(handle: number, resources: UriComponents[]): void {
+		const provider = this._provider.get(handle);
+		if (provider) {
+			const [emitter] = provider;
+			emitter.fire(resources && resources.map(r => URI.revive(r)));
+		}
+	}
+
+	$unregisterDecorationProvider(handle: number): void {
+		const provider = this._provider.get(handle);
+		if (provider) {
+			dispose(provider);
+			this._provider.delete(handle);
+		}
+	}
+}

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

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IMarkerService, IMarkerData } from 'vs/platform/markers/common/markers';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { MainThreadDiagnosticsShape, MainContext, IExtHostContext, ExtHostDiagnosticsShape, ExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
+
+@extHostNamedCustomer(MainContext.MainThreadDiagnostics)
+export class MainThreadDiagnostics implements MainThreadDiagnosticsShape {
+
+	private readonly _activeOwners = new Set<string>();
+
+	private readonly _proxy: ExtHostDiagnosticsShape;
+	private readonly _markerListener: IDisposable;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IMarkerService private readonly _markerService: IMarkerService,
+		@IUriIdentityService private readonly _uriIdentService: IUriIdentityService,
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDiagnostics);
+
+		this._markerListener = this._markerService.onMarkerChanged(this._forwardMarkers, this);
+	}
+
+	dispose(): void {
+		this._markerListener.dispose();
+		this._activeOwners.forEach(owner => this._markerService.changeAll(owner, []));
+		this._activeOwners.clear();
+	}
+
+	private _forwardMarkers(resources: readonly URI[]): void {
+		const data: [UriComponents, IMarkerData[]][] = [];
+		for (const resource of resources) {
+			data.push([
+				resource,
+				this._markerService.read({ resource }).filter(marker => !this._activeOwners.has(marker.owner))
+			]);
+		}
+		this._proxy.$acceptMarkersChange(data);
+	}
+
+	$changeMany(owner: string, entries: [UriComponents, IMarkerData[]][]): void {
+		for (let entry of entries) {
+			let [uri, markers] = entry;
+			if (markers) {
+				for (const marker of markers) {
+					if (marker.relatedInformation) {
+						for (const relatedInformation of marker.relatedInformation) {
+							relatedInformation.resource = URI.revive(relatedInformation.resource);
+						}
+					}
+					if (marker.code && typeof marker.code !== 'string') {
+						marker.code.target = URI.revive(marker.code.target);
+					}
+				}
+			}
+			this._markerService.changeOne(owner, this._uriIdentService.asCanonicalUri(URI.revive(uri)), markers);
+		}
+		this._activeOwners.add(owner);
+	}
+
+	$clear(owner: string): void {
+		this._markerService.changeAll(owner, []);
+		this._activeOwners.delete(owner);
+	}
+}

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

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { MainThreadDiaglogsShape, MainContext, IExtHostContext, MainThreadDialogOpenOptions, MainThreadDialogSaveOptions } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { forEach } from 'vs/base/common/collections';
+import { IFileDialogService, IOpenDialogOptions, ISaveDialogOptions } from 'vs/platform/dialogs/common/dialogs';
+
+@extHostNamedCustomer(MainContext.MainThreadDialogs)
+export class MainThreadDialogs implements MainThreadDiaglogsShape {
+
+	constructor(
+		context: IExtHostContext,
+		@IFileDialogService private readonly _fileDialogService: IFileDialogService,
+	) {
+		//
+	}
+
+	dispose(): void {
+		//
+	}
+
+	$showOpenDialog(options?: MainThreadDialogOpenOptions): Promise<URI[] | undefined> {
+		return Promise.resolve(this._fileDialogService.showOpenDialog(MainThreadDialogs._convertOpenOptions(options)));
+	}
+
+	$showSaveDialog(options?: MainThreadDialogSaveOptions): Promise<URI | undefined> {
+		return Promise.resolve(this._fileDialogService.showSaveDialog(MainThreadDialogs._convertSaveOptions(options)));
+	}
+
+	private static _convertOpenOptions(options?: MainThreadDialogOpenOptions): IOpenDialogOptions {
+		const result: IOpenDialogOptions = {
+			openLabel: options?.openLabel || undefined,
+			canSelectFiles: options?.canSelectFiles || (!options?.canSelectFiles && !options?.canSelectFolders),
+			canSelectFolders: options?.canSelectFolders,
+			canSelectMany: options?.canSelectMany,
+			defaultUri: options?.defaultUri ? URI.revive(options.defaultUri) : undefined,
+			title: options?.title || undefined
+		};
+		if (options?.filters) {
+			result.filters = [];
+			forEach(options.filters, entry => result.filters!.push({ name: entry.key, extensions: entry.value }));
+		}
+		return result;
+	}
+
+	private static _convertSaveOptions(options?: MainThreadDialogSaveOptions): ISaveDialogOptions {
+		const result: ISaveDialogOptions = {
+			defaultUri: options?.defaultUri ? URI.revive(options.defaultUri) : undefined,
+			saveLabel: options?.saveLabel || undefined,
+			title: options?.title || undefined
+		};
+		if (options?.filters) {
+			result.filters = [];
+			forEach(options.filters, entry => result.filters!.push({ name: entry.key, extensions: entry.value }));
+		}
+		return result;
+	}
+}

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

@@ -0,0 +1,96 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { EditOperation } from 'vs/editor/common/core/editOperation';
+import { Range } from 'vs/editor/common/core/range';
+import { ITextModel } from 'vs/editor/common/model';
+import { IEditorWorkerService } from 'vs/editor/common/services/editorWorkerService';
+import { IModelService } from 'vs/editor/common/services/modelService';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, ExtHostDocumentContentProvidersShape, IExtHostContext, MainContext, MainThreadDocumentContentProvidersShape } from '../common/extHost.protocol';
+import { CancellationTokenSource } from 'vs/base/common/cancellation';
+
+@extHostNamedCustomer(MainContext.MainThreadDocumentContentProviders)
+export class MainThreadDocumentContentProviders implements MainThreadDocumentContentProvidersShape {
+
+	private readonly _resourceContentProvider = new Map<number, IDisposable>();
+	private readonly _pendingUpdate = new Map<string, CancellationTokenSource>();
+	private readonly _proxy: ExtHostDocumentContentProvidersShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ITextModelService private readonly _textModelResolverService: ITextModelService,
+		@IModeService private readonly _modeService: IModeService,
+		@IModelService private readonly _modelService: IModelService,
+		@IEditorWorkerService private readonly _editorWorkerService: IEditorWorkerService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentContentProviders);
+	}
+
+	dispose(): void {
+		dispose(this._resourceContentProvider.values());
+		dispose(this._pendingUpdate.values());
+	}
+
+	$registerTextContentProvider(handle: number, scheme: string): void {
+		const registration = this._textModelResolverService.registerTextModelContentProvider(scheme, {
+			provideTextContent: (uri: URI): Promise<ITextModel | null> => {
+				return this._proxy.$provideTextDocumentContent(handle, uri).then(value => {
+					if (typeof value === 'string') {
+						const firstLineText = value.substr(0, 1 + value.search(/\r?\n/));
+						const languageSelection = this._modeService.createByFilepathOrFirstLine(uri, firstLineText);
+						return this._modelService.createModel(value, languageSelection, uri);
+					}
+					return null;
+				});
+			}
+		});
+		this._resourceContentProvider.set(handle, registration);
+	}
+
+	$unregisterTextContentProvider(handle: number): void {
+		const registration = this._resourceContentProvider.get(handle);
+		if (registration) {
+			registration.dispose();
+			this._resourceContentProvider.delete(handle);
+		}
+	}
+
+	$onVirtualDocumentChange(uri: UriComponents, value: string): void {
+		const model = this._modelService.getModel(URI.revive(uri));
+		if (!model) {
+			return;
+		}
+
+		// cancel and dispose an existing update
+		const pending = this._pendingUpdate.get(model.id);
+		if (pending) {
+			pending.cancel();
+		}
+
+		// create and keep update token
+		const myToken = new CancellationTokenSource();
+		this._pendingUpdate.set(model.id, myToken);
+
+		this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: value, range: model.getFullModelRange() }]).then(edits => {
+			// remove token
+			this._pendingUpdate.delete(model.id);
+
+			if (myToken.token.isCancellationRequested) {
+				// ignore this
+				return;
+			}
+			if (edits && edits.length > 0) {
+				// use the evil-edit as these models show in readonly-editor only
+				model.applyEdits(edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)));
+			}
+		}).catch(onUnexpectedError);
+	}
+}

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

@@ -0,0 +1,302 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { IReference, dispose, Disposable } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { ITextModel } from 'vs/editor/common/model';
+import { IModelService, shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { IFileService, FileOperation } from 'vs/platform/files/common/files';
+import { MainThreadDocumentsAndEditors } from 'vs/workbench/api/browser/mainThreadDocumentsAndEditors';
+import { ExtHostContext, ExtHostDocumentsShape, IExtHostContext, MainThreadDocumentsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ITextEditorModel } from 'vs/workbench/common/editor';
+import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+import { toLocalResource, extUri, IExtUri } from 'vs/base/common/resources';
+import { IWorkingCopyFileService } from 'vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
+import { Emitter } from 'vs/base/common/event';
+import { IPathService } from 'vs/workbench/services/path/common/pathService';
+
+export class BoundModelReferenceCollection {
+
+	private _data = new Array<{ uri: URI, length: number, dispose(): void }>();
+	private _length = 0;
+
+	constructor(
+		private readonly _extUri: IExtUri,
+		private readonly _maxAge: number = 1000 * 60 * 3,
+		private readonly _maxLength: number = 1024 * 1024 * 80,
+	) {
+		//
+	}
+
+	dispose(): void {
+		this._data = dispose(this._data);
+	}
+
+	remove(uri: URI): void {
+		for (const entry of [...this._data] /* copy array because dispose will modify it */) {
+			if (this._extUri.isEqualOrParent(entry.uri, uri)) {
+				entry.dispose();
+			}
+		}
+	}
+
+	add(uri: URI, ref: IReference<ITextEditorModel>): void {
+		const length = ref.object.textEditorModel.getValueLength();
+		let handle: any;
+		let entry: { uri: URI, length: number, dispose(): void };
+		const dispose = () => {
+			const idx = this._data.indexOf(entry);
+			if (idx >= 0) {
+				this._length -= length;
+				ref.dispose();
+				clearTimeout(handle);
+				this._data.splice(idx, 1);
+			}
+		};
+		handle = setTimeout(dispose, this._maxAge);
+		entry = { uri, length, dispose };
+
+		this._data.push(entry);
+		this._length += length;
+		this._cleanup();
+	}
+
+	private _cleanup(): void {
+		while (this._length > this._maxLength) {
+			this._data[0].dispose();
+		}
+	}
+}
+
+class ModelTracker extends Disposable {
+
+	private _knownVersionId: number;
+
+	constructor(
+		private readonly _model: ITextModel,
+		private readonly _onIsCaughtUpWithContentChanges: Emitter<URI>,
+		private readonly _proxy: ExtHostDocumentsShape,
+		private readonly _textFileService: ITextFileService,
+	) {
+		super();
+		this._knownVersionId = this._model.getVersionId();
+		this._register(this._model.onDidChangeContent((e) => {
+			this._knownVersionId = e.versionId;
+			this._proxy.$acceptModelChanged(this._model.uri, e, this._textFileService.isDirty(this._model.uri));
+			if (this.isCaughtUpWithContentChanges()) {
+				this._onIsCaughtUpWithContentChanges.fire(this._model.uri);
+			}
+		}));
+	}
+
+	public isCaughtUpWithContentChanges(): boolean {
+		return (this._model.getVersionId() === this._knownVersionId);
+	}
+}
+
+export class MainThreadDocuments extends Disposable implements MainThreadDocumentsShape {
+
+	private _onIsCaughtUpWithContentChanges = this._register(new Emitter<URI>());
+	public readonly onIsCaughtUpWithContentChanges = this._onIsCaughtUpWithContentChanges.event;
+
+	private readonly _modelService: IModelService;
+	private readonly _textModelResolverService: ITextModelService;
+	private readonly _textFileService: ITextFileService;
+	private readonly _fileService: IFileService;
+	private readonly _environmentService: IWorkbenchEnvironmentService;
+	private readonly _uriIdentityService: IUriIdentityService;
+
+	private _modelTrackers: { [modelUrl: string]: ModelTracker; };
+	private readonly _proxy: ExtHostDocumentsShape;
+	private readonly _modelIsSynced = new Set<string>();
+	private readonly _modelReferenceCollection: BoundModelReferenceCollection;
+
+	constructor(
+		documentsAndEditors: MainThreadDocumentsAndEditors,
+		extHostContext: IExtHostContext,
+		@IModelService modelService: IModelService,
+		@ITextFileService textFileService: ITextFileService,
+		@IFileService fileService: IFileService,
+		@ITextModelService textModelResolverService: ITextModelService,
+		@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService,
+		@IUriIdentityService uriIdentityService: IUriIdentityService,
+		@IWorkingCopyFileService workingCopyFileService: IWorkingCopyFileService,
+		@IPathService private readonly _pathService: IPathService
+	) {
+		super();
+		this._modelService = modelService;
+		this._textModelResolverService = textModelResolverService;
+		this._textFileService = textFileService;
+		this._fileService = fileService;
+		this._environmentService = environmentService;
+		this._uriIdentityService = uriIdentityService;
+
+		this._modelReferenceCollection = this._register(new BoundModelReferenceCollection(uriIdentityService.extUri));
+
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocuments);
+
+		this._register(documentsAndEditors.onDocumentAdd(models => models.forEach(this._onModelAdded, this)));
+		this._register(documentsAndEditors.onDocumentRemove(urls => urls.forEach(this._onModelRemoved, this)));
+		this._register(modelService.onModelModeChanged(this._onModelModeChanged, this));
+
+		this._register(textFileService.files.onDidSave(e => {
+			if (this._shouldHandleFileEvent(e.model.resource)) {
+				this._proxy.$acceptModelSaved(e.model.resource);
+			}
+		}));
+		this._register(textFileService.files.onDidChangeDirty(m => {
+			if (this._shouldHandleFileEvent(m.resource)) {
+				this._proxy.$acceptDirtyStateChanged(m.resource, m.isDirty());
+			}
+		}));
+
+		this._register(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => {
+			if (e.operation === FileOperation.MOVE || e.operation === FileOperation.DELETE) {
+				for (const { source } of e.files) {
+					if (source) {
+						this._modelReferenceCollection.remove(source);
+					}
+				}
+			}
+		}));
+
+		this._modelTrackers = Object.create(null);
+	}
+
+	public dispose(): void {
+		Object.keys(this._modelTrackers).forEach((modelUrl) => {
+			this._modelTrackers[modelUrl].dispose();
+		});
+		this._modelTrackers = Object.create(null);
+		super.dispose();
+	}
+
+	public isCaughtUpWithContentChanges(resource: URI): boolean {
+		const modelUrl = resource.toString();
+		if (this._modelTrackers[modelUrl]) {
+			return this._modelTrackers[modelUrl].isCaughtUpWithContentChanges();
+		}
+		return true;
+	}
+
+	private _shouldHandleFileEvent(resource: URI): boolean {
+		const model = this._modelService.getModel(resource);
+		return !!model && shouldSynchronizeModel(model);
+	}
+
+	private _onModelAdded(model: ITextModel): void {
+		// Same filter as in mainThreadEditorsTracker
+		if (!shouldSynchronizeModel(model)) {
+			// don't synchronize too large models
+			return;
+		}
+		const modelUrl = model.uri;
+		this._modelIsSynced.add(modelUrl.toString());
+		this._modelTrackers[modelUrl.toString()] = new ModelTracker(model, this._onIsCaughtUpWithContentChanges, this._proxy, this._textFileService);
+	}
+
+	private _onModelModeChanged(event: { model: ITextModel; oldModeId: string; }): void {
+		let { model, oldModeId } = event;
+		const modelUrl = model.uri;
+		if (!this._modelIsSynced.has(modelUrl.toString())) {
+			return;
+		}
+		this._proxy.$acceptModelModeChanged(model.uri, oldModeId, model.getLanguageIdentifier().language);
+	}
+
+	private _onModelRemoved(modelUrl: URI): void {
+		const strModelUrl = modelUrl.toString();
+		if (!this._modelIsSynced.has(strModelUrl)) {
+			return;
+		}
+		this._modelIsSynced.delete(strModelUrl);
+		this._modelTrackers[strModelUrl].dispose();
+		delete this._modelTrackers[strModelUrl];
+	}
+
+	// --- from extension host process
+
+	$trySaveDocument(uri: UriComponents): Promise<boolean> {
+		return this._textFileService.save(URI.revive(uri)).then(target => !!target);
+	}
+
+	$tryOpenDocument(uriData: UriComponents): Promise<URI> {
+		const inputUri = URI.revive(uriData);
+		if (!inputUri.scheme || !(inputUri.fsPath || inputUri.authority)) {
+			return Promise.reject(new Error(`Invalid uri. Scheme and authority or path must be set.`));
+		}
+
+		const canonicalUri = this._uriIdentityService.asCanonicalUri(inputUri);
+
+		let promise: Promise<URI>;
+		switch (canonicalUri.scheme) {
+			case Schemas.untitled:
+				promise = this._handleUntitledScheme(canonicalUri);
+				break;
+			case Schemas.file:
+			default:
+				promise = this._handleAsResourceInput(canonicalUri);
+				break;
+		}
+
+		return promise.then(documentUri => {
+			if (!documentUri) {
+				return Promise.reject(new Error(`cannot open ${canonicalUri.toString()}`));
+			} else if (!extUri.isEqual(documentUri, canonicalUri)) {
+				return Promise.reject(new Error(`cannot open ${canonicalUri.toString()}. Detail: Actual document opened as ${documentUri.toString()}`));
+			} else if (!this._modelIsSynced.has(canonicalUri.toString())) {
+				return Promise.reject(new Error(`cannot open ${canonicalUri.toString()}. Detail: Files above 50MB cannot be synchronized with extensions.`));
+			} else {
+				return canonicalUri;
+			}
+		}, err => {
+			return Promise.reject(new Error(`cannot open ${canonicalUri.toString()}. Detail: ${toErrorMessage(err)}`));
+		});
+	}
+
+	$tryCreateDocument(options?: { language?: string, content?: string }): Promise<URI> {
+		return this._doCreateUntitled(undefined, options ? options.language : undefined, options ? options.content : undefined);
+	}
+
+	private _handleAsResourceInput(uri: URI): Promise<URI> {
+		return this._textModelResolverService.createModelReference(uri).then(ref => {
+			this._modelReferenceCollection.add(uri, ref);
+			return ref.object.textEditorModel.uri;
+		});
+	}
+
+	private _handleUntitledScheme(uri: URI): Promise<URI> {
+		const asLocalUri = toLocalResource(uri, this._environmentService.remoteAuthority, this._pathService.defaultUriScheme);
+		return this._fileService.resolve(asLocalUri).then(stats => {
+			// don't create a new file ontop of an existing file
+			return Promise.reject(new Error('file already exists'));
+		}, err => {
+			return this._doCreateUntitled(Boolean(uri.path) ? uri : undefined);
+		});
+	}
+
+	private _doCreateUntitled(associatedResource?: URI, mode?: string, initialValue?: string): Promise<URI> {
+		return this._textFileService.untitled.resolve({
+			associatedResource,
+			mode,
+			initialValue
+		}).then(model => {
+			const resource = model.resource;
+
+			if (!this._modelIsSynced.has(resource.toString())) {
+				throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);
+			}
+
+			this._proxy.$acceptDirtyStateChanged(resource, true); // mark as dirty
+
+			return resource;
+		});
+	}
+}

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

@@ -0,0 +1,467 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { IDisposable, combinedDisposable, DisposableStore } from 'vs/base/common/lifecycle';
+import { URI } from 'vs/base/common/uri';
+import { ICodeEditor, isCodeEditor, isDiffEditor, IActiveCodeEditor } from 'vs/editor/browser/editorBrowser';
+import { IBulkEditService } from 'vs/editor/browser/services/bulkEditService';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { IEditor } from 'vs/editor/common/editorCommon';
+import { ITextModel } from 'vs/editor/common/model';
+import { IModelService, shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { IFileService } from 'vs/platform/files/common/files';
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainThreadDocuments } from 'vs/workbench/api/browser/mainThreadDocuments';
+import { MainThreadTextEditor } from 'vs/workbench/api/browser/mainThreadEditor';
+import { MainThreadTextEditors } from 'vs/workbench/api/browser/mainThreadEditors';
+import { ExtHostContext, ExtHostDocumentsAndEditorsShape, IDocumentsAndEditorsDelta, IExtHostContext, IModelAddedData, ITextEditorAddData, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { EditorViewColumn, editorGroupToViewColumn } from 'vs/workbench/api/common/shared/editor';
+import { BaseTextEditor } from 'vs/workbench/browser/parts/editor/textEditor';
+import { IEditorPane } from 'vs/workbench/common/editor';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
+import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+import { IWorkingCopyFileService } from 'vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+import { IPathService } from 'vs/workbench/services/path/common/pathService';
+
+namespace delta {
+
+	export function ofSets<T>(before: Set<T>, after: Set<T>): { removed: T[], added: T[] } {
+		const removed: T[] = [];
+		const added: T[] = [];
+		for (let element of before) {
+			if (!after.has(element)) {
+				removed.push(element);
+			}
+		}
+		for (let element of after) {
+			if (!before.has(element)) {
+				added.push(element);
+			}
+		}
+		return { removed, added };
+	}
+
+	export function ofMaps<K, V>(before: Map<K, V>, after: Map<K, V>): { removed: V[], added: V[] } {
+		const removed: V[] = [];
+		const added: V[] = [];
+		for (let [index, value] of before) {
+			if (!after.has(index)) {
+				removed.push(value);
+			}
+		}
+		for (let [index, value] of after) {
+			if (!before.has(index)) {
+				added.push(value);
+			}
+		}
+		return { removed, added };
+	}
+}
+
+class TextEditorSnapshot {
+
+	readonly id: string;
+
+	constructor(
+		readonly editor: IActiveCodeEditor,
+	) {
+		this.id = `${editor.getId()},${editor.getModel().id}`;
+	}
+}
+
+class DocumentAndEditorStateDelta {
+
+	readonly isEmpty: boolean;
+
+	constructor(
+		readonly removedDocuments: ITextModel[],
+		readonly addedDocuments: ITextModel[],
+		readonly removedEditors: TextEditorSnapshot[],
+		readonly addedEditors: TextEditorSnapshot[],
+		readonly oldActiveEditor: string | null | undefined,
+		readonly newActiveEditor: string | null | undefined,
+	) {
+		this.isEmpty = this.removedDocuments.length === 0
+			&& this.addedDocuments.length === 0
+			&& this.removedEditors.length === 0
+			&& this.addedEditors.length === 0
+			&& oldActiveEditor === newActiveEditor;
+	}
+
+	toString(): string {
+		let ret = 'DocumentAndEditorStateDelta\n';
+		ret += `\tRemoved Documents: [${this.removedDocuments.map(d => d.uri.toString(true)).join(', ')}]\n`;
+		ret += `\tAdded Documents: [${this.addedDocuments.map(d => d.uri.toString(true)).join(', ')}]\n`;
+		ret += `\tRemoved Editors: [${this.removedEditors.map(e => e.id).join(', ')}]\n`;
+		ret += `\tAdded Editors: [${this.addedEditors.map(e => e.id).join(', ')}]\n`;
+		ret += `\tNew Active Editor: ${this.newActiveEditor}\n`;
+		return ret;
+	}
+}
+
+class DocumentAndEditorState {
+
+	static compute(before: DocumentAndEditorState | undefined, after: DocumentAndEditorState): DocumentAndEditorStateDelta {
+		if (!before) {
+			return new DocumentAndEditorStateDelta(
+				[], [...after.documents.values()],
+				[], [...after.textEditors.values()],
+				undefined, after.activeEditor
+			);
+		}
+		const documentDelta = delta.ofSets(before.documents, after.documents);
+		const editorDelta = delta.ofMaps(before.textEditors, after.textEditors);
+		const oldActiveEditor = before.activeEditor !== after.activeEditor ? before.activeEditor : undefined;
+		const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
+
+		return new DocumentAndEditorStateDelta(
+			documentDelta.removed, documentDelta.added,
+			editorDelta.removed, editorDelta.added,
+			oldActiveEditor, newActiveEditor
+		);
+	}
+
+	constructor(
+		readonly documents: Set<ITextModel>,
+		readonly textEditors: Map<string, TextEditorSnapshot>,
+		readonly activeEditor: string | null | undefined,
+	) {
+		//
+	}
+}
+
+const enum ActiveEditorOrder {
+	Editor, Panel
+}
+
+class MainThreadDocumentAndEditorStateComputer {
+
+	private readonly _toDispose = new DisposableStore();
+	private _toDisposeOnEditorRemove = new Map<string, IDisposable>();
+	private _currentState?: DocumentAndEditorState;
+	private _activeEditorOrder: ActiveEditorOrder = ActiveEditorOrder.Editor;
+
+	constructor(
+		private readonly _onDidChangeState: (delta: DocumentAndEditorStateDelta) => void,
+		@IModelService private readonly _modelService: IModelService,
+		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@IPanelService private readonly _panelService: IPanelService
+	) {
+		this._modelService.onModelAdded(this._updateStateOnModelAdd, this, this._toDispose);
+		this._modelService.onModelRemoved(_ => this._updateState(), this, this._toDispose);
+		this._editorService.onDidActiveEditorChange(_ => this._updateState(), this, this._toDispose);
+
+		this._codeEditorService.onCodeEditorAdd(this._onDidAddEditor, this, this._toDispose);
+		this._codeEditorService.onCodeEditorRemove(this._onDidRemoveEditor, this, this._toDispose);
+		this._codeEditorService.listCodeEditors().forEach(this._onDidAddEditor, this);
+
+		this._panelService.onDidPanelOpen(_ => this._activeEditorOrder = ActiveEditorOrder.Panel, undefined, this._toDispose);
+		this._panelService.onDidPanelClose(_ => this._activeEditorOrder = ActiveEditorOrder.Editor, undefined, this._toDispose);
+		this._editorService.onDidVisibleEditorsChange(_ => this._activeEditorOrder = ActiveEditorOrder.Editor, undefined, this._toDispose);
+
+		this._updateState();
+	}
+
+	dispose(): void {
+		this._toDispose.dispose();
+	}
+
+	private _onDidAddEditor(e: ICodeEditor): void {
+		this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable(
+			e.onDidChangeModel(() => this._updateState()),
+			e.onDidFocusEditorText(() => this._updateState()),
+			e.onDidFocusEditorWidget(() => this._updateState(e))
+		));
+		this._updateState();
+	}
+
+	private _onDidRemoveEditor(e: ICodeEditor): void {
+		const sub = this._toDisposeOnEditorRemove.get(e.getId());
+		if (sub) {
+			this._toDisposeOnEditorRemove.delete(e.getId());
+			sub.dispose();
+			this._updateState();
+		}
+	}
+
+	private _updateStateOnModelAdd(model: ITextModel): void {
+		if (!shouldSynchronizeModel(model)) {
+			// ignore
+			return;
+		}
+
+		if (!this._currentState) {
+			// too early
+			this._updateState();
+			return;
+		}
+
+		// small (fast) delta
+		this._currentState = new DocumentAndEditorState(
+			this._currentState.documents.add(model),
+			this._currentState.textEditors,
+			this._currentState.activeEditor
+		);
+
+		this._onDidChangeState(new DocumentAndEditorStateDelta(
+			[], [model],
+			[], [],
+			undefined, undefined
+		));
+	}
+
+	private _updateState(widgetFocusCandidate?: ICodeEditor): void {
+
+		// models: ignore too large models
+		const models = new Set<ITextModel>();
+		for (const model of this._modelService.getModels()) {
+			if (shouldSynchronizeModel(model)) {
+				models.add(model);
+			}
+		}
+
+		// editor: only take those that have a not too large model
+		const editors = new Map<string, TextEditorSnapshot>();
+		let activeEditor: string | null = null; // Strict null work. This doesn't like being undefined!
+
+		for (const editor of this._codeEditorService.listCodeEditors()) {
+			if (editor.isSimpleWidget) {
+				continue;
+			}
+			const model = editor.getModel();
+			if (editor.hasModel() && model && shouldSynchronizeModel(model)
+				&& !model.isDisposed() // model disposed
+				&& Boolean(this._modelService.getModel(model.uri)) // model disposing, the flag didn't flip yet but the model service already removed it
+			) {
+				const apiEditor = new TextEditorSnapshot(editor);
+				editors.set(apiEditor.id, apiEditor);
+				if (editor.hasTextFocus() || (widgetFocusCandidate === editor && editor.hasWidgetFocus())) {
+					// text focus has priority, widget focus is tricky because multiple
+					// editors might claim widget focus at the same time. therefore we use a
+					// candidate (which is the editor that has raised an widget focus event)
+					// in addition to the widget focus check
+					activeEditor = apiEditor.id;
+				}
+			}
+		}
+
+		// active editor: if none of the previous editors had focus we try
+		// to match output panels or the active workbench editor with
+		// one of editor we have just computed
+		if (!activeEditor) {
+			let candidate: IEditor | undefined;
+			if (this._activeEditorOrder === ActiveEditorOrder.Editor) {
+				candidate = this._getActiveEditorFromEditorPart() || this._getActiveEditorFromPanel();
+			} else {
+				candidate = this._getActiveEditorFromPanel() || this._getActiveEditorFromEditorPart();
+			}
+
+			if (candidate) {
+				for (const snapshot of editors.values()) {
+					if (candidate === snapshot.editor) {
+						activeEditor = snapshot.id;
+					}
+				}
+			}
+		}
+
+		// compute new state and compare against old
+		const newState = new DocumentAndEditorState(models, editors, activeEditor);
+		const delta = DocumentAndEditorState.compute(this._currentState, newState);
+		if (!delta.isEmpty) {
+			this._currentState = newState;
+			this._onDidChangeState(delta);
+		}
+	}
+
+	private _getActiveEditorFromPanel(): IEditor | undefined {
+		const panel = this._panelService.getActivePanel();
+		if (panel instanceof BaseTextEditor && isCodeEditor(panel.getControl())) {
+			return panel.getControl();
+		} else {
+			return undefined;
+		}
+	}
+
+	private _getActiveEditorFromEditorPart(): IEditor | undefined {
+		let activeTextEditorControl = this._editorService.activeTextEditorControl;
+		if (isDiffEditor(activeTextEditorControl)) {
+			activeTextEditorControl = activeTextEditorControl.getModifiedEditor();
+		}
+		return activeTextEditorControl;
+	}
+}
+
+@extHostCustomer
+export class MainThreadDocumentsAndEditors {
+
+	private readonly _toDispose = new DisposableStore();
+	private readonly _proxy: ExtHostDocumentsAndEditorsShape;
+	private readonly _mainThreadDocuments: MainThreadDocuments;
+	private readonly _textEditors = new Map<string, MainThreadTextEditor>();
+
+	private readonly _onTextEditorAdd = new Emitter<MainThreadTextEditor[]>();
+	private readonly _onTextEditorRemove = new Emitter<string[]>();
+	private readonly _onDocumentAdd = new Emitter<ITextModel[]>();
+	private readonly _onDocumentRemove = new Emitter<URI[]>();
+
+	readonly onTextEditorAdd: Event<MainThreadTextEditor[]> = this._onTextEditorAdd.event;
+	readonly onTextEditorRemove: Event<string[]> = this._onTextEditorRemove.event;
+	readonly onDocumentAdd: Event<ITextModel[]> = this._onDocumentAdd.event;
+	readonly onDocumentRemove: Event<URI[]> = this._onDocumentRemove.event;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IModelService private readonly _modelService: IModelService,
+		@ITextFileService private readonly _textFileService: ITextFileService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@ICodeEditorService codeEditorService: ICodeEditorService,
+		@IFileService fileService: IFileService,
+		@ITextModelService textModelResolverService: ITextModelService,
+		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
+		@IBulkEditService bulkEditService: IBulkEditService,
+		@IPanelService panelService: IPanelService,
+		@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService,
+		@IWorkingCopyFileService workingCopyFileService: IWorkingCopyFileService,
+		@IUriIdentityService uriIdentityService: IUriIdentityService,
+		@IClipboardService private readonly _clipboardService: IClipboardService,
+		@IPathService pathService: IPathService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentsAndEditors);
+
+		this._mainThreadDocuments = this._toDispose.add(new MainThreadDocuments(this, extHostContext, this._modelService, this._textFileService, fileService, textModelResolverService, environmentService, uriIdentityService, workingCopyFileService, pathService));
+		extHostContext.set(MainContext.MainThreadDocuments, this._mainThreadDocuments);
+
+		const mainThreadTextEditors = this._toDispose.add(new MainThreadTextEditors(this, extHostContext, codeEditorService, bulkEditService, this._editorService, this._editorGroupService));
+		extHostContext.set(MainContext.MainThreadTextEditors, mainThreadTextEditors);
+
+		// It is expected that the ctor of the state computer calls our `_onDelta`.
+		this._toDispose.add(new MainThreadDocumentAndEditorStateComputer(delta => this._onDelta(delta), _modelService, codeEditorService, this._editorService, panelService));
+
+		this._toDispose.add(this._onTextEditorAdd);
+		this._toDispose.add(this._onTextEditorRemove);
+		this._toDispose.add(this._onDocumentAdd);
+		this._toDispose.add(this._onDocumentRemove);
+	}
+
+	dispose(): void {
+		this._toDispose.dispose();
+	}
+
+	private _onDelta(delta: DocumentAndEditorStateDelta): void {
+
+		let removedDocuments: URI[];
+		const removedEditors: string[] = [];
+		const addedEditors: MainThreadTextEditor[] = [];
+
+		// removed models
+		removedDocuments = delta.removedDocuments.map(m => m.uri);
+
+		// added editors
+		for (const apiEditor of delta.addedEditors) {
+			const mainThreadEditor = new MainThreadTextEditor(apiEditor.id, apiEditor.editor.getModel(),
+				apiEditor.editor, { onGainedFocus() { }, onLostFocus() { } }, this._mainThreadDocuments, this._modelService, this._clipboardService);
+
+			this._textEditors.set(apiEditor.id, mainThreadEditor);
+			addedEditors.push(mainThreadEditor);
+		}
+
+		// removed editors
+		for (const { id } of delta.removedEditors) {
+			const mainThreadEditor = this._textEditors.get(id);
+			if (mainThreadEditor) {
+				mainThreadEditor.dispose();
+				this._textEditors.delete(id);
+				removedEditors.push(id);
+			}
+		}
+
+		const extHostDelta: IDocumentsAndEditorsDelta = Object.create(null);
+		let empty = true;
+		if (delta.newActiveEditor !== undefined) {
+			empty = false;
+			extHostDelta.newActiveEditor = delta.newActiveEditor;
+		}
+		if (removedDocuments.length > 0) {
+			empty = false;
+			extHostDelta.removedDocuments = removedDocuments;
+		}
+		if (removedEditors.length > 0) {
+			empty = false;
+			extHostDelta.removedEditors = removedEditors;
+		}
+		if (delta.addedDocuments.length > 0) {
+			empty = false;
+			extHostDelta.addedDocuments = delta.addedDocuments.map(m => this._toModelAddData(m));
+		}
+		if (delta.addedEditors.length > 0) {
+			empty = false;
+			extHostDelta.addedEditors = addedEditors.map(e => this._toTextEditorAddData(e));
+		}
+
+		if (!empty) {
+			// first update ext host
+			this._proxy.$acceptDocumentsAndEditorsDelta(extHostDelta);
+			// second update dependent state listener
+			this._onDocumentRemove.fire(removedDocuments);
+			this._onDocumentAdd.fire(delta.addedDocuments);
+			this._onTextEditorRemove.fire(removedEditors);
+			this._onTextEditorAdd.fire(addedEditors);
+		}
+	}
+
+	private _toModelAddData(model: ITextModel): IModelAddedData {
+		return {
+			uri: model.uri,
+			versionId: model.getVersionId(),
+			lines: model.getLinesContent(),
+			EOL: model.getEOL(),
+			modeId: model.getLanguageIdentifier().language,
+			isDirty: this._textFileService.isDirty(model.uri)
+		};
+	}
+
+	private _toTextEditorAddData(textEditor: MainThreadTextEditor): ITextEditorAddData {
+		const props = textEditor.getProperties();
+		return {
+			id: textEditor.getId(),
+			documentUri: textEditor.getModel().uri,
+			options: props.options,
+			selections: props.selections,
+			visibleRanges: props.visibleRanges,
+			editorPosition: this._findEditorPosition(textEditor)
+		};
+	}
+
+	private _findEditorPosition(editor: MainThreadTextEditor): EditorViewColumn | undefined {
+		for (const editorPane of this._editorService.visibleEditorPanes) {
+			if (editor.matches(editorPane)) {
+				return editorGroupToViewColumn(this._editorGroupService, editorPane.group);
+			}
+		}
+		return undefined;
+	}
+
+	findTextEditorIdFor(editorPane: IEditorPane): string | undefined {
+		for (const [id, editor] of this._textEditors) {
+			if (editor.matches(editorPane)) {
+				return id;
+			}
+		}
+		return undefined;
+	}
+
+	getEditor(id: string): MainThreadTextEditor | undefined {
+		return this._textEditors.get(id);
+	}
+}

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

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { MainContext, IExtHostContext, MainThreadDownloadServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDownloadService } from 'vs/platform/download/common/download';
+import { UriComponents, URI } from 'vs/base/common/uri';
+
+@extHostNamedCustomer(MainContext.MainThreadDownloadService)
+export class MainThreadDownloadService extends Disposable implements MainThreadDownloadServiceShape {
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IDownloadService private readonly downloadService: IDownloadService
+	) {
+		super();
+	}
+
+	$download(uri: UriComponents, to: UriComponents): Promise<void> {
+		return this.downloadService.download(URI.revive(uri), URI.revive(to));
+	}
+
+}

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

@@ -0,0 +1,547 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
+import { RenderLineNumbersType, TextEditorCursorStyle, cursorStyleToString, EditorOption } from 'vs/editor/common/config/editorOptions';
+import { IRange, Range } from 'vs/editor/common/core/range';
+import { ISelection, Selection } from 'vs/editor/common/core/selection';
+import { IDecorationOptions, ScrollType } from 'vs/editor/common/editorCommon';
+import { ISingleEditOperation, ITextModel, ITextModelUpdateOptions, IIdentifiedSingleEditOperation } from 'vs/editor/common/model';
+import { IModelService } from 'vs/editor/common/services/modelService';
+import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
+import { IApplyEditsOptions, IEditorPropertiesChangeData, IResolvedTextEditorConfiguration, ITextEditorConfigurationUpdate, IUndoStopOptions, TextEditorRevealType } from 'vs/workbench/api/common/extHost.protocol';
+import { IEditorPane } from 'vs/workbench/common/editor';
+import { withNullAsUndefined } from 'vs/base/common/types';
+import { equals } from 'vs/base/common/arrays';
+import { CodeEditorStateFlag, EditorState } from 'vs/editor/browser/core/editorState';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+import { SnippetParser } from 'vs/editor/contrib/snippet/snippetParser';
+import { MainThreadDocuments } from 'vs/workbench/api/browser/mainThreadDocuments';
+
+export interface IFocusTracker {
+	onGainedFocus(): void;
+	onLostFocus(): void;
+}
+
+export class MainThreadTextEditorProperties {
+
+	public static readFromEditor(previousProperties: MainThreadTextEditorProperties | null, model: ITextModel, codeEditor: ICodeEditor | null): MainThreadTextEditorProperties {
+		const selections = MainThreadTextEditorProperties._readSelectionsFromCodeEditor(previousProperties, codeEditor);
+		const options = MainThreadTextEditorProperties._readOptionsFromCodeEditor(previousProperties, model, codeEditor);
+		const visibleRanges = MainThreadTextEditorProperties._readVisibleRangesFromCodeEditor(previousProperties, codeEditor);
+		return new MainThreadTextEditorProperties(selections, options, visibleRanges);
+	}
+
+	private static _readSelectionsFromCodeEditor(previousProperties: MainThreadTextEditorProperties | null, codeEditor: ICodeEditor | null): Selection[] {
+		let result: Selection[] | null = null;
+		if (codeEditor) {
+			result = codeEditor.getSelections();
+		}
+		if (!result && previousProperties) {
+			result = previousProperties.selections;
+		}
+		if (!result) {
+			result = [new Selection(1, 1, 1, 1)];
+		}
+		return result;
+	}
+
+	private static _readOptionsFromCodeEditor(previousProperties: MainThreadTextEditorProperties | null, model: ITextModel, codeEditor: ICodeEditor | null): IResolvedTextEditorConfiguration {
+		if (model.isDisposed()) {
+			if (previousProperties) {
+				// shutdown time
+				return previousProperties.options;
+			} else {
+				throw new Error('No valid properties');
+			}
+		}
+
+		let cursorStyle: TextEditorCursorStyle;
+		let lineNumbers: RenderLineNumbersType;
+		if (codeEditor) {
+			const options = codeEditor.getOptions();
+			const lineNumbersOpts = options.get(EditorOption.lineNumbers);
+			cursorStyle = options.get(EditorOption.cursorStyle);
+			lineNumbers = lineNumbersOpts.renderType;
+		} else if (previousProperties) {
+			cursorStyle = previousProperties.options.cursorStyle;
+			lineNumbers = previousProperties.options.lineNumbers;
+		} else {
+			cursorStyle = TextEditorCursorStyle.Line;
+			lineNumbers = RenderLineNumbersType.On;
+		}
+
+		const modelOptions = model.getOptions();
+		return {
+			insertSpaces: modelOptions.insertSpaces,
+			tabSize: modelOptions.tabSize,
+			indentSize: modelOptions.indentSize,
+			cursorStyle: cursorStyle,
+			lineNumbers: lineNumbers
+		};
+	}
+
+	private static _readVisibleRangesFromCodeEditor(previousProperties: MainThreadTextEditorProperties | null, codeEditor: ICodeEditor | null): Range[] {
+		if (codeEditor) {
+			return codeEditor.getVisibleRanges();
+		}
+		return [];
+	}
+
+	constructor(
+		public readonly selections: Selection[],
+		public readonly options: IResolvedTextEditorConfiguration,
+		public readonly visibleRanges: Range[]
+	) {
+	}
+
+	public generateDelta(oldProps: MainThreadTextEditorProperties | null, selectionChangeSource: string | null): IEditorPropertiesChangeData | null {
+		const delta: IEditorPropertiesChangeData = {
+			options: null,
+			selections: null,
+			visibleRanges: null
+		};
+
+		if (!oldProps || !MainThreadTextEditorProperties._selectionsEqual(oldProps.selections, this.selections)) {
+			delta.selections = {
+				selections: this.selections,
+				source: withNullAsUndefined(selectionChangeSource)
+			};
+		}
+
+		if (!oldProps || !MainThreadTextEditorProperties._optionsEqual(oldProps.options, this.options)) {
+			delta.options = this.options;
+		}
+
+		if (!oldProps || !MainThreadTextEditorProperties._rangesEqual(oldProps.visibleRanges, this.visibleRanges)) {
+			delta.visibleRanges = this.visibleRanges;
+		}
+
+		if (delta.selections || delta.options || delta.visibleRanges) {
+			// something changed
+			return delta;
+		}
+		// nothing changed
+		return null;
+	}
+
+	private static _selectionsEqual(a: readonly Selection[], b: readonly Selection[]): boolean {
+		return equals(a, b, (aValue, bValue) => aValue.equalsSelection(bValue));
+	}
+
+	private static _rangesEqual(a: readonly Range[], b: readonly Range[]): boolean {
+		return equals(a, b, (aValue, bValue) => aValue.equalsRange(bValue));
+	}
+
+	private static _optionsEqual(a: IResolvedTextEditorConfiguration, b: IResolvedTextEditorConfiguration): boolean {
+		if (a && !b || !a && b) {
+			return false;
+		}
+		if (!a && !b) {
+			return true;
+		}
+		return (
+			a.tabSize === b.tabSize
+			&& a.indentSize === b.indentSize
+			&& a.insertSpaces === b.insertSpaces
+			&& a.cursorStyle === b.cursorStyle
+			&& a.lineNumbers === b.lineNumbers
+		);
+	}
+}
+
+/**
+ * Text Editor that is permanently bound to the same model.
+ * It can be bound or not to a CodeEditor.
+ */
+export class MainThreadTextEditor {
+
+	private readonly _id: string;
+	private readonly _model: ITextModel;
+	private readonly _mainThreadDocuments: MainThreadDocuments;
+	private readonly _modelService: IModelService;
+	private readonly _clipboardService: IClipboardService;
+	private readonly _modelListeners = new DisposableStore();
+	private _codeEditor: ICodeEditor | null;
+	private readonly _focusTracker: IFocusTracker;
+	private readonly _codeEditorListeners = new DisposableStore();
+
+	private _properties: MainThreadTextEditorProperties | null;
+	private readonly _onPropertiesChanged: Emitter<IEditorPropertiesChangeData>;
+
+	constructor(
+		id: string,
+		model: ITextModel,
+		codeEditor: ICodeEditor,
+		focusTracker: IFocusTracker,
+		mainThreadDocuments: MainThreadDocuments,
+		modelService: IModelService,
+		clipboardService: IClipboardService,
+	) {
+		this._id = id;
+		this._model = model;
+		this._codeEditor = null;
+		this._properties = null;
+		this._focusTracker = focusTracker;
+		this._mainThreadDocuments = mainThreadDocuments;
+		this._modelService = modelService;
+		this._clipboardService = clipboardService;
+
+		this._onPropertiesChanged = new Emitter<IEditorPropertiesChangeData>();
+
+		this._modelListeners.add(this._model.onDidChangeOptions((e) => {
+			this._updatePropertiesNow(null);
+		}));
+
+		this.setCodeEditor(codeEditor);
+		this._updatePropertiesNow(null);
+	}
+
+	public dispose(): void {
+		this._modelListeners.dispose();
+		this._codeEditor = null;
+		this._codeEditorListeners.dispose();
+	}
+
+	private _updatePropertiesNow(selectionChangeSource: string | null): void {
+		this._setProperties(
+			MainThreadTextEditorProperties.readFromEditor(this._properties, this._model, this._codeEditor),
+			selectionChangeSource
+		);
+	}
+
+	private _setProperties(newProperties: MainThreadTextEditorProperties, selectionChangeSource: string | null): void {
+		const delta = newProperties.generateDelta(this._properties, selectionChangeSource);
+		this._properties = newProperties;
+		if (delta) {
+			this._onPropertiesChanged.fire(delta);
+		}
+	}
+
+	public getId(): string {
+		return this._id;
+	}
+
+	public getModel(): ITextModel {
+		return this._model;
+	}
+
+	public getCodeEditor(): ICodeEditor | null {
+		return this._codeEditor;
+	}
+
+	public hasCodeEditor(codeEditor: ICodeEditor | null): boolean {
+		return (this._codeEditor === codeEditor);
+	}
+
+	public setCodeEditor(codeEditor: ICodeEditor | null): void {
+		if (this.hasCodeEditor(codeEditor)) {
+			// Nothing to do...
+			return;
+		}
+		this._codeEditorListeners.clear();
+
+		this._codeEditor = codeEditor;
+		if (this._codeEditor) {
+
+			// Catch early the case that this code editor gets a different model set and disassociate from this model
+			this._codeEditorListeners.add(this._codeEditor.onDidChangeModel(() => {
+				this.setCodeEditor(null);
+			}));
+
+			this._codeEditorListeners.add(this._codeEditor.onDidFocusEditorWidget(() => {
+				this._focusTracker.onGainedFocus();
+			}));
+			this._codeEditorListeners.add(this._codeEditor.onDidBlurEditorWidget(() => {
+				this._focusTracker.onLostFocus();
+			}));
+
+			let nextSelectionChangeSource: string | null = null;
+			this._codeEditorListeners.add(this._mainThreadDocuments.onIsCaughtUpWithContentChanges((uri) => {
+				if (uri.toString() === this._model.uri.toString()) {
+					const selectionChangeSource = nextSelectionChangeSource;
+					nextSelectionChangeSource = null;
+					this._updatePropertiesNow(selectionChangeSource);
+				}
+			}));
+
+			const isValidCodeEditor = () => {
+				// Due to event timings, it is possible that there is a model change event not yet delivered to us.
+				// > e.g. a model change event is emitted to a listener which then decides to update editor options
+				// > In this case the editor configuration change event reaches us first.
+				// So simply check that the model is still attached to this code editor
+				return (this._codeEditor && this._codeEditor.getModel() === this._model);
+			};
+
+			const updateProperties = (selectionChangeSource: string | null) => {
+				// Some editor events get delivered faster than model content changes. This is
+				// problematic, as this leads to editor properties reaching the extension host
+				// too soon, before the model content change that was the root cause.
+				//
+				// If this case is identified, then let's update editor properties on the next model
+				// content change instead.
+				if (this._mainThreadDocuments.isCaughtUpWithContentChanges(this._model.uri)) {
+					nextSelectionChangeSource = null;
+					this._updatePropertiesNow(selectionChangeSource);
+				} else {
+					// update editor properties on the next model content change
+					nextSelectionChangeSource = selectionChangeSource;
+				}
+			};
+
+			this._codeEditorListeners.add(this._codeEditor.onDidChangeCursorSelection((e) => {
+				// selection
+				if (!isValidCodeEditor()) {
+					return;
+				}
+				updateProperties(e.source);
+			}));
+			this._codeEditorListeners.add(this._codeEditor.onDidChangeConfiguration((e) => {
+				// options
+				if (!isValidCodeEditor()) {
+					return;
+				}
+				updateProperties(null);
+			}));
+			this._codeEditorListeners.add(this._codeEditor.onDidLayoutChange(() => {
+				// visibleRanges
+				if (!isValidCodeEditor()) {
+					return;
+				}
+				updateProperties(null);
+			}));
+			this._codeEditorListeners.add(this._codeEditor.onDidScrollChange(() => {
+				// visibleRanges
+				if (!isValidCodeEditor()) {
+					return;
+				}
+				updateProperties(null);
+			}));
+			this._updatePropertiesNow(null);
+		}
+	}
+
+	public isVisible(): boolean {
+		return !!this._codeEditor;
+	}
+
+	public getProperties(): MainThreadTextEditorProperties {
+		return this._properties!;
+	}
+
+	public get onPropertiesChanged(): Event<IEditorPropertiesChangeData> {
+		return this._onPropertiesChanged.event;
+	}
+
+	public setSelections(selections: ISelection[]): void {
+		if (this._codeEditor) {
+			this._codeEditor.setSelections(selections);
+			return;
+		}
+
+		const newSelections = selections.map(Selection.liftSelection);
+		this._setProperties(
+			new MainThreadTextEditorProperties(newSelections, this._properties!.options, this._properties!.visibleRanges),
+			null
+		);
+	}
+
+	private _setIndentConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
+		const creationOpts = this._modelService.getCreationOptions(this._model.getLanguageIdentifier().language, this._model.uri, this._model.isForSimpleWidget);
+
+		if (newConfiguration.tabSize === 'auto' || newConfiguration.insertSpaces === 'auto') {
+			// one of the options was set to 'auto' => detect indentation
+			let insertSpaces = creationOpts.insertSpaces;
+			let tabSize = creationOpts.tabSize;
+
+			if (newConfiguration.insertSpaces !== 'auto' && typeof newConfiguration.insertSpaces !== 'undefined') {
+				insertSpaces = newConfiguration.insertSpaces;
+			}
+
+			if (newConfiguration.tabSize !== 'auto' && typeof newConfiguration.tabSize !== 'undefined') {
+				tabSize = newConfiguration.tabSize;
+			}
+
+			this._model.detectIndentation(insertSpaces, tabSize);
+			return;
+		}
+
+		const newOpts: ITextModelUpdateOptions = {};
+		if (typeof newConfiguration.insertSpaces !== 'undefined') {
+			newOpts.insertSpaces = newConfiguration.insertSpaces;
+		}
+		if (typeof newConfiguration.tabSize !== 'undefined') {
+			newOpts.tabSize = newConfiguration.tabSize;
+		}
+		if (typeof newConfiguration.indentSize !== 'undefined') {
+			if (newConfiguration.indentSize === 'tabSize') {
+				newOpts.indentSize = newOpts.tabSize || creationOpts.tabSize;
+			} else {
+				newOpts.indentSize = newConfiguration.indentSize;
+			}
+		}
+		this._model.updateOptions(newOpts);
+	}
+
+	public setConfiguration(newConfiguration: ITextEditorConfigurationUpdate): void {
+		this._setIndentConfiguration(newConfiguration);
+
+		if (!this._codeEditor) {
+			return;
+		}
+
+		if (newConfiguration.cursorStyle) {
+			const newCursorStyle = cursorStyleToString(newConfiguration.cursorStyle);
+			this._codeEditor.updateOptions({
+				cursorStyle: newCursorStyle
+			});
+		}
+
+		if (typeof newConfiguration.lineNumbers !== 'undefined') {
+			let lineNumbers: 'on' | 'off' | 'relative';
+			switch (newConfiguration.lineNumbers) {
+				case RenderLineNumbersType.On:
+					lineNumbers = 'on';
+					break;
+				case RenderLineNumbersType.Relative:
+					lineNumbers = 'relative';
+					break;
+				default:
+					lineNumbers = 'off';
+			}
+			this._codeEditor.updateOptions({
+				lineNumbers: lineNumbers
+			});
+		}
+	}
+
+	public setDecorations(key: string, ranges: IDecorationOptions[]): void {
+		if (!this._codeEditor) {
+			return;
+		}
+		this._codeEditor.setDecorations(key, ranges);
+	}
+
+	public setDecorationsFast(key: string, _ranges: number[]): void {
+		if (!this._codeEditor) {
+			return;
+		}
+		const ranges: Range[] = [];
+		for (let i = 0, len = Math.floor(_ranges.length / 4); i < len; i++) {
+			ranges[i] = new Range(_ranges[4 * i], _ranges[4 * i + 1], _ranges[4 * i + 2], _ranges[4 * i + 3]);
+		}
+		this._codeEditor.setDecorationsFast(key, ranges);
+	}
+
+	public revealRange(range: IRange, revealType: TextEditorRevealType): void {
+		if (!this._codeEditor) {
+			return;
+		}
+		switch (revealType) {
+			case TextEditorRevealType.Default:
+				this._codeEditor.revealRange(range, ScrollType.Smooth);
+				break;
+			case TextEditorRevealType.InCenter:
+				this._codeEditor.revealRangeInCenter(range, ScrollType.Smooth);
+				break;
+			case TextEditorRevealType.InCenterIfOutsideViewport:
+				this._codeEditor.revealRangeInCenterIfOutsideViewport(range, ScrollType.Smooth);
+				break;
+			case TextEditorRevealType.AtTop:
+				this._codeEditor.revealRangeAtTop(range, ScrollType.Smooth);
+				break;
+			default:
+				console.warn(`Unknown revealType: ${revealType}`);
+				break;
+		}
+	}
+
+	public isFocused(): boolean {
+		if (this._codeEditor) {
+			return this._codeEditor.hasTextFocus();
+		}
+		return false;
+	}
+
+	public matches(editor: IEditorPane): boolean {
+		if (!editor) {
+			return false;
+		}
+		return editor.getControl() === this._codeEditor;
+	}
+
+	public applyEdits(versionIdCheck: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): boolean {
+		if (this._model.getVersionId() !== versionIdCheck) {
+			// throw new Error('Model has changed in the meantime!');
+			// model changed in the meantime
+			return false;
+		}
+
+		if (!this._codeEditor) {
+			// console.warn('applyEdits on invisible editor');
+			return false;
+		}
+
+		if (typeof opts.setEndOfLine !== 'undefined') {
+			this._model.pushEOL(opts.setEndOfLine);
+		}
+
+		const transformedEdits = edits.map((edit): IIdentifiedSingleEditOperation => {
+			return {
+				range: Range.lift(edit.range),
+				text: edit.text,
+				forceMoveMarkers: edit.forceMoveMarkers
+			};
+		});
+
+		if (opts.undoStopBefore) {
+			this._codeEditor.pushUndoStop();
+		}
+		this._codeEditor.executeEdits('MainThreadTextEditor', transformedEdits);
+		if (opts.undoStopAfter) {
+			this._codeEditor.pushUndoStop();
+		}
+		return true;
+	}
+
+	async insertSnippet(template: string, ranges: readonly IRange[], opts: IUndoStopOptions) {
+
+		if (!this._codeEditor || !this._codeEditor.hasModel()) {
+			return false;
+		}
+
+		// check if clipboard is required and only iff read it (async)
+		let clipboardText: string | undefined;
+		const needsTemplate = SnippetParser.guessNeedsClipboard(template);
+		if (needsTemplate) {
+			const state = new EditorState(this._codeEditor, CodeEditorStateFlag.Value | CodeEditorStateFlag.Position);
+			clipboardText = await this._clipboardService.readText();
+			if (!state.validate(this._codeEditor)) {
+				return false;
+			}
+		}
+
+		const snippetController = SnippetController2.get(this._codeEditor);
+
+		// // cancel previous snippet mode
+		// snippetController.leaveSnippet();
+
+		// set selection, focus editor
+		const selections = ranges.map(r => new Selection(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn));
+		this._codeEditor.setSelections(selections);
+		this._codeEditor.focus();
+
+		// make modifications
+		snippetController.insert(template, {
+			overwriteBefore: 0, overwriteAfter: 0,
+			undoStopBefore: opts.undoStopBefore, undoStopAfter: opts.undoStopAfter,
+			clipboardText
+		});
+
+		return true;
+	}
+}

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

@@ -0,0 +1,363 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { disposed } from 'vs/base/common/errors';
+import { IDisposable, dispose, DisposableStore } from 'vs/base/common/lifecycle';
+import { equals as objectEquals } from 'vs/base/common/objects';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IBulkEditService, ResourceEdit, ResourceFileEdit, ResourceTextEdit } from 'vs/editor/browser/services/bulkEditService';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
+import { IRange } from 'vs/editor/common/core/range';
+import { ISelection } from 'vs/editor/common/core/selection';
+import { IDecorationOptions, IDecorationRenderOptions, ILineChange } from 'vs/editor/common/editorCommon';
+import { ISingleEditOperation } from 'vs/editor/common/model';
+import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { IEditorOptions, ITextEditorOptions, IResourceEditorInput, EditorActivation } from 'vs/platform/editor/common/editor';
+import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IOpenerService } from 'vs/platform/opener/common/opener';
+import { MainThreadDocumentsAndEditors } from 'vs/workbench/api/browser/mainThreadDocumentsAndEditors';
+import { MainThreadTextEditor } from 'vs/workbench/api/browser/mainThreadEditor';
+import { ExtHostContext, ExtHostEditorsShape, IApplyEditsOptions, IExtHostContext, ITextDocumentShowOptions, ITextEditorConfigurationUpdate, ITextEditorPositionData, IUndoStopOptions, MainThreadTextEditorsShape, TextEditorRevealType, IWorkspaceEditDto, WorkspaceEditType } from 'vs/workbench/api/common/extHost.protocol';
+import { EditorViewColumn, editorGroupToViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
+import { openEditorWith } from 'vs/workbench/services/editor/common/editorOpenWith';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IWorkingCopyService } from 'vs/workbench/services/workingCopy/common/workingCopyService';
+import { revive } from 'vs/base/common/marshalling';
+import { ResourceNotebookCellEdit } from 'vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+
+function reviveWorkspaceEditDto2(data: IWorkspaceEditDto | undefined): ResourceEdit[] {
+	if (!data?.edits) {
+		return [];
+	}
+
+	const result: ResourceEdit[] = [];
+	for (let edit of revive<IWorkspaceEditDto>(data).edits) {
+		if (edit._type === WorkspaceEditType.File) {
+			result.push(new ResourceFileEdit(edit.oldUri, edit.newUri, edit.options, edit.metadata));
+		} else if (edit._type === WorkspaceEditType.Text) {
+			result.push(new ResourceTextEdit(edit.resource, edit.edit, edit.modelVersionId, edit.metadata));
+		} else if (edit._type === WorkspaceEditType.Cell) {
+			result.push(new ResourceNotebookCellEdit(edit.resource, edit.edit, edit.notebookVersionId, edit.metadata));
+		}
+	}
+	return result;
+}
+
+export class MainThreadTextEditors implements MainThreadTextEditorsShape {
+
+	private static INSTANCE_COUNT: number = 0;
+
+	private readonly _instanceId: string;
+	private readonly _proxy: ExtHostEditorsShape;
+	private readonly _documentsAndEditors: MainThreadDocumentsAndEditors;
+	private readonly _toDispose = new DisposableStore();
+	private _textEditorsListenersMap: { [editorId: string]: IDisposable[]; };
+	private _editorPositionData: ITextEditorPositionData | null;
+	private _registeredDecorationTypes: { [decorationType: string]: boolean; };
+
+	constructor(
+		documentsAndEditors: MainThreadDocumentsAndEditors,
+		extHostContext: IExtHostContext,
+		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
+		@IBulkEditService private readonly _bulkEditService: IBulkEditService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService
+	) {
+		this._instanceId = String(++MainThreadTextEditors.INSTANCE_COUNT);
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostEditors);
+		this._documentsAndEditors = documentsAndEditors;
+
+		this._textEditorsListenersMap = Object.create(null);
+		this._editorPositionData = null;
+
+		this._toDispose.add(documentsAndEditors.onTextEditorAdd(editors => editors.forEach(this._onTextEditorAdd, this)));
+		this._toDispose.add(documentsAndEditors.onTextEditorRemove(editors => editors.forEach(this._onTextEditorRemove, this)));
+
+		this._toDispose.add(this._editorService.onDidVisibleEditorsChange(() => this._updateActiveAndVisibleTextEditors()));
+		this._toDispose.add(this._editorGroupService.onDidRemoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+		this._toDispose.add(this._editorGroupService.onDidMoveGroup(() => this._updateActiveAndVisibleTextEditors()));
+
+		this._registeredDecorationTypes = Object.create(null);
+	}
+
+	public dispose(): void {
+		Object.keys(this._textEditorsListenersMap).forEach((editorId) => {
+			dispose(this._textEditorsListenersMap[editorId]);
+		});
+		this._textEditorsListenersMap = Object.create(null);
+		this._toDispose.dispose();
+		for (let decorationType in this._registeredDecorationTypes) {
+			this._codeEditorService.removeDecorationType(decorationType);
+		}
+		this._registeredDecorationTypes = Object.create(null);
+	}
+
+	private _onTextEditorAdd(textEditor: MainThreadTextEditor): void {
+		const id = textEditor.getId();
+		const toDispose: IDisposable[] = [];
+		toDispose.push(textEditor.onPropertiesChanged((data) => {
+			this._proxy.$acceptEditorPropertiesChanged(id, data);
+		}));
+
+		this._textEditorsListenersMap[id] = toDispose;
+	}
+
+	private _onTextEditorRemove(id: string): void {
+		dispose(this._textEditorsListenersMap[id]);
+		delete this._textEditorsListenersMap[id];
+	}
+
+	private _updateActiveAndVisibleTextEditors(): void {
+
+		// editor columns
+		const editorPositionData = this._getTextEditorPositionData();
+		if (!objectEquals(this._editorPositionData, editorPositionData)) {
+			this._editorPositionData = editorPositionData;
+			this._proxy.$acceptEditorPositionData(this._editorPositionData);
+		}
+	}
+
+	private _getTextEditorPositionData(): ITextEditorPositionData {
+		const result: ITextEditorPositionData = Object.create(null);
+		for (let editorPane of this._editorService.visibleEditorPanes) {
+			const id = this._documentsAndEditors.findTextEditorIdFor(editorPane);
+			if (id) {
+				result[id] = editorGroupToViewColumn(this._editorGroupService, editorPane.group);
+			}
+		}
+		return result;
+	}
+
+	// --- from extension host process
+
+	async $tryShowTextDocument(resource: UriComponents, options: ITextDocumentShowOptions): Promise<string | undefined> {
+		const uri = URI.revive(resource);
+
+		const editorOptions: ITextEditorOptions = {
+			preserveFocus: options.preserveFocus,
+			pinned: options.pinned,
+			selection: options.selection,
+			// preserve pre 1.38 behaviour to not make group active when preserveFocus: true
+			// but make sure to restore the editor to fix https://github.com/microsoft/vscode/issues/79633
+			activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
+			override: false
+		};
+
+		const input: IResourceEditorInput = {
+			resource: uri,
+			options: editorOptions
+		};
+
+		const editor = await this._editorService.openEditor(input, viewColumnToEditorGroup(this._editorGroupService, options.position));
+		if (!editor) {
+			return undefined;
+		}
+		return this._documentsAndEditors.findTextEditorIdFor(editor);
+	}
+
+	async $tryShowEditor(id: string, position?: EditorViewColumn): Promise<void> {
+		const mainThreadEditor = this._documentsAndEditors.getEditor(id);
+		if (mainThreadEditor) {
+			const model = mainThreadEditor.getModel();
+			await this._editorService.openEditor({
+				resource: model.uri,
+				options: { preserveFocus: false }
+			}, viewColumnToEditorGroup(this._editorGroupService, position));
+			return;
+		}
+	}
+
+	async $tryHideEditor(id: string): Promise<void> {
+		const mainThreadEditor = this._documentsAndEditors.getEditor(id);
+		if (mainThreadEditor) {
+			const editorPanes = this._editorService.visibleEditorPanes;
+			for (let editorPane of editorPanes) {
+				if (mainThreadEditor.matches(editorPane)) {
+					return editorPane.group.closeEditor(editorPane.input);
+				}
+			}
+		}
+	}
+
+	$trySetSelections(id: string, selections: ISelection[]): Promise<void> {
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		editor.setSelections(selections);
+		return Promise.resolve(undefined);
+	}
+
+	$trySetDecorations(id: string, key: string, ranges: IDecorationOptions[]): Promise<void> {
+		key = `${this._instanceId}-${key}`;
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		editor.setDecorations(key, ranges);
+		return Promise.resolve(undefined);
+	}
+
+	$trySetDecorationsFast(id: string, key: string, ranges: number[]): Promise<void> {
+		key = `${this._instanceId}-${key}`;
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		editor.setDecorationsFast(key, ranges);
+		return Promise.resolve(undefined);
+	}
+
+	$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): Promise<void> {
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		editor.revealRange(range, revealType);
+		return Promise.resolve();
+	}
+
+	$trySetOptions(id: string, options: ITextEditorConfigurationUpdate): Promise<void> {
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		editor.setConfiguration(options);
+		return Promise.resolve(undefined);
+	}
+
+	$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): Promise<boolean> {
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		return Promise.resolve(editor.applyEdits(modelVersionId, edits, opts));
+	}
+
+	$tryApplyWorkspaceEdit(dto: IWorkspaceEditDto): Promise<boolean> {
+		const edits = reviveWorkspaceEditDto2(dto);
+		return this._bulkEditService.apply(edits).then(() => true, _err => false);
+	}
+
+	$tryInsertSnippet(id: string, template: string, ranges: readonly IRange[], opts: IUndoStopOptions): Promise<boolean> {
+		const editor = this._documentsAndEditors.getEditor(id);
+		if (!editor) {
+			return Promise.reject(disposed(`TextEditor(${id})`));
+		}
+		return Promise.resolve(editor.insertSnippet(template, ranges, opts));
+	}
+
+	$registerTextEditorDecorationType(key: string, options: IDecorationRenderOptions): void {
+		key = `${this._instanceId}-${key}`;
+		this._registeredDecorationTypes[key] = true;
+		this._codeEditorService.registerDecorationType(key, options);
+	}
+
+	$removeTextEditorDecorationType(key: string): void {
+		key = `${this._instanceId}-${key}`;
+		delete this._registeredDecorationTypes[key];
+		this._codeEditorService.removeDecorationType(key);
+	}
+
+	$getDiffInformation(id: string): Promise<ILineChange[]> {
+		const editor = this._documentsAndEditors.getEditor(id);
+
+		if (!editor) {
+			return Promise.reject(new Error('No such TextEditor'));
+		}
+
+		const codeEditor = editor.getCodeEditor();
+		if (!codeEditor) {
+			return Promise.reject(new Error('No such CodeEditor'));
+		}
+
+		const codeEditorId = codeEditor.getId();
+		const diffEditors = this._codeEditorService.listDiffEditors();
+		const [diffEditor] = diffEditors.filter(d => d.getOriginalEditor().getId() === codeEditorId || d.getModifiedEditor().getId() === codeEditorId);
+
+		if (diffEditor) {
+			return Promise.resolve(diffEditor.getLineChanges() || []);
+		}
+
+		const dirtyDiffContribution = codeEditor.getContribution('editor.contrib.dirtydiff');
+
+		if (dirtyDiffContribution) {
+			return Promise.resolve((dirtyDiffContribution as any).getChanges());
+		}
+
+		return Promise.resolve([]);
+	}
+}
+
+// --- commands
+
+CommandsRegistry.registerCommand('_workbench.open', async function (accessor: ServicesAccessor, args: [URI, IEditorOptions, EditorViewColumn, string?]) {
+	const editorService = accessor.get(IEditorService);
+	const editorGroupService = accessor.get(IEditorGroupsService);
+	const openerService = accessor.get(IOpenerService);
+
+	const [resource, options, position, label] = args;
+
+	if (options || typeof position === 'number') {
+		// use editor options or editor view column as a hint to use the editor service for opening
+		await editorService.openEditor({ resource, options, label }, viewColumnToEditorGroup(editorGroupService, position));
+		return;
+	}
+
+	if (resource && resource.scheme === 'command') {
+		// do not allow to execute commands from here
+		return;
+
+	}
+	// finally, delegate to opener service
+	await openerService.open(resource);
+});
+
+CommandsRegistry.registerCommand('_workbench.openWith', (accessor: ServicesAccessor, args: [URI, string, ITextEditorOptions | undefined, EditorViewColumn | undefined]) => {
+	const editorService = accessor.get(IEditorService);
+	const editorGroupsService = accessor.get(IEditorGroupsService);
+	const configurationService = accessor.get(IConfigurationService);
+	const quickInputService = accessor.get(IQuickInputService);
+
+	const [resource, id, options, position] = args;
+
+	const group = editorGroupsService.getGroup(viewColumnToEditorGroup(editorGroupsService, position)) ?? editorGroupsService.activeGroup;
+	const textOptions: ITextEditorOptions = options ? { ...options, override: false } : { override: false };
+
+	const input = editorService.createEditorInput({ resource });
+	return openEditorWith(input, id, textOptions, group, editorService, configurationService, quickInputService);
+});
+
+
+CommandsRegistry.registerCommand('_workbench.diff', async function (accessor: ServicesAccessor, args: [URI, URI, string, string, IEditorOptions, EditorViewColumn]) {
+	const editorService = accessor.get(IEditorService);
+	const editorGroupService = accessor.get(IEditorGroupsService);
+
+	let [leftResource, rightResource, label, description, options, position] = args;
+
+	if (!options || typeof options !== 'object') {
+		options = {
+			preserveFocus: false
+		};
+	}
+
+	await editorService.openEditor({ leftResource, rightResource, label, description, options }, viewColumnToEditorGroup(editorGroupService, position));
+});
+
+CommandsRegistry.registerCommand('_workbench.revertAllDirty', async function (accessor: ServicesAccessor) {
+	const environmentService = accessor.get(IEnvironmentService);
+	if (!environmentService.extensionTestsLocationURI) {
+		throw new Error('Command is only available when running extension tests.');
+	}
+
+	const workingCopyService = accessor.get(IWorkingCopyService);
+	for (const workingCopy of workingCopyService.dirtyWorkingCopies) {
+		await workingCopy.revert({ soft: true });
+	}
+});

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

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { SerializedError, onUnexpectedError } from 'vs/base/common/errors';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainContext, MainThreadErrorsShape } from 'vs/workbench/api/common/extHost.protocol';
+
+@extHostNamedCustomer(MainContext.MainThreadErrors)
+export class MainThreadErrors implements MainThreadErrorsShape {
+
+	dispose(): void {
+		//
+	}
+
+	$onUnexpectedError(err: any | SerializedError): void {
+		if (err && err.$isError) {
+			const { name, message, stack } = err;
+			err = new Error();
+			err.message = message;
+			err.name = name;
+			err.stack = stack;
+		}
+		onUnexpectedError(err);
+	}
+}

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

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { SerializedError } from 'vs/base/common/errors';
+import Severity from 'vs/base/common/severity';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IExtHostContext, MainContext, MainThreadExtensionServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IExtensionService, ExtensionActivationError } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { localize } from 'vs/nls';
+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 { CancellationToken } from 'vs/base/common/cancellation';
+import { ILocalExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ExtensionActivationReason } from 'vs/workbench/api/common/extHostExtensionActivator';
+
+@extHostNamedCustomer(MainContext.MainThreadExtensionService)
+export class MainThreadExtensionService implements MainThreadExtensionServiceShape {
+
+	private readonly _extensionService: IExtensionService;
+	private readonly _notificationService: INotificationService;
+	private readonly _extensionsWorkbenchService: IExtensionsWorkbenchService;
+	private readonly _hostService: IHostService;
+	private readonly _extensionEnablementService: IWorkbenchExtensionEnablementService;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IExtensionService extensionService: IExtensionService,
+		@INotificationService notificationService: INotificationService,
+		@IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService,
+		@IHostService hostService: IHostService,
+		@IWorkbenchExtensionEnablementService extensionEnablementService: IWorkbenchExtensionEnablementService
+	) {
+		this._extensionService = extensionService;
+		this._notificationService = notificationService;
+		this._extensionsWorkbenchService = extensionsWorkbenchService;
+		this._hostService = hostService;
+		this._extensionEnablementService = extensionEnablementService;
+	}
+
+	public dispose(): void {
+	}
+
+	$activateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
+		return this._extensionService._activateById(extensionId, reason);
+	}
+	async $onWillActivateExtension(extensionId: ExtensionIdentifier): Promise<void> {
+		this._extensionService._onWillActivateExtension(extensionId);
+	}
+	$onDidActivateExtension(extensionId: ExtensionIdentifier, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationReason: ExtensionActivationReason): void {
+		this._extensionService._onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason);
+	}
+	$onExtensionRuntimeError(extensionId: ExtensionIdentifier, data: SerializedError): void {
+		const error = new Error();
+		error.name = data.name;
+		error.message = data.message;
+		error.stack = data.stack;
+		this._extensionService._onExtensionRuntimeError(extensionId, error);
+		console.error(`[${extensionId}]${error.message}`);
+		console.error(error.stack);
+	}
+	async $onExtensionActivationError(extensionId: ExtensionIdentifier, activationError: ExtensionActivationError): Promise<void> {
+		if (typeof activationError === 'string') {
+			this._extensionService._logOrShowMessage(Severity.Error, activationError);
+		} else {
+			this._handleMissingDependency(extensionId, activationError.dependency);
+		}
+	}
+
+	private async _handleMissingDependency(extensionId: ExtensionIdentifier, missingDependency: string): Promise<void> {
+		const extension = await this._extensionService.getExtension(extensionId.value);
+		if (extension) {
+			const local = await this._extensionsWorkbenchService.queryLocal();
+			const installedDependency = local.filter(i => areSameExtensions(i.identifier, { id: missingDependency }))[0];
+			if (installedDependency) {
+				await this._handleMissingInstalledDependency(extension, installedDependency.local!);
+			} else {
+				await this._handleMissingNotInstalledDependency(extension, missingDependency);
+			}
+		}
+	}
+
+	private async _handleMissingInstalledDependency(extension: IExtensionDescription, missingInstalledDependency: ILocalExtension): Promise<void> {
+		const extName = extension.displayName || extension.name;
+		if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
+			this._notificationService.notify({
+				severity: Severity.Error,
+				message: localize('reload window', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?", extName, missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name),
+				actions: {
+					primary: [new Action('reload', localize('reload', "Reload Window"), '', true, () => this._hostService.reload())]
+				}
+			});
+		} else {
+			const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
+			this._notificationService.notify({
+				severity: Severity.Error,
+				message: localize('disabledDep', "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is disabled. Would you like to enable the extension and reload the window?", extName, missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name),
+				actions: {
+					primary: [new Action('enable', localize('enable dep', "Enable and Reload"), '', true,
+						() => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace)
+							.then(() => this._hostService.reload(), e => this._notificationService.error(e)))]
+				}
+			});
+		}
+	}
+
+	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];
+		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)
+							.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));
+		}
+	}
+
+	async $onExtensionHostExit(code: number): Promise<void> {
+		this._extensionService._onExtensionHostExit(code);
+	}
+}

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

@@ -0,0 +1,244 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { IDisposable, dispose, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { FileWriteOptions, FileSystemProviderCapabilities, IFileChange, IFileService, IStat, IWatchOptions, FileType, FileOverwriteOptions, FileDeleteOptions, FileOpenOptions, IFileStat, FileOperationError, FileOperationResult, FileSystemProviderErrorCode, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileFolderCopyCapability } from 'vs/platform/files/common/files';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, ExtHostFileSystemShape, IExtHostContext, IFileChangeDto, MainContext, MainThreadFileSystemShape } from '../common/extHost.protocol';
+import { VSBuffer } from 'vs/base/common/buffer';
+
+@extHostNamedCustomer(MainContext.MainThreadFileSystem)
+export class MainThreadFileSystem implements MainThreadFileSystemShape {
+
+	private readonly _proxy: ExtHostFileSystemShape;
+	private readonly _fileProvider = new Map<number, RemoteFileSystemProvider>();
+	private readonly _disposables = new DisposableStore();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IFileService private readonly _fileService: IFileService,
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostFileSystem);
+
+		const infoProxy = extHostContext.getProxy(ExtHostContext.ExtHostFileSystemInfo);
+
+		for (let entry of _fileService.listCapabilities()) {
+			infoProxy.$acceptProviderInfos(entry.scheme, entry.capabilities);
+		}
+		this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(e => infoProxy.$acceptProviderInfos(e.scheme, e.provider?.capabilities ?? null)));
+		this._disposables.add(_fileService.onDidChangeFileSystemProviderCapabilities(e => infoProxy.$acceptProviderInfos(e.scheme, e.provider.capabilities)));
+	}
+
+	dispose(): void {
+		this._disposables.dispose();
+		dispose(this._fileProvider.values());
+		this._fileProvider.clear();
+	}
+
+	async $registerFileSystemProvider(handle: number, scheme: string, capabilities: FileSystemProviderCapabilities): Promise<void> {
+		this._fileProvider.set(handle, new RemoteFileSystemProvider(this._fileService, scheme, capabilities, handle, this._proxy));
+	}
+
+	$unregisterProvider(handle: number): void {
+		this._fileProvider.get(handle)?.dispose();
+		this._fileProvider.delete(handle);
+	}
+
+	$onFileSystemChange(handle: number, changes: IFileChangeDto[]): void {
+		const fileProvider = this._fileProvider.get(handle);
+		if (!fileProvider) {
+			throw new Error('Unknown file provider');
+		}
+		fileProvider.$onFileSystemChange(changes);
+	}
+
+
+	// --- consumer fs, vscode.workspace.fs
+
+	$stat(uri: UriComponents): Promise<IStat> {
+		return this._fileService.resolve(URI.revive(uri), { resolveMetadata: true }).then(stat => {
+			return {
+				ctime: stat.ctime,
+				mtime: stat.mtime,
+				size: stat.size,
+				type: MainThreadFileSystem._asFileType(stat)
+			};
+		}).catch(MainThreadFileSystem._handleError);
+	}
+
+	$readdir(uri: UriComponents): Promise<[string, FileType][]> {
+		return this._fileService.resolve(URI.revive(uri), { resolveMetadata: false }).then(stat => {
+			if (!stat.isDirectory) {
+				const err = new Error(stat.name);
+				err.name = FileSystemProviderErrorCode.FileNotADirectory;
+				throw err;
+			}
+			return !stat.children ? [] : stat.children.map(child => [child.name, MainThreadFileSystem._asFileType(child)] as [string, FileType]);
+		}).catch(MainThreadFileSystem._handleError);
+	}
+
+	private static _asFileType(stat: IFileStat): FileType {
+		let res = 0;
+		if (stat.isFile) {
+			res += FileType.File;
+
+		} else if (stat.isDirectory) {
+			res += FileType.Directory;
+		}
+		if (stat.isSymbolicLink) {
+			res += FileType.SymbolicLink;
+		}
+		return res;
+	}
+
+	$readFile(uri: UriComponents): Promise<VSBuffer> {
+		return this._fileService.readFile(URI.revive(uri)).then(file => file.value).catch(MainThreadFileSystem._handleError);
+	}
+
+	$writeFile(uri: UriComponents, content: VSBuffer): Promise<void> {
+		return this._fileService.writeFile(URI.revive(uri), content)
+			.then(() => undefined).catch(MainThreadFileSystem._handleError);
+	}
+
+	$rename(source: UriComponents, target: UriComponents, opts: FileOverwriteOptions): Promise<void> {
+		return this._fileService.move(URI.revive(source), URI.revive(target), opts.overwrite)
+			.then(() => undefined).catch(MainThreadFileSystem._handleError);
+	}
+
+	$copy(source: UriComponents, target: UriComponents, opts: FileOverwriteOptions): Promise<void> {
+		return this._fileService.copy(URI.revive(source), URI.revive(target), opts.overwrite)
+			.then(() => undefined).catch(MainThreadFileSystem._handleError);
+	}
+
+	$mkdir(uri: UriComponents): Promise<void> {
+		return this._fileService.createFolder(URI.revive(uri))
+			.then(() => undefined).catch(MainThreadFileSystem._handleError);
+	}
+
+	$delete(uri: UriComponents, opts: FileDeleteOptions): Promise<void> {
+		return this._fileService.del(URI.revive(uri), opts).catch(MainThreadFileSystem._handleError);
+	}
+
+	private static _handleError(err: any): never {
+		if (err instanceof FileOperationError) {
+			switch (err.fileOperationResult) {
+				case FileOperationResult.FILE_NOT_FOUND:
+					err.name = FileSystemProviderErrorCode.FileNotFound;
+					break;
+				case FileOperationResult.FILE_IS_DIRECTORY:
+					err.name = FileSystemProviderErrorCode.FileIsADirectory;
+					break;
+				case FileOperationResult.FILE_PERMISSION_DENIED:
+					err.name = FileSystemProviderErrorCode.NoPermissions;
+					break;
+				case FileOperationResult.FILE_MOVE_CONFLICT:
+					err.name = FileSystemProviderErrorCode.FileExists;
+					break;
+			}
+		}
+
+		throw err;
+	}
+}
+
+class RemoteFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileFolderCopyCapability {
+
+	private readonly _onDidChange = new Emitter<readonly IFileChange[]>();
+	private readonly _registration: IDisposable;
+
+	readonly onDidChangeFile: Event<readonly IFileChange[]> = this._onDidChange.event;
+
+	readonly capabilities: FileSystemProviderCapabilities;
+	readonly onDidChangeCapabilities: Event<void> = Event.None;
+
+	constructor(
+		fileService: IFileService,
+		scheme: string,
+		capabilities: FileSystemProviderCapabilities,
+		private readonly _handle: number,
+		private readonly _proxy: ExtHostFileSystemShape
+	) {
+		this.capabilities = capabilities;
+		this._registration = fileService.registerProvider(scheme, this);
+	}
+
+	dispose(): void {
+		this._registration.dispose();
+		this._onDidChange.dispose();
+	}
+
+	watch(resource: URI, opts: IWatchOptions) {
+		const session = Math.random();
+		this._proxy.$watch(this._handle, session, resource, opts);
+		return toDisposable(() => {
+			this._proxy.$unwatch(this._handle, session);
+		});
+	}
+
+	$onFileSystemChange(changes: IFileChangeDto[]): void {
+		this._onDidChange.fire(changes.map(RemoteFileSystemProvider._createFileChange));
+	}
+
+	private static _createFileChange(dto: IFileChangeDto): IFileChange {
+		return { resource: URI.revive(dto.resource), type: dto.type };
+	}
+
+	// --- forwarding calls
+
+	stat(resource: URI): Promise<IStat> {
+		return this._proxy.$stat(this._handle, resource).then(undefined, err => {
+			throw err;
+		});
+	}
+
+	readFile(resource: URI): Promise<Uint8Array> {
+		return this._proxy.$readFile(this._handle, resource).then(buffer => buffer.buffer);
+	}
+
+	writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void> {
+		return this._proxy.$writeFile(this._handle, resource, VSBuffer.wrap(content), opts);
+	}
+
+	delete(resource: URI, opts: FileDeleteOptions): Promise<void> {
+		return this._proxy.$delete(this._handle, resource, opts);
+	}
+
+	mkdir(resource: URI): Promise<void> {
+		return this._proxy.$mkdir(this._handle, resource);
+	}
+
+	readdir(resource: URI): Promise<[string, FileType][]> {
+		return this._proxy.$readdir(this._handle, resource);
+	}
+
+	rename(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void> {
+		return this._proxy.$rename(this._handle, resource, target, opts);
+	}
+
+	copy(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void> {
+		return this._proxy.$copy(this._handle, resource, target, opts);
+	}
+
+	open(resource: URI, opts: FileOpenOptions): Promise<number> {
+		return this._proxy.$open(this._handle, resource, opts);
+	}
+
+	close(fd: number): Promise<void> {
+		return this._proxy.$close(this._handle, fd);
+	}
+
+	read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+		return this._proxy.$read(this._handle, fd, pos, length).then(readData => {
+			data.set(readData.buffer, offset);
+			return readData.byteLength;
+		});
+	}
+
+	write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number> {
+		return this._proxy.$write(this._handle, fd, pos, VSBuffer.wrap(data).slice(offset, offset + length));
+	}
+}

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

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { FileChangeType, IFileService } from 'vs/platform/files/common/files';
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, FileSystemEvents, IExtHostContext } from '../common/extHost.protocol';
+import { localize } from 'vs/nls';
+import { Extensions, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IWorkingCopyFileService } from 'vs/workbench/services/workingCopy/common/workingCopyFileService';
+
+@extHostCustomer
+export class MainThreadFileSystemEventService {
+
+	private readonly _listener = new DisposableStore();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IFileService fileService: IFileService,
+		@IWorkingCopyFileService workingCopyFileService: IWorkingCopyFileService
+	) {
+
+		const proxy = extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService);
+
+		// file system events - (changes the editor and other make)
+		const events: FileSystemEvents = {
+			created: [],
+			changed: [],
+			deleted: []
+		};
+		this._listener.add(fileService.onDidFilesChange(event => {
+			for (let change of event.changes) {
+				switch (change.type) {
+					case FileChangeType.ADDED:
+						events.created.push(change.resource);
+						break;
+					case FileChangeType.UPDATED:
+						events.changed.push(change.resource);
+						break;
+					case FileChangeType.DELETED:
+						events.deleted.push(change.resource);
+						break;
+				}
+			}
+
+			proxy.$onFileEvent(events);
+			events.created.length = 0;
+			events.changed.length = 0;
+			events.deleted.length = 0;
+		}));
+
+
+		// BEFORE file operation
+		workingCopyFileService.addFileOperationParticipant({
+			participate: (files, operation, progress, timeout, token) => {
+				return proxy.$onWillRunFileOperation(operation, files, timeout, token);
+			}
+		});
+
+		// AFTER file operation
+		this._listener.add(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => proxy.$onDidRunFileOperation(e.operation, e.files)));
+	}
+
+	dispose(): void {
+		this._listener.dispose();
+	}
+}
+
+
+Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
+	id: 'files',
+	properties: {
+		'files.participants.timeout': {
+			type: 'number',
+			default: 5000,
+			markdownDescription: localize('files.participants.timeout', "Timeout in milliseconds after which file participants for create, rename, and delete are cancelled. Use `0` to disable participants."),
+		}
+	}
+});

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

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { MainContext, MainThreadKeytarShape, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { ICredentialsService } from 'vs/workbench/services/credentials/common/credentials';
+
+@extHostNamedCustomer(MainContext.MainThreadKeytar)
+export class MainThreadKeytar implements MainThreadKeytarShape {
+
+	constructor(
+		_extHostContext: IExtHostContext,
+		@ICredentialsService private readonly _credentialsService: ICredentialsService,
+	) { }
+
+	async $getPassword(service: string, account: string): Promise<string | null> {
+		return this._credentialsService.getPassword(service, account);
+	}
+
+	async $setPassword(service: string, account: string, password: string): Promise<void> {
+		return this._credentialsService.setPassword(service, account, password);
+	}
+
+	async $deletePassword(service: string, account: string): Promise<boolean> {
+		return this._credentialsService.deletePassword(service, account);
+	}
+
+	async $findPassword(service: string): Promise<string | null> {
+		return this._credentialsService.findPassword(service);
+	}
+
+	async $findCredentials(service: string): Promise<Array<{ account: string, password: string }>> {
+		return this._credentialsService.findCredentials(service);
+	}
+
+	dispose(): void {
+		//
+	}
+}

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

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainContext, MainThreadLabelServiceShape, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ResourceLabelFormatter, ILabelService } from 'vs/platform/label/common/label';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+
+@extHostNamedCustomer(MainContext.MainThreadLabelService)
+export class MainThreadLabelService implements MainThreadLabelServiceShape {
+
+	private readonly _resourceLabelFormatters = new Map<number, IDisposable>();
+
+	constructor(
+		_: IExtHostContext,
+		@ILabelService private readonly _labelService: ILabelService
+	) { }
+
+	$registerResourceLabelFormatter(handle: number, formatter: ResourceLabelFormatter): void {
+		// Dynamicily registered formatters should have priority over those contributed via package.json
+		formatter.priority = true;
+		const disposable = this._labelService.registerFormatter(formatter);
+		this._resourceLabelFormatters.set(handle, disposable);
+	}
+
+	$unregisterResourceLabelFormatter(handle: number): void {
+		dispose(this._resourceLabelFormatters.get(handle));
+		this._resourceLabelFormatters.delete(handle);
+	}
+
+	dispose(): void {
+		// noop
+	}
+}

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

@@ -0,0 +1,786 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { Emitter, Event } from 'vs/base/common/event';
+import { ITextModel, ISingleEditOperation } from 'vs/editor/common/model';
+import * as modes from 'vs/editor/common/modes';
+import * as search from 'vs/workbench/contrib/search/common/search';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Position as EditorPosition } from 'vs/editor/common/core/position';
+import { Range as EditorRange, IRange } from 'vs/editor/common/core/range';
+import { ExtHostContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, MainContext, IExtHostContext, ILanguageConfigurationDto, IRegExpDto, IIndentationRuleDto, IOnEnterRuleDto, ILocationDto, IWorkspaceSymbolDto, reviveWorkspaceEditDto, IDocumentFilterDto, IDefinitionLinkDto, ISignatureHelpProviderMetadataDto, ILinkDto, ICallHierarchyItemDto, ISuggestDataDto, ICodeActionDto, ISuggestDataDtoField, ISuggestResultDtoField, ICodeActionProviderMetadataDto, ILanguageWordDefinitionDto } from '../common/extHost.protocol';
+import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
+import { LanguageConfiguration, IndentationRule, OnEnterRule } from 'vs/editor/common/modes/languageConfiguration';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { URI } from 'vs/base/common/uri';
+import { Selection } from 'vs/editor/common/core/selection';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import * as callh from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
+import { mixin } from 'vs/base/common/objects';
+import { decodeSemanticTokensDto } from 'vs/workbench/api/common/shared/semanticTokensDto';
+
+@extHostNamedCustomer(MainContext.MainThreadLanguageFeatures)
+export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesShape {
+
+	private readonly _proxy: ExtHostLanguageFeaturesShape;
+	private readonly _modeService: IModeService;
+	private readonly _registrations = new Map<number, IDisposable>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IModeService modeService: IModeService,
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostLanguageFeatures);
+		this._modeService = modeService;
+
+		if (this._modeService) {
+			const updateAllWordDefinitions = () => {
+				const langWordPairs = LanguageConfigurationRegistry.getWordDefinitions();
+				let wordDefinitionDtos: ILanguageWordDefinitionDto[] = [];
+				for (const [languageId, wordDefinition] of langWordPairs) {
+					const language = this._modeService.getLanguageIdentifier(languageId);
+					if (!language) {
+						continue;
+					}
+					wordDefinitionDtos.push({
+						languageId: language.language,
+						regexSource: wordDefinition.source,
+						regexFlags: wordDefinition.flags
+					});
+				}
+				this._proxy.$setWordDefinitions(wordDefinitionDtos);
+			};
+			LanguageConfigurationRegistry.onDidChange((e) => {
+				const wordDefinition = LanguageConfigurationRegistry.getWordDefinition(e.languageIdentifier.id);
+				this._proxy.$setWordDefinitions([{
+					languageId: e.languageIdentifier.language,
+					regexSource: wordDefinition.source,
+					regexFlags: wordDefinition.flags
+				}]);
+			});
+			updateAllWordDefinitions();
+		}
+	}
+
+	dispose(): void {
+		for (const registration of this._registrations.values()) {
+			registration.dispose();
+		}
+		this._registrations.clear();
+	}
+
+	$unregister(handle: number): void {
+		const registration = this._registrations.get(handle);
+		if (registration) {
+			registration.dispose();
+			this._registrations.delete(handle);
+		}
+	}
+
+	//#region --- revive functions
+
+	private static _reviveLocationDto(data?: ILocationDto): modes.Location;
+	private static _reviveLocationDto(data?: ILocationDto[]): modes.Location[];
+	private static _reviveLocationDto(data: ILocationDto | ILocationDto[] | undefined): modes.Location | modes.Location[] | undefined {
+		if (!data) {
+			return data;
+		} else if (Array.isArray(data)) {
+			data.forEach(l => MainThreadLanguageFeatures._reviveLocationDto(l));
+			return <modes.Location[]>data;
+		} else {
+			data.uri = URI.revive(data.uri);
+			return <modes.Location>data;
+		}
+	}
+
+	private static _reviveLocationLinkDto(data: IDefinitionLinkDto): modes.LocationLink;
+	private static _reviveLocationLinkDto(data: IDefinitionLinkDto[]): modes.LocationLink[];
+	private static _reviveLocationLinkDto(data: IDefinitionLinkDto | IDefinitionLinkDto[]): modes.LocationLink | modes.LocationLink[] {
+		if (!data) {
+			return <modes.LocationLink>data;
+		} else if (Array.isArray(data)) {
+			data.forEach(l => MainThreadLanguageFeatures._reviveLocationLinkDto(l));
+			return <modes.LocationLink[]>data;
+		} else {
+			data.uri = URI.revive(data.uri);
+			return <modes.LocationLink>data;
+		}
+	}
+
+	private static _reviveWorkspaceSymbolDto(data: IWorkspaceSymbolDto): search.IWorkspaceSymbol;
+	private static _reviveWorkspaceSymbolDto(data: IWorkspaceSymbolDto[]): search.IWorkspaceSymbol[];
+	private static _reviveWorkspaceSymbolDto(data: undefined): undefined;
+	private static _reviveWorkspaceSymbolDto(data: IWorkspaceSymbolDto | IWorkspaceSymbolDto[] | undefined): search.IWorkspaceSymbol | search.IWorkspaceSymbol[] | undefined {
+		if (!data) {
+			return <undefined>data;
+		} else if (Array.isArray(data)) {
+			data.forEach(MainThreadLanguageFeatures._reviveWorkspaceSymbolDto);
+			return <search.IWorkspaceSymbol[]>data;
+		} else {
+			data.location = MainThreadLanguageFeatures._reviveLocationDto(data.location);
+			return <search.IWorkspaceSymbol>data;
+		}
+	}
+
+	private static _reviveCodeActionDto(data: ReadonlyArray<ICodeActionDto>): modes.CodeAction[] {
+		if (data) {
+			data.forEach(code => reviveWorkspaceEditDto(code.edit));
+		}
+		return <modes.CodeAction[]>data;
+	}
+
+	private static _reviveLinkDTO(data: ILinkDto): modes.ILink {
+		if (data.url && typeof data.url !== 'string') {
+			data.url = URI.revive(data.url);
+		}
+		return <modes.ILink>data;
+	}
+
+	private static _reviveCallHierarchyItemDto(data: ICallHierarchyItemDto | undefined): callh.CallHierarchyItem {
+		if (data) {
+			data.uri = URI.revive(data.uri);
+		}
+		return data as callh.CallHierarchyItem;
+	}
+
+	//#endregion
+
+	// --- outline
+
+	$registerDocumentSymbolProvider(handle: number, selector: IDocumentFilterDto[], displayName: string): void {
+		this._registrations.set(handle, modes.DocumentSymbolProviderRegistry.register(selector, <modes.DocumentSymbolProvider>{
+			displayName,
+			provideDocumentSymbols: (model: ITextModel, token: CancellationToken): Promise<modes.DocumentSymbol[] | undefined> => {
+				return this._proxy.$provideDocumentSymbols(handle, model.uri, token);
+			}
+		}));
+	}
+
+	// --- code lens
+
+	$registerCodeLensSupport(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void {
+
+		const provider = <modes.CodeLensProvider>{
+			provideCodeLenses: (model: ITextModel, token: CancellationToken): Promise<modes.CodeLensList | undefined> => {
+				return this._proxy.$provideCodeLenses(handle, model.uri, token).then(listDto => {
+					if (!listDto) {
+						return undefined;
+					}
+					return {
+						lenses: listDto.lenses,
+						dispose: () => listDto.cacheId && this._proxy.$releaseCodeLenses(handle, listDto.cacheId)
+					};
+				});
+			},
+			resolveCodeLens: (_model: ITextModel, codeLens: modes.CodeLens, token: CancellationToken): Promise<modes.CodeLens | undefined> => {
+				return this._proxy.$resolveCodeLens(handle, codeLens, token);
+			}
+		};
+
+		if (typeof eventHandle === 'number') {
+			const emitter = new Emitter<modes.CodeLensProvider>();
+			this._registrations.set(eventHandle, emitter);
+			provider.onDidChange = emitter.event;
+		}
+
+		this._registrations.set(handle, modes.CodeLensProviderRegistry.register(selector, provider));
+	}
+
+	$emitCodeLensEvent(eventHandle: number, event?: any): void {
+		const obj = this._registrations.get(eventHandle);
+		if (obj instanceof Emitter) {
+			obj.fire(event);
+		}
+	}
+
+	// --- declaration
+
+	$registerDefinitionSupport(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.DefinitionProviderRegistry.register(selector, <modes.DefinitionProvider>{
+			provideDefinition: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		}));
+	}
+
+	$registerDeclarationSupport(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.DeclarationProviderRegistry.register(selector, <modes.DeclarationProvider>{
+			provideDeclaration: (model, position, token) => {
+				return this._proxy.$provideDeclaration(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		}));
+	}
+
+	$registerImplementationSupport(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.ImplementationProviderRegistry.register(selector, <modes.ImplementationProvider>{
+			provideImplementation: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideImplementation(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		}));
+	}
+
+	$registerTypeDefinitionSupport(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.TypeDefinitionProviderRegistry.register(selector, <modes.TypeDefinitionProvider>{
+			provideTypeDefinition: (model, position, token): Promise<modes.LocationLink[]> => {
+				return this._proxy.$provideTypeDefinition(handle, model.uri, position, token).then(MainThreadLanguageFeatures._reviveLocationLinkDto);
+			}
+		}));
+	}
+
+	// --- extra info
+
+	$registerHoverProvider(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.HoverProviderRegistry.register(selector, <modes.HoverProvider>{
+			provideHover: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.Hover | undefined> => {
+				return this._proxy.$provideHover(handle, model.uri, position, token);
+			}
+		}));
+	}
+
+	// --- debug hover
+
+	$registerEvaluatableExpressionProvider(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.EvaluatableExpressionProviderRegistry.register(selector, <modes.EvaluatableExpressionProvider>{
+			provideEvaluatableExpression: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.EvaluatableExpression | undefined> => {
+				return this._proxy.$provideEvaluatableExpression(handle, model.uri, position, token);
+			}
+		}));
+	}
+
+	// --- occurrences
+
+	$registerDocumentHighlightProvider(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.DocumentHighlightProviderRegistry.register(selector, <modes.DocumentHighlightProvider>{
+			provideDocumentHighlights: (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.DocumentHighlight[] | undefined> => {
+				return this._proxy.$provideDocumentHighlights(handle, model.uri, position, token);
+			}
+		}));
+	}
+
+	// --- on type rename
+
+	$registerOnTypeRenameProvider(handle: number, selector: IDocumentFilterDto[], wordPattern?: IRegExpDto): void {
+		const revivedWordPattern = wordPattern ? MainThreadLanguageFeatures._reviveRegExp(wordPattern) : undefined;
+		this._registrations.set(handle, modes.OnTypeRenameProviderRegistry.register(selector, <modes.OnTypeRenameProvider>{
+			wordPattern: revivedWordPattern,
+			provideOnTypeRenameRanges: async (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<{ ranges: IRange[]; wordPattern?: RegExp; } | undefined> => {
+				const res = await this._proxy.$provideOnTypeRenameRanges(handle, model.uri, position, token);
+				if (res) {
+					return {
+						ranges: res.ranges,
+						wordPattern: res.wordPattern ? MainThreadLanguageFeatures._reviveRegExp(res.wordPattern) : undefined
+					};
+				}
+				return undefined;
+			}
+		}));
+	}
+
+	// --- references
+
+	$registerReferenceSupport(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.ReferenceProviderRegistry.register(selector, <modes.ReferenceProvider>{
+			provideReferences: (model: ITextModel, position: EditorPosition, context: modes.ReferenceContext, token: CancellationToken): Promise<modes.Location[]> => {
+				return this._proxy.$provideReferences(handle, model.uri, position, context, token).then(MainThreadLanguageFeatures._reviveLocationDto);
+			}
+		}));
+	}
+
+	// --- quick fix
+
+	$registerQuickFixSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto, displayName: string, supportsResolve: boolean): void {
+		const provider: modes.CodeActionProvider = {
+			provideCodeActions: async (model: ITextModel, rangeOrSelection: EditorRange | Selection, context: modes.CodeActionContext, token: CancellationToken): Promise<modes.CodeActionList | undefined> => {
+				const listDto = await this._proxy.$provideCodeActions(handle, model.uri, rangeOrSelection, context, token);
+				if (!listDto) {
+					return undefined;
+				}
+				return <modes.CodeActionList>{
+					actions: MainThreadLanguageFeatures._reviveCodeActionDto(listDto.actions),
+					dispose: () => {
+						if (typeof listDto.cacheId === 'number') {
+							this._proxy.$releaseCodeActions(handle, listDto.cacheId);
+						}
+					}
+				};
+			},
+			providedCodeActionKinds: metadata.providedKinds,
+			documentation: metadata.documentation,
+			displayName
+		};
+
+		if (supportsResolve) {
+			provider.resolveCodeAction = async (codeAction: modes.CodeAction, token: CancellationToken): Promise<modes.CodeAction> => {
+				const data = await this._proxy.$resolveCodeAction(handle, (<ICodeActionDto>codeAction).cacheId!, token);
+				codeAction.edit = reviveWorkspaceEditDto(data);
+				return codeAction;
+			};
+		}
+
+		this._registrations.set(handle, modes.CodeActionProviderRegistry.register(selector, provider));
+	}
+
+	// --- formatting
+
+	$registerDocumentFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string): void {
+		this._registrations.set(handle, modes.DocumentFormattingEditProviderRegistry.register(selector, <modes.DocumentFormattingEditProvider>{
+			extensionId,
+			displayName,
+			provideDocumentFormattingEdits: (model: ITextModel, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[] | undefined> => {
+				return this._proxy.$provideDocumentFormattingEdits(handle, model.uri, options, token);
+			}
+		}));
+	}
+
+	$registerRangeFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string): void {
+		this._registrations.set(handle, modes.DocumentRangeFormattingEditProviderRegistry.register(selector, <modes.DocumentRangeFormattingEditProvider>{
+			extensionId,
+			displayName,
+			provideDocumentRangeFormattingEdits: (model: ITextModel, range: EditorRange, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[] | undefined> => {
+				return this._proxy.$provideDocumentRangeFormattingEdits(handle, model.uri, range, options, token);
+			}
+		}));
+	}
+
+	$registerOnTypeFormattingSupport(handle: number, selector: IDocumentFilterDto[], autoFormatTriggerCharacters: string[], extensionId: ExtensionIdentifier): void {
+		this._registrations.set(handle, modes.OnTypeFormattingEditProviderRegistry.register(selector, <modes.OnTypeFormattingEditProvider>{
+			extensionId,
+			autoFormatTriggerCharacters,
+			provideOnTypeFormattingEdits: (model: ITextModel, position: EditorPosition, ch: string, options: modes.FormattingOptions, token: CancellationToken): Promise<ISingleEditOperation[] | undefined> => {
+				return this._proxy.$provideOnTypeFormattingEdits(handle, model.uri, position, ch, options, token);
+			}
+		}));
+	}
+
+	// --- navigate type
+
+	$registerNavigateTypeSupport(handle: number): void {
+		let lastResultId: number | undefined;
+		this._registrations.set(handle, search.WorkspaceSymbolProviderRegistry.register(<search.IWorkspaceSymbolProvider>{
+			provideWorkspaceSymbols: (search: string, token: CancellationToken): Promise<search.IWorkspaceSymbol[]> => {
+				return this._proxy.$provideWorkspaceSymbols(handle, search, token).then(result => {
+					if (lastResultId !== undefined) {
+						this._proxy.$releaseWorkspaceSymbols(handle, lastResultId);
+					}
+					lastResultId = result._id;
+					return MainThreadLanguageFeatures._reviveWorkspaceSymbolDto(result.symbols);
+				});
+			},
+			resolveWorkspaceSymbol: (item: search.IWorkspaceSymbol, token: CancellationToken): Promise<search.IWorkspaceSymbol | undefined> => {
+				return this._proxy.$resolveWorkspaceSymbol(handle, item, token).then(i => {
+					if (i) {
+						return MainThreadLanguageFeatures._reviveWorkspaceSymbolDto(i);
+					}
+					return undefined;
+				});
+			}
+		}));
+	}
+
+	// --- rename
+
+	$registerRenameSupport(handle: number, selector: IDocumentFilterDto[], supportResolveLocation: boolean): void {
+		this._registrations.set(handle, modes.RenameProviderRegistry.register(selector, <modes.RenameProvider>{
+			provideRenameEdits: (model: ITextModel, position: EditorPosition, newName: string, token: CancellationToken) => {
+				return this._proxy.$provideRenameEdits(handle, model.uri, position, newName, token).then(reviveWorkspaceEditDto);
+			},
+			resolveRenameLocation: supportResolveLocation
+				? (model: ITextModel, position: EditorPosition, token: CancellationToken): Promise<modes.RenameLocation | undefined> => this._proxy.$resolveRenameLocation(handle, model.uri, position, token)
+				: undefined
+		}));
+	}
+
+	// --- semantic tokens
+
+	$registerDocumentSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: modes.SemanticTokensLegend, eventHandle: number | undefined): void {
+		let event: Event<void> | undefined = undefined;
+		if (typeof eventHandle === 'number') {
+			const emitter = new Emitter<void>();
+			this._registrations.set(eventHandle, emitter);
+			event = emitter.event;
+		}
+		this._registrations.set(handle, modes.DocumentSemanticTokensProviderRegistry.register(selector, new MainThreadDocumentSemanticTokensProvider(this._proxy, handle, legend, event)));
+	}
+
+	$emitDocumentSemanticTokensEvent(eventHandle: number): void {
+		const obj = this._registrations.get(eventHandle);
+		if (obj instanceof Emitter) {
+			obj.fire(undefined);
+		}
+	}
+
+	$registerDocumentRangeSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: modes.SemanticTokensLegend): void {
+		this._registrations.set(handle, modes.DocumentRangeSemanticTokensProviderRegistry.register(selector, new MainThreadDocumentRangeSemanticTokensProvider(this._proxy, handle, legend)));
+	}
+
+	// --- suggest
+
+	private static _inflateSuggestDto(defaultRange: IRange | { insert: IRange, replace: IRange }, data: ISuggestDataDto): modes.CompletionItem {
+
+		return {
+			label: data[ISuggestDataDtoField.label2] ?? data[ISuggestDataDtoField.label],
+			kind: data[ISuggestDataDtoField.kind] ?? modes.CompletionItemKind.Property,
+			tags: data[ISuggestDataDtoField.kindModifier],
+			detail: data[ISuggestDataDtoField.detail],
+			documentation: data[ISuggestDataDtoField.documentation],
+			sortText: data[ISuggestDataDtoField.sortText],
+			filterText: data[ISuggestDataDtoField.filterText],
+			preselect: data[ISuggestDataDtoField.preselect],
+			insertText: typeof data.h === 'undefined' ? data[ISuggestDataDtoField.label] : data.h,
+			range: data[ISuggestDataDtoField.range] ?? defaultRange,
+			insertTextRules: data[ISuggestDataDtoField.insertTextRules],
+			commitCharacters: data[ISuggestDataDtoField.commitCharacters],
+			additionalTextEdits: data[ISuggestDataDtoField.additionalTextEdits],
+			command: data[ISuggestDataDtoField.command],
+			// not-standard
+			_id: data.x,
+		};
+	}
+
+	$registerSuggestSupport(handle: number, selector: IDocumentFilterDto[], triggerCharacters: string[], supportsResolveDetails: boolean, displayName: string): void {
+		const provider: modes.CompletionItemProvider = {
+			triggerCharacters,
+			_debugDisplayName: displayName,
+			provideCompletionItems: async (model: ITextModel, position: EditorPosition, context: modes.CompletionContext, token: CancellationToken): Promise<modes.CompletionList | undefined> => {
+				const result = await this._proxy.$provideCompletionItems(handle, model.uri, position, context, token);
+				if (!result) {
+					return result;
+				}
+				return {
+					suggestions: result[ISuggestResultDtoField.completions].map(d => MainThreadLanguageFeatures._inflateSuggestDto(result[ISuggestResultDtoField.defaultRanges], d)),
+					incomplete: result[ISuggestResultDtoField.isIncomplete] || false,
+					duration: result[ISuggestResultDtoField.duration],
+					dispose: () => {
+						if (typeof result.x === 'number') {
+							this._proxy.$releaseCompletionItems(handle, result.x);
+						}
+					}
+				};
+			}
+		};
+		if (supportsResolveDetails) {
+			provider.resolveCompletionItem = (suggestion, token) => {
+				return this._proxy.$resolveCompletionItem(handle, suggestion._id!, token).then(result => {
+					if (!result) {
+						return suggestion;
+					}
+
+					let newSuggestion = MainThreadLanguageFeatures._inflateSuggestDto(suggestion.range, result);
+					return mixin(suggestion, newSuggestion, true);
+				});
+			};
+		}
+		this._registrations.set(handle, modes.CompletionProviderRegistry.register(selector, provider));
+	}
+
+	// --- parameter hints
+
+	$registerSignatureHelpProvider(handle: number, selector: IDocumentFilterDto[], metadata: ISignatureHelpProviderMetadataDto): void {
+		this._registrations.set(handle, modes.SignatureHelpProviderRegistry.register(selector, <modes.SignatureHelpProvider>{
+
+			signatureHelpTriggerCharacters: metadata.triggerCharacters,
+			signatureHelpRetriggerCharacters: metadata.retriggerCharacters,
+
+			provideSignatureHelp: async (model: ITextModel, position: EditorPosition, token: CancellationToken, context: modes.SignatureHelpContext): Promise<modes.SignatureHelpResult | undefined> => {
+				const result = await this._proxy.$provideSignatureHelp(handle, model.uri, position, context, token);
+				if (!result) {
+					return undefined;
+				}
+				return {
+					value: result,
+					dispose: () => {
+						this._proxy.$releaseSignatureHelp(handle, result.id);
+					}
+				};
+			}
+		}));
+	}
+
+	// --- links
+
+	$registerDocumentLinkProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean): void {
+		const provider: modes.LinkProvider = {
+			provideLinks: (model, token) => {
+				return this._proxy.$provideDocumentLinks(handle, model.uri, token).then(dto => {
+					if (!dto) {
+						return undefined;
+					}
+					return {
+						links: dto.links.map(MainThreadLanguageFeatures._reviveLinkDTO),
+						dispose: () => {
+							if (typeof dto.id === 'number') {
+								this._proxy.$releaseDocumentLinks(handle, dto.id);
+							}
+						}
+					};
+				});
+			}
+		};
+		if (supportsResolve) {
+			provider.resolveLink = (link, token) => {
+				const dto: ILinkDto = link;
+				if (!dto.cacheId) {
+					return link;
+				}
+				return this._proxy.$resolveDocumentLink(handle, dto.cacheId, token).then(obj => {
+					return obj && MainThreadLanguageFeatures._reviveLinkDTO(obj);
+				});
+			};
+		}
+		this._registrations.set(handle, modes.LinkProviderRegistry.register(selector, provider));
+	}
+
+	// --- colors
+
+	$registerDocumentColorProvider(handle: number, selector: IDocumentFilterDto[]): void {
+		const proxy = this._proxy;
+		this._registrations.set(handle, modes.ColorProviderRegistry.register(selector, <modes.DocumentColorProvider>{
+			provideDocumentColors: (model, token) => {
+				return proxy.$provideDocumentColors(handle, model.uri, token)
+					.then(documentColors => {
+						return documentColors.map(documentColor => {
+							const [red, green, blue, alpha] = documentColor.color;
+							const color = {
+								red: red,
+								green: green,
+								blue: blue,
+								alpha
+							};
+
+							return {
+								color,
+								range: documentColor.range
+							};
+						});
+					});
+			},
+
+			provideColorPresentations: (model, colorInfo, token) => {
+				return proxy.$provideColorPresentations(handle, model.uri, {
+					color: [colorInfo.color.red, colorInfo.color.green, colorInfo.color.blue, colorInfo.color.alpha],
+					range: colorInfo.range
+				}, token);
+			}
+		}));
+	}
+
+	// --- folding
+
+	$registerFoldingRangeProvider(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void {
+		const provider = <modes.FoldingRangeProvider>{
+			provideFoldingRanges: (model, context, token) => {
+				return this._proxy.$provideFoldingRanges(handle, model.uri, context, token);
+			}
+		};
+
+		if (typeof eventHandle === 'number') {
+			const emitter = new Emitter<modes.FoldingRangeProvider>();
+			this._registrations.set(eventHandle, emitter);
+			provider.onDidChange = emitter.event;
+		}
+
+		this._registrations.set(handle, modes.FoldingRangeProviderRegistry.register(selector, provider));
+	}
+
+	$emitFoldingRangeEvent(eventHandle: number, event?: any): void {
+		const obj = this._registrations.get(eventHandle);
+		if (obj instanceof Emitter) {
+			obj.fire(event);
+		}
+	}
+
+	// -- smart select
+
+	$registerSelectionRangeProvider(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, modes.SelectionRangeRegistry.register(selector, {
+			provideSelectionRanges: (model, positions, token) => {
+				return this._proxy.$provideSelectionRanges(handle, model.uri, positions, token);
+			}
+		}));
+	}
+
+	// --- call hierarchy
+
+	$registerCallHierarchyProvider(handle: number, selector: IDocumentFilterDto[]): void {
+		this._registrations.set(handle, callh.CallHierarchyProviderRegistry.register(selector, {
+
+			prepareCallHierarchy: async (document, position, token) => {
+				const items = await this._proxy.$prepareCallHierarchy(handle, document.uri, position, token);
+				if (!items) {
+					return undefined;
+				}
+				return {
+					dispose: () => {
+						for (const item of items) {
+							this._proxy.$releaseCallHierarchy(handle, item._sessionId);
+						}
+					},
+					roots: items.map(MainThreadLanguageFeatures._reviveCallHierarchyItemDto)
+				};
+			},
+
+			provideOutgoingCalls: async (item, token) => {
+				const outgoing = await this._proxy.$provideCallHierarchyOutgoingCalls(handle, item._sessionId, item._itemId, token);
+				if (!outgoing) {
+					return outgoing;
+				}
+				outgoing.forEach(value => {
+					value.to = MainThreadLanguageFeatures._reviveCallHierarchyItemDto(value.to);
+				});
+				return <any>outgoing;
+			},
+			provideIncomingCalls: async (item, token) => {
+				const incoming = await this._proxy.$provideCallHierarchyIncomingCalls(handle, item._sessionId, item._itemId, token);
+				if (!incoming) {
+					return incoming;
+				}
+				incoming.forEach(value => {
+					value.from = MainThreadLanguageFeatures._reviveCallHierarchyItemDto(value.from);
+				});
+				return <any>incoming;
+			}
+		}));
+	}
+
+	// --- configuration
+
+	private static _reviveRegExp(regExp: IRegExpDto): RegExp {
+		return new RegExp(regExp.pattern, regExp.flags);
+	}
+
+	private static _reviveIndentationRule(indentationRule: IIndentationRuleDto): IndentationRule {
+		return {
+			decreaseIndentPattern: MainThreadLanguageFeatures._reviveRegExp(indentationRule.decreaseIndentPattern),
+			increaseIndentPattern: MainThreadLanguageFeatures._reviveRegExp(indentationRule.increaseIndentPattern),
+			indentNextLinePattern: indentationRule.indentNextLinePattern ? MainThreadLanguageFeatures._reviveRegExp(indentationRule.indentNextLinePattern) : undefined,
+			unIndentedLinePattern: indentationRule.unIndentedLinePattern ? MainThreadLanguageFeatures._reviveRegExp(indentationRule.unIndentedLinePattern) : undefined,
+		};
+	}
+
+	private static _reviveOnEnterRule(onEnterRule: IOnEnterRuleDto): OnEnterRule {
+		return {
+			beforeText: MainThreadLanguageFeatures._reviveRegExp(onEnterRule.beforeText),
+			afterText: onEnterRule.afterText ? MainThreadLanguageFeatures._reviveRegExp(onEnterRule.afterText) : undefined,
+			oneLineAboveText: onEnterRule.oneLineAboveText ? MainThreadLanguageFeatures._reviveRegExp(onEnterRule.oneLineAboveText) : undefined,
+			action: onEnterRule.action
+		};
+	}
+
+	private static _reviveOnEnterRules(onEnterRules: IOnEnterRuleDto[]): OnEnterRule[] {
+		return onEnterRules.map(MainThreadLanguageFeatures._reviveOnEnterRule);
+	}
+
+	$setLanguageConfiguration(handle: number, languageId: string, _configuration: ILanguageConfigurationDto): void {
+
+		const configuration: LanguageConfiguration = {
+			comments: _configuration.comments,
+			brackets: _configuration.brackets,
+			wordPattern: _configuration.wordPattern ? MainThreadLanguageFeatures._reviveRegExp(_configuration.wordPattern) : undefined,
+			indentationRules: _configuration.indentationRules ? MainThreadLanguageFeatures._reviveIndentationRule(_configuration.indentationRules) : undefined,
+			onEnterRules: _configuration.onEnterRules ? MainThreadLanguageFeatures._reviveOnEnterRules(_configuration.onEnterRules) : undefined,
+
+			autoClosingPairs: undefined,
+			surroundingPairs: undefined,
+			__electricCharacterSupport: undefined
+		};
+
+		if (_configuration.__characterPairSupport) {
+			// backwards compatibility
+			configuration.autoClosingPairs = _configuration.__characterPairSupport.autoClosingPairs;
+		}
+
+		if (_configuration.__electricCharacterSupport && _configuration.__electricCharacterSupport.docComment) {
+			configuration.__electricCharacterSupport = {
+				docComment: {
+					open: _configuration.__electricCharacterSupport.docComment.open,
+					close: _configuration.__electricCharacterSupport.docComment.close
+				}
+			};
+		}
+
+		const languageIdentifier = this._modeService.getLanguageIdentifier(languageId);
+		if (languageIdentifier) {
+			this._registrations.set(handle, LanguageConfigurationRegistry.register(languageIdentifier, configuration));
+		}
+	}
+
+}
+
+export class MainThreadDocumentSemanticTokensProvider implements modes.DocumentSemanticTokensProvider {
+
+	constructor(
+		private readonly _proxy: ExtHostLanguageFeaturesShape,
+		private readonly _handle: number,
+		private readonly _legend: modes.SemanticTokensLegend,
+		public readonly onDidChange: Event<void> | undefined,
+	) {
+	}
+
+	public releaseDocumentSemanticTokens(resultId: string | undefined): void {
+		if (resultId) {
+			this._proxy.$releaseDocumentSemanticTokens(this._handle, parseInt(resultId, 10));
+		}
+	}
+
+	public getLegend(): modes.SemanticTokensLegend {
+		return this._legend;
+	}
+
+	async provideDocumentSemanticTokens(model: ITextModel, lastResultId: string | null, token: CancellationToken): Promise<modes.SemanticTokens | modes.SemanticTokensEdits | null> {
+		const nLastResultId = lastResultId ? parseInt(lastResultId, 10) : 0;
+		const encodedDto = await this._proxy.$provideDocumentSemanticTokens(this._handle, model.uri, nLastResultId, token);
+		if (!encodedDto) {
+			return null;
+		}
+		if (token.isCancellationRequested) {
+			return null;
+		}
+		const dto = decodeSemanticTokensDto(encodedDto);
+		if (dto.type === 'full') {
+			return {
+				resultId: String(dto.id),
+				data: dto.data
+			};
+		}
+		return {
+			resultId: String(dto.id),
+			edits: dto.deltas
+		};
+	}
+}
+
+export class MainThreadDocumentRangeSemanticTokensProvider implements modes.DocumentRangeSemanticTokensProvider {
+
+	constructor(
+		private readonly _proxy: ExtHostLanguageFeaturesShape,
+		private readonly _handle: number,
+		private readonly _legend: modes.SemanticTokensLegend,
+	) {
+	}
+
+	public getLegend(): modes.SemanticTokensLegend {
+		return this._legend;
+	}
+
+	async provideDocumentRangeSemanticTokens(model: ITextModel, range: EditorRange, token: CancellationToken): Promise<modes.SemanticTokens | null> {
+		const encodedDto = await this._proxy.$provideDocumentRangeSemanticTokens(this._handle, model.uri, range, token);
+		if (!encodedDto) {
+			return null;
+		}
+		if (token.isCancellationRequested) {
+			return null;
+		}
+		const dto = decodeSemanticTokensDto(encodedDto);
+		if (dto.type === 'full') {
+			return {
+				resultId: String(dto.id),
+				data: dto.data
+			};
+		}
+		throw new Error(`Unexpected`);
+	}
+}

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

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IModeService } from 'vs/editor/common/services/modeService';
+import { IModelService } from 'vs/editor/common/services/modelService';
+import { MainThreadLanguagesShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IPosition } from 'vs/editor/common/core/position';
+import { IRange, Range } from 'vs/editor/common/core/range';
+import { StandardTokenType } from 'vs/editor/common/modes';
+
+@extHostNamedCustomer(MainContext.MainThreadLanguages)
+export class MainThreadLanguages implements MainThreadLanguagesShape {
+
+	constructor(
+		_extHostContext: IExtHostContext,
+		@IModeService private readonly _modeService: IModeService,
+		@IModelService private readonly _modelService: IModelService
+	) {
+	}
+
+	dispose(): void {
+		// nothing
+	}
+
+	$getLanguages(): Promise<string[]> {
+		return Promise.resolve(this._modeService.getRegisteredModes());
+	}
+
+	$changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
+		const uri = URI.revive(resource);
+		const model = this._modelService.getModel(uri);
+		if (!model) {
+			return Promise.reject(new Error('Invalid uri'));
+		}
+		const languageIdentifier = this._modeService.getLanguageIdentifier(languageId);
+		if (!languageIdentifier || languageIdentifier.language !== languageId) {
+			return Promise.reject(new Error(`Unknown language id: ${languageId}`));
+		}
+		this._modelService.setMode(model, this._modeService.create(languageId));
+		return Promise.resolve(undefined);
+	}
+
+	async $tokensAtPosition(resource: UriComponents, position: IPosition): Promise<undefined | { type: StandardTokenType, range: IRange }> {
+		const uri = URI.revive(resource);
+		const model = this._modelService.getModel(uri);
+		if (!model) {
+			return undefined;
+		}
+		model.tokenizeIfCheap(position.lineNumber);
+		const tokens = model.getLineTokens(position.lineNumber);
+		const idx = tokens.findTokenIndexAtOffset(position.column - 1);
+		return {
+			type: tokens.getStandardTokenType(idx),
+			range: new Range(position.lineNumber, 1 + tokens.getStartOffset(idx), position.lineNumber, 1 + tokens.getEndOffset(idx))
+		};
+	}
+}

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

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ILogService, LogLevel } from 'vs/platform/log/common/log';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IExtHostContext, ExtHostContext, MainThreadLogShape, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { UriComponents, URI } from 'vs/base/common/uri';
+import { FileLogService } from 'vs/platform/log/common/fileLogService';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { basename } from 'vs/base/common/path';
+
+@extHostNamedCustomer(MainContext.MainThreadLog)
+export class MainThreadLogService implements MainThreadLogShape {
+
+	private readonly _loggers = new Map<string, FileLogService>();
+	private readonly _logListener: IDisposable;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ILogService private readonly _logService: ILogService,
+		@IInstantiationService private readonly _instaService: IInstantiationService,
+	) {
+		const proxy = extHostContext.getProxy(ExtHostContext.ExtHostLogService);
+		this._logListener = _logService.onDidChangeLogLevel(level => {
+			proxy.$setLevel(level);
+			this._loggers.forEach(value => value.setLevel(level));
+		});
+	}
+
+	dispose(): void {
+		this._logListener.dispose();
+		this._loggers.forEach(value => value.dispose());
+		this._loggers.clear();
+	}
+
+	$log(file: UriComponents, level: LogLevel, message: any[]): void {
+		const uri = URI.revive(file);
+		let logger = this._loggers.get(uri.toString());
+		if (!logger) {
+			logger = this._instaService.createInstance(FileLogService, basename(file.path), URI.revive(file), this._logService.getLevel());
+			this._loggers.set(uri.toString(), logger);
+		}
+		logger.log(level, message);
+	}
+}

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

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import Severity from 'vs/base/common/severity';
+import { Action, IAction } from 'vs/base/common/actions';
+import { MainThreadMessageServiceShape, MainContext, IExtHostContext, MainThreadMessageOptions } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { Event } from 'vs/base/common/event';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { dispose } from 'vs/base/common/lifecycle';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+
+@extHostNamedCustomer(MainContext.MainThreadMessageService)
+export class MainThreadMessageService implements MainThreadMessageServiceShape {
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@INotificationService private readonly _notificationService: INotificationService,
+		@ICommandService private readonly _commandService: ICommandService,
+		@IDialogService private readonly _dialogService: IDialogService
+	) {
+		//
+	}
+
+	dispose(): void {
+		//
+	}
+
+	$showMessage(severity: Severity, message: string, options: MainThreadMessageOptions, commands: { title: string; isCloseAffordance: boolean; handle: number; }[]): Promise<number | undefined> {
+		if (options.modal) {
+			return this._showModalMessage(severity, message, commands);
+		} else {
+			return this._showMessage(severity, message, commands, options.extension);
+		}
+	}
+
+	private _showMessage(severity: Severity, message: string, commands: { title: string; isCloseAffordance: boolean; handle: number; }[], extension: IExtensionDescription | undefined): Promise<number | undefined> {
+
+		return new Promise<number | undefined>(resolve => {
+
+			const primaryActions: MessageItemAction[] = [];
+
+			class MessageItemAction extends Action {
+				constructor(id: string, label: string, handle: number) {
+					super(id, label, undefined, true, () => {
+						resolve(handle);
+						return Promise.resolve();
+					});
+				}
+			}
+
+			class ManageExtensionAction extends Action {
+				constructor(id: ExtensionIdentifier, label: string, commandService: ICommandService) {
+					super(id.value, label, undefined, true, () => {
+						return commandService.executeCommand('_extensions.manage', id.value);
+					});
+				}
+			}
+
+			commands.forEach(command => {
+				primaryActions.push(new MessageItemAction('_extension_message_handle_' + command.handle, command.title, command.handle));
+			});
+
+			let source: string | undefined;
+			if (extension) {
+				source = nls.localize('extensionSource', "{0} (Extension)", extension.displayName || extension.name);
+			}
+
+			if (!source) {
+				source = nls.localize('defaultSource', "Extension");
+			}
+
+			const secondaryActions: IAction[] = [];
+			if (extension && !extension.isUnderDevelopment) {
+				secondaryActions.push(new ManageExtensionAction(extension.identifier, nls.localize('manageExtension', "Manage Extension"), this._commandService));
+			}
+
+			const messageHandle = this._notificationService.notify({
+				severity,
+				message,
+				actions: { primary: primaryActions, secondary: secondaryActions },
+				source
+			});
+
+			// if promise has not been resolved yet, now is the time to ensure a return value
+			// otherwise if already resolved it means the user clicked one of the buttons
+			Event.once(messageHandle.onDidClose)(() => {
+				dispose(primaryActions);
+				dispose(secondaryActions);
+				resolve(undefined);
+			});
+		});
+	}
+
+	private async _showModalMessage(severity: Severity, message: string, commands: { title: string; isCloseAffordance: boolean; handle: number; }[]): Promise<number | undefined> {
+		let cancelId: number | undefined = undefined;
+
+		const buttons = commands.map((command, index) => {
+			if (command.isCloseAffordance === true) {
+				cancelId = index;
+			}
+
+			return command.title;
+		});
+
+		if (cancelId === undefined) {
+			if (buttons.length > 0) {
+				buttons.push(nls.localize('cancel', "Cancel"));
+			} else {
+				buttons.push(nls.localize('ok', "OK"));
+			}
+
+			cancelId = buttons.length - 1;
+		}
+
+		const { choice } = await this._dialogService.show(severity, message, buttons, { cancelId });
+		return choice === commands.length ? undefined : commands[choice].handle;
+	}
+}

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

@@ -0,0 +1,771 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as DOM from 'vs/base/browser/dom';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Emitter } from 'vs/base/common/event';
+import { IRelativePattern } from 'vs/base/common/glob';
+import { combinedDisposable, Disposable, DisposableStore, dispose, IDisposable, IReference } from 'vs/base/common/lifecycle';
+import { ResourceMap } from 'vs/base/common/map';
+import { Schemas } from 'vs/base/common/network';
+import { IExtUri } from 'vs/base/common/resources';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ILogService } from 'vs/platform/log/common/log';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { INotebookEditor } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
+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 { ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, CellEditType, DisplayOrderKey, ICellEditOperation, ICellRange, IEditor, IMainCellDto, INotebookDecorationRenderOptions, INotebookDocumentFilter, INotebookEditorModel, INotebookExclusiveDocumentFilter, NotebookCellOutputsSplice, NotebookCellsChangeType, NOTEBOOK_DISPLAY_ORDER, TransientMetadata } 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 { 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, INotebookModelAddedData, MainContext, MainThreadNotebookShape, NotebookEditorRevealType, NotebookExtensionDescription } from '../common/extHost.protocol';
+
+class DocumentAndEditorState {
+	static ofSets<T>(before: Set<T>, after: Set<T>): { removed: T[], added: T[] } {
+		const removed: T[] = [];
+		const added: T[] = [];
+		before.forEach(element => {
+			if (!after.has(element)) {
+				removed.push(element);
+			}
+		});
+		after.forEach(element => {
+			if (!before.has(element)) {
+				added.push(element);
+			}
+		});
+		return { removed, added };
+	}
+
+	static ofMaps<K, V>(before: Map<K, V>, after: Map<K, V>): { removed: V[], added: V[] } {
+		const removed: V[] = [];
+		const added: V[] = [];
+		before.forEach((value, index) => {
+			if (!after.has(index)) {
+				removed.push(value);
+			}
+		});
+		after.forEach((value, index) => {
+			if (!before.has(index)) {
+				added.push(value);
+			}
+		});
+		return { removed, added };
+	}
+
+	static compute(before: DocumentAndEditorState | undefined, after: DocumentAndEditorState): INotebookDocumentsAndEditorsDelta {
+		if (!before) {
+			const apiEditors = [];
+			for (let id in after.textEditors) {
+				const editor = after.textEditors.get(id)!;
+				apiEditors.push({ id, documentUri: editor.uri!, selections: editor!.getSelectionHandles(), visibleRanges: editor.visibleRanges });
+			}
+
+			return {
+				addedDocuments: [],
+				addedEditors: apiEditors,
+				visibleEditors: [...after.visibleEditors].map(editor => editor[0])
+			};
+		}
+		const documentDelta = DocumentAndEditorState.ofSets(before.documents, after.documents);
+		const editorDelta = DocumentAndEditorState.ofMaps(before.textEditors, after.textEditors);
+		const addedAPIEditors = editorDelta.added.map(add => ({
+			id: add.getId(),
+			documentUri: add.uri!,
+			selections: add.getSelectionHandles(),
+			visibleRanges: add.visibleRanges
+		}));
+
+		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 = DocumentAndEditorState.ofMaps(before.visibleEditors, after.visibleEditors);
+
+		return {
+			addedDocuments: documentDelta.added.map((e: NotebookTextModel): INotebookModelAddedData => {
+				return {
+					viewType: e.viewType,
+					uri: e.uri,
+					metadata: e.metadata,
+					versionId: e.versionId,
+					cells: e.cells.map(cell => ({
+						handle: cell.handle,
+						uri: cell.uri,
+						source: cell.textBuffer.getLinesContent(),
+						eol: cell.textBuffer.getEOL(),
+						language: cell.language,
+						cellKind: cell.cellKind,
+						outputs: cell.outputs,
+						metadata: cell.metadata
+					})),
+					contentOptions: e.transientOptions,
+					// attachedEditor: editorId ? {
+					// 	id: editorId,
+					// 	selections: document.textModel.selections
+					// } : undefined
+				};
+			}),
+			removedDocuments: documentDelta.removed.map(e => e.uri),
+			addedEditors: addedAPIEditors,
+			removedEditors: removedAPIEditors,
+			newActiveEditor: newActiveEditor,
+			visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0
+				? undefined
+				: [...after.visibleEditors].map(editor => editor[0])
+		};
+	}
+
+	constructor(
+		readonly documents: Set<NotebookTextModel>,
+		readonly textEditors: Map<string, IEditor>,
+		readonly activeEditor: string | null | undefined,
+		readonly visibleEditors: Map<string, IEditor>
+	) {
+		//
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadNotebook)
+export class MainThreadNotebooks extends Disposable implements MainThreadNotebookShape {
+	private readonly _notebookProviders = new Map<string, { controller: IMainNotebookController, disposable: IDisposable }>();
+	private readonly _notebookKernelProviders = new Map<number, { extension: NotebookExtensionDescription, emitter: Emitter<URI | undefined>, provider: IDisposable }>();
+	private readonly _proxy: ExtHostNotebookShape;
+	private _toDisposeOnEditorRemove = new Map<string, IDisposable>();
+	private _currentState?: DocumentAndEditorState;
+	private _editorEventListenersMapping: Map<string, DisposableStore> = new Map();
+	private _documentEventListenersMapping: ResourceMap<DisposableStore> = new ResourceMap();
+	private readonly _cellStatusBarEntries: Map<number, IDisposable> = new Map();
+	private readonly _modelReferenceCollection: BoundModelReferenceCollection;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@INotebookService private _notebookService: INotebookService,
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IEditorService private readonly editorService: IEditorService,
+		@IAccessibilityService private readonly accessibilityService: IAccessibilityService,
+		@ILogService private readonly logService: ILogService,
+		@INotebookCellStatusBarService private readonly cellStatusBarService: INotebookCellStatusBarService,
+		@IWorkingCopyService private readonly _workingCopyService: IWorkingCopyService,
+		@INotebookEditorModelResolverService private readonly _notebookModelResolverService: INotebookEditorModelResolverService,
+		@IUriIdentityService private readonly _uriIdentityService: IUriIdentityService,
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostNotebook);
+		this._modelReferenceCollection = new BoundModelReferenceCollection(this._uriIdentityService.extUri);
+		this._register(this._modelReferenceCollection);
+		this.registerListeners();
+	}
+
+	async $tryApplyEdits(_viewType: string, resource: UriComponents, modelVersionId: number, cellEdits: ICellEditOperation[]): Promise<boolean> {
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		if (!textModel) {
+			return false;
+		}
+		this._notebookService.transformEditsOutputs(textModel, cellEdits);
+		return textModel.applyEdits(modelVersionId, cellEdits, true, undefined, () => undefined, undefined);
+	}
+
+	private _isDeltaEmpty(delta: INotebookDocumentsAndEditorsDelta) {
+		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;
+	}
+
+	private _emitDelta(delta: INotebookDocumentsAndEditorsDelta) {
+		if (this._isDeltaEmpty(delta)) {
+			return;
+		}
+
+		return this._proxy.$acceptDocumentAndEditorsDelta(delta);
+	}
+
+	registerListeners() {
+		this._notebookService.listNotebookEditors().forEach((e) => {
+			this._addNotebookEditor(e);
+		});
+
+		this._register(this._notebookService.onDidChangeActiveEditor(e => {
+			this._updateState();
+		}));
+
+		this._register(this._notebookService.onDidChangeVisibleEditors(e => {
+			if (this._notebookProviders.size > 0) {
+				if (!this._currentState) {
+					// no current state means we didn't even create editors in ext host yet.
+					return;
+				}
+
+				// we can't simply update visibleEditors as we need to check if we should create editors first.
+				this._updateState();
+			}
+		}));
+
+		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(() => {
+					const selectionHandles = editor.getSelectionHandles();
+					this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: null, selections: { selections: selectionHandles } });
+				}));
+
+				this._editorEventListenersMapping.set(editor.getId(), disposableStore);
+			}
+		};
+
+		this._register(this._notebookService.onNotebookEditorAdd(editor => {
+			notebookEditorAddedHandler(editor);
+			this._addNotebookEditor(editor);
+		}));
+
+		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 {
+				handle: cell.handle,
+				uri: cell.uri,
+				source: cell.textBuffer.getLinesContent(),
+				eol: cell.textBuffer.getEOL(),
+				language: cell.language,
+				cellKind: cell.cellKind,
+				outputs: cell.outputs,
+				metadata: cell.metadata
+			};
+		};
+
+
+		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);
+			}
+		};
+
+		this._notebookService.listNotebookDocuments().forEach(notebookDocumentAddedHandler);
+		this._register(this._notebookService.onDidAddNotebookDocument(document => {
+			notebookDocumentAddedHandler(document);
+			this._updateState();
+		}));
+
+		this._register(this._notebookService.onDidRemoveNotebookDocument(uri => {
+			this._documentEventListenersMapping.get(uri)?.dispose();
+			this._documentEventListenersMapping.delete(uri);
+			this._updateState();
+		}));
+
+		this._register(this._notebookService.onDidChangeNotebookActiveKernel(e => {
+			this._proxy.$acceptNotebookActiveKernelChange(e);
+		}));
+
+		this._register(this._notebookService.onNotebookDocumentSaved(e => {
+			this._proxy.$acceptModelSaved(e);
+		}));
+
+		const updateOrder = () => {
+			let userOrder = this.configurationService.getValue<string[]>(DisplayOrderKey);
+			this._proxy.$acceptDisplayOrder({
+				defaultOrder: this.accessibilityService.isScreenReaderOptimized() ? ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER : NOTEBOOK_DISPLAY_ORDER,
+				userOrder: userOrder
+			});
+		};
+
+		updateOrder();
+
+		this._register(this.configurationService.onDidChangeConfiguration(e => {
+			if (e.affectedKeys.indexOf(DisplayOrderKey) >= 0) {
+				updateOrder();
+			}
+		}));
+
+		this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => {
+			updateOrder();
+		}));
+
+		const activeEditorPane = this.editorService.activeEditorPane as any | undefined;
+		const notebookEditor = activeEditorPane?.isNotebookEditor ? activeEditorPane.getControl() : undefined;
+		this._updateState(notebookEditor);
+	}
+
+	private _addNotebookEditor(e: IEditor) {
+		this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable(
+			e.onDidChangeModel(() => this._updateState()),
+			e.onDidFocusEditorWidget(() => {
+				this._updateState(e);
+			}),
+		));
+
+		const activeEditorPane = this.editorService.activeEditorPane as any | undefined;
+		const notebookEditor = activeEditorPane?.isNotebookEditor ? activeEditorPane.getControl() : undefined;
+		this._updateState(notebookEditor);
+	}
+
+	private _removeNotebookEditor(editors: IEditor[]) {
+		editors.forEach(e => {
+			const sub = this._toDisposeOnEditorRemove.get(e.getId());
+			if (sub) {
+				this._toDisposeOnEditorRemove.delete(e.getId());
+				sub.dispose();
+			}
+		});
+
+		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.hasModel()) {
+				editors.set(editor.getId(), editor);
+				documentEditorsMap.set(editor.textModel!.uri.toString(), editor);
+			}
+		});
+
+		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.hasModel()) {
+			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)
+
+		// if (!isEmptyChange) {
+		this._currentState = newState;
+		await this._emitDelta(delta);
+		// }
+	}
+
+	async $registerNotebookProvider(extension: NotebookExtensionDescription, viewType: string, supportBackup: boolean, options: {
+		transientOutputs: boolean;
+		transientMetadata: TransientMetadata;
+		viewOptions?: { displayName: string; filenamePattern: (string | IRelativePattern | INotebookExclusiveDocumentFilter)[]; exclusive: boolean; };
+	}): Promise<void> {
+		let contentOptions = { transientOutputs: options.transientOutputs, transientMetadata: options.transientMetadata };
+
+		const controller: IMainNotebookController = {
+			supportBackup,
+			get options() {
+				return contentOptions;
+			},
+			set options(newOptions) {
+				contentOptions.transientMetadata = newOptions.transientMetadata;
+				contentOptions.transientOutputs = newOptions.transientOutputs;
+			},
+			viewOptions: options.viewOptions,
+			reloadNotebook: async (mainthreadTextModel: NotebookTextModel) => {
+				const data = await this._proxy.$resolveNotebookData(viewType, mainthreadTextModel.uri);
+				mainthreadTextModel.updateLanguages(data.languages);
+				mainthreadTextModel.metadata = data.metadata;
+				mainthreadTextModel.transientOptions = contentOptions;
+
+				const edits: ICellEditOperation[] = [
+					{ editType: CellEditType.Replace, index: 0, count: mainthreadTextModel.cells.length, cells: data.cells }
+				];
+
+				this._notebookService.transformEditsOutputs(mainthreadTextModel, edits);
+				await new Promise(resolve => {
+					DOM.scheduleAtNextAnimationFrame(() => {
+						const ret = mainthreadTextModel!.applyEdits(mainthreadTextModel!.versionId, edits, true, undefined, () => undefined, undefined);
+						resolve(ret);
+					});
+				});
+			},
+			resolveNotebookDocument: async (viewType: string, uri: URI, backupId?: string) => {
+				const data = await this._proxy.$resolveNotebookData(viewType, uri, backupId);
+				return {
+					data,
+					transientOptions: contentOptions
+				};
+			},
+			resolveNotebookEditor: async (viewType: string, uri: URI, editorId: string) => {
+				await this._proxy.$resolveNotebookEditor(viewType, uri, editorId);
+			},
+			onDidReceiveMessage: (editorId: string, rendererType: string | undefined, message: unknown) => {
+				this._proxy.$onDidReceiveMessage(editorId, rendererType, message);
+			},
+			save: async (uri: URI, token: CancellationToken) => {
+				return this._proxy.$saveNotebook(viewType, uri, token);
+			},
+			saveAs: async (uri: URI, target: URI, token: CancellationToken) => {
+				return this._proxy.$saveNotebookAs(viewType, uri, target, token);
+			},
+			backup: async (uri: URI, token: CancellationToken) => {
+				return this._proxy.$backup(viewType, uri, token);
+			}
+		};
+
+		const disposable = this._notebookService.registerNotebookController(viewType, extension, controller);
+		this._notebookProviders.set(viewType, { controller, disposable });
+		return;
+	}
+
+	async $updateNotebookProviderOptions(viewType: string, options?: { transientOutputs: boolean; transientMetadata: TransientMetadata; }): Promise<void> {
+		const provider = this._notebookProviders.get(viewType);
+
+		if (provider && options) {
+			provider.controller.options = options;
+			this._notebookService.listNotebookDocuments().forEach(document => {
+				if (document.viewType === viewType) {
+					document.transientOptions = provider.controller.options;
+				}
+			});
+		}
+	}
+
+	async $unregisterNotebookProvider(viewType: string): Promise<void> {
+		const entry = this._notebookProviders.get(viewType);
+		if (entry) {
+			entry.disposable.dispose();
+			this._notebookProviders.delete(viewType);
+		}
+	}
+
+	async $registerNotebookKernelProvider(extension: NotebookExtensionDescription, handle: number, documentFilter: INotebookDocumentFilter): Promise<void> {
+		const emitter = new Emitter<URI | undefined>();
+		const that = this;
+		const provider = this._notebookService.registerNotebookKernelProvider({
+			providerExtensionId: extension.id.value,
+			providerDescription: extension.description,
+			onDidChangeKernels: emitter.event,
+			selector: documentFilter,
+			provideKernels: async (uri: URI, token: CancellationToken) => {
+				const kernels = await that._proxy.$provideNotebookKernels(handle, uri, token);
+				return kernels.map(kernel => {
+					return {
+						...kernel,
+						providerHandle: handle
+					};
+				});
+			},
+			resolveKernel: (editorId: string, uri: URI, kernelId: string, token: CancellationToken) => {
+				return that._proxy.$resolveNotebookKernel(handle, editorId, uri, kernelId, token);
+			},
+			executeNotebook: (uri: URI, kernelId: string, cellHandle: number | undefined) => {
+				this.logService.debug('MainthreadNotebooks.registerNotebookKernelProvider#executeNotebook', uri.path, kernelId, cellHandle);
+				return that._proxy.$executeNotebookKernelFromProvider(handle, uri, kernelId, cellHandle);
+			},
+			cancelNotebook: (uri: URI, kernelId: string, cellHandle: number | undefined) => {
+				this.logService.debug('MainthreadNotebooks.registerNotebookKernelProvider#cancelNotebook', uri.path, kernelId, cellHandle);
+				return that._proxy.$cancelNotebookKernelFromProvider(handle, uri, kernelId, cellHandle);
+			},
+		});
+		this._notebookKernelProviders.set(handle, {
+			extension,
+			emitter,
+			provider
+		});
+
+		return;
+	}
+
+	async $unregisterNotebookKernelProvider(handle: number): Promise<void> {
+		const entry = this._notebookKernelProviders.get(handle);
+
+		if (entry) {
+			entry.emitter.dispose();
+			entry.provider.dispose();
+			this._notebookKernelProviders.delete(handle);
+		}
+	}
+
+	$onNotebookKernelChange(handle: number, uriComponents: UriComponents): void {
+		const entry = this._notebookKernelProviders.get(handle);
+
+		entry?.emitter.fire(uriComponents ? URI.revive(uriComponents) : undefined);
+	}
+
+	async $updateNotebookLanguages(viewType: string, resource: UriComponents, languages: string[]): Promise<void> {
+		this.logService.debug('MainThreadNotebooks#updateNotebookLanguages', resource.path, languages);
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		textModel?.updateLanguages(languages);
+	}
+
+	async $spliceNotebookCellOutputs(viewType: string, resource: UriComponents, cellHandle: number, splices: NotebookCellOutputsSplice[]): Promise<void> {
+		this.logService.debug('MainThreadNotebooks#spliceNotebookCellOutputs', resource.path, cellHandle);
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+
+		if (!textModel) {
+			return;
+		}
+
+		this._notebookService.transformSpliceOutputs(textModel, splices);
+		const cell = textModel.cells.find(cell => cell.handle === cellHandle);
+
+		if (!cell) {
+			return;
+		}
+
+		textModel.applyEdits(textModel.versionId, [
+			{
+				editType: CellEditType.OutputsSplice,
+				index: textModel.cells.indexOf(cell),
+				splices
+			}
+		], true, undefined, () => undefined, 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;
+		}
+
+		return false;
+	}
+
+	$onUndoableContentChange(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void {
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+
+		if (textModel) {
+			textModel.handleUnknownUndoableEdit(label, () => {
+				const isDirty = this._workingCopyService.isDirty(textModel.uri.with({ scheme: Schemas.vscodeNotebook }));
+				return this._proxy.$undoNotebook(textModel.viewType, textModel.uri, editId, isDirty);
+			}, () => {
+				const isDirty = this._workingCopyService.isDirty(textModel.uri.with({ scheme: Schemas.vscodeNotebook }));
+				return this._proxy.$redoNotebook(textModel.viewType, textModel.uri, editId, isDirty);
+			});
+		}
+	}
+
+	$onContentChange(resource: UriComponents, viewType: string): void {
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+
+		if (textModel) {
+			textModel.applyEdits(textModel.versionId, [
+				{
+					editType: CellEditType.Unknown
+				}
+			], true, undefined, () => undefined, undefined);
+		}
+	}
+
+	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;
+			const viewModel = notebookEditor.viewModel;
+			const cell = viewModel?.viewCells[range.start];
+			if (!cell) {
+				return;
+			}
+
+			switch (revealType) {
+				case NotebookEditorRevealType.Default:
+					notebookEditor.revealInView(cell);
+					break;
+				case NotebookEditorRevealType.InCenter:
+					notebookEditor.revealInCenter(cell);
+					break;
+				case NotebookEditorRevealType.InCenterIfOutsideViewport:
+					notebookEditor.revealInCenterIfOutsideViewport(cell);
+					break;
+				default:
+					break;
+			}
+		}
+	}
+
+	$registerNotebookEditorDecorationType(key: string, options: INotebookDecorationRenderOptions) {
+		this._notebookService.registerEditorDecorationType(key, options);
+	}
+
+	$removeNotebookEditorDecorationType(key: string) {
+		this._notebookService.removeEditorDecorationType(key);
+	}
+
+	$trySetDecorations(id: string, range: ICellRange, key: string) {
+		const editor = this._notebookService.listNotebookEditors().find(editor => editor.getId() === id);
+		if (editor && editor.isNotebookEditor) {
+			const notebookEditor = editor as INotebookEditor;
+			notebookEditor.setEditorDecorations(key, range);
+		}
+	}
+
+	async $setStatusBarEntry(id: number, rawStatusBarEntry: INotebookCellStatusBarEntryDto): Promise<void> {
+		const statusBarEntry = {
+			...rawStatusBarEntry,
+			...{ cellResource: URI.revive(rawStatusBarEntry.cellResource) }
+		};
+
+		const existingEntry = this._cellStatusBarEntries.get(id);
+		if (existingEntry) {
+			existingEntry.dispose();
+		}
+
+		if (statusBarEntry.visible) {
+			this._cellStatusBarEntries.set(
+				id,
+				this.cellStatusBarService.addEntry(statusBarEntry));
+		}
+	}
+
+
+	async $tryOpenDocument(uriComponents: UriComponents, viewType?: string): Promise<URI> {
+		const uri = URI.revive(uriComponents);
+		const ref = await this._notebookModelResolverService.resolve(uri, viewType);
+		this._modelReferenceCollection.add(uri, ref);
+
+		return uri;
+	}
+}
+
+
+export class BoundModelReferenceCollection {
+
+	private _data = new Array<{ uri: URI, dispose(): void }>();
+
+	constructor(
+		private readonly _extUri: IExtUri,
+		private readonly _maxAge: number = 1000 * 60 * 3,
+	) {
+		//
+	}
+
+	dispose(): void {
+		this._data = dispose(this._data);
+	}
+
+	remove(uri: URI): void {
+		for (const entry of [...this._data] /* copy array because dispose will modify it */) {
+			if (this._extUri.isEqualOrParent(entry.uri, uri)) {
+				entry.dispose();
+			}
+		}
+	}
+
+	add(uri: URI, ref: IReference<INotebookEditorModel>): void {
+		let handle: any;
+		let entry: { uri: URI, dispose(): void };
+		const dispose = () => {
+			const idx = this._data.indexOf(entry);
+			if (idx >= 0) {
+				ref.dispose();
+				clearTimeout(handle);
+				this._data.splice(idx, 1);
+			}
+		};
+		handle = setTimeout(dispose, this._maxAge);
+		entry = { uri, dispose };
+
+		this._data.push(entry);
+	}
+}

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

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IOutputService, IOutputChannel, OUTPUT_VIEW_ID } from 'vs/workbench/contrib/output/common/output';
+import { Extensions, IOutputChannelRegistry } from 'vs/workbench/services/output/common/output';
+import { MainThreadOutputServiceShape, MainContext, IExtHostContext, ExtHostOutputServiceShape, ExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { UriComponents, URI } from 'vs/base/common/uri';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Event } from 'vs/base/common/event';
+import { IViewsService } from 'vs/workbench/common/views';
+
+@extHostNamedCustomer(MainContext.MainThreadOutputService)
+export class MainThreadOutputService extends Disposable implements MainThreadOutputServiceShape {
+
+	private static _idPool = 1;
+
+	private readonly _proxy: ExtHostOutputServiceShape;
+	private readonly _outputService: IOutputService;
+	private readonly _viewsService: IViewsService;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IOutputService outputService: IOutputService,
+		@IViewsService viewsService: IViewsService
+	) {
+		super();
+		this._outputService = outputService;
+		this._viewsService = viewsService;
+
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostOutputService);
+
+		const setVisibleChannel = () => {
+			const visibleChannel = this._viewsService.isViewVisible(OUTPUT_VIEW_ID) ? this._outputService.getActiveChannel() : undefined;
+			this._proxy.$setVisibleChannel(visibleChannel ? visibleChannel.id : null);
+		};
+		this._register(Event.any<any>(this._outputService.onActiveOutputChannel, Event.filter(this._viewsService.onDidChangeViewVisibility, ({ id }) => id === OUTPUT_VIEW_ID))(() => setVisibleChannel()));
+		setVisibleChannel();
+	}
+
+	public $register(label: string, log: boolean, file?: UriComponents): Promise<string> {
+		const id = 'extension-output-#' + (MainThreadOutputService._idPool++);
+		Registry.as<IOutputChannelRegistry>(Extensions.OutputChannels).registerChannel({ id, label, file: file ? URI.revive(file) : undefined, log });
+		this._register(toDisposable(() => this.$dispose(id)));
+		return Promise.resolve(id);
+	}
+
+	public $append(channelId: string, value: string): Promise<void> | undefined {
+		const channel = this._getChannel(channelId);
+		if (channel) {
+			channel.append(value);
+		}
+		return undefined;
+	}
+
+	public $update(channelId: string): Promise<void> | undefined {
+		const channel = this._getChannel(channelId);
+		if (channel) {
+			channel.update();
+		}
+		return undefined;
+	}
+
+	public $clear(channelId: string, till: number): Promise<void> | undefined {
+		const channel = this._getChannel(channelId);
+		if (channel) {
+			channel.clear(till);
+		}
+		return undefined;
+	}
+
+	public $reveal(channelId: string, preserveFocus: boolean): Promise<void> | undefined {
+		const channel = this._getChannel(channelId);
+		if (channel) {
+			this._outputService.showChannel(channel.id, preserveFocus);
+		}
+		return undefined;
+	}
+
+	public $close(channelId: string): Promise<void> | undefined {
+		if (this._viewsService.isViewVisible(OUTPUT_VIEW_ID)) {
+			const activeChannel = this._outputService.getActiveChannel();
+			if (activeChannel && channelId === activeChannel.id) {
+				this._viewsService.closeView(OUTPUT_VIEW_ID);
+			}
+		}
+
+		return undefined;
+	}
+
+	public $dispose(channelId: string): Promise<void> | undefined {
+		const channel = this._getChannel(channelId);
+		if (channel) {
+			channel.dispose();
+		}
+		return undefined;
+	}
+
+	private _getChannel(channelId: string): IOutputChannel | undefined {
+		return this._outputService.getChannel(channelId);
+	}
+}

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

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IProgress, IProgressService, IProgressStep, ProgressLocation, IProgressOptions, IProgressNotificationOptions } from 'vs/platform/progress/common/progress';
+import { MainThreadProgressShape, MainContext, IExtHostContext, ExtHostProgressShape, ExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { Action } from 'vs/base/common/actions';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { localize } from 'vs/nls';
+
+class ManageExtensionAction extends Action {
+	constructor(id: ExtensionIdentifier, label: string, commandService: ICommandService) {
+		super(id.value, label, undefined, true, () => {
+			return commandService.executeCommand('_extensions.manage', id.value);
+		});
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadProgress)
+export class MainThreadProgress implements MainThreadProgressShape {
+
+	private readonly _progressService: IProgressService;
+	private _progress = new Map<number, { resolve: () => void, progress: IProgress<IProgressStep> }>();
+	private readonly _proxy: ExtHostProgressShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IProgressService progressService: IProgressService,
+		@ICommandService private readonly _commandService: ICommandService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostProgress);
+		this._progressService = progressService;
+	}
+
+	dispose(): void {
+		this._progress.forEach(handle => handle.resolve());
+		this._progress.clear();
+	}
+
+	$startProgress(handle: number, options: IProgressOptions, extension?: IExtensionDescription): void {
+		const task = this._createTask(handle);
+
+		if (options.location === ProgressLocation.Notification && extension && !extension.isUnderDevelopment) {
+			const notificationOptions: IProgressNotificationOptions = {
+				...options,
+				location: ProgressLocation.Notification,
+				secondaryActions: [new ManageExtensionAction(extension.identifier, localize('manageExtension', "Manage Extension"), this._commandService)]
+			};
+
+			options = notificationOptions;
+		}
+
+		this._progressService.withProgress(options, task, () => this._proxy.$acceptProgressCanceled(handle));
+	}
+
+	$progressReport(handle: number, message: IProgressStep): void {
+		const entry = this._progress.get(handle);
+		if (entry) {
+			entry.progress.report(message);
+		}
+	}
+
+	$progressEnd(handle: number): void {
+		const entry = this._progress.get(handle);
+		if (entry) {
+			entry.resolve();
+			this._progress.delete(handle);
+		}
+	}
+
+	private _createTask(handle: number) {
+		return (progress: IProgress<IProgressStep>) => {
+			return new Promise<void>(resolve => {
+				this._progress.set(handle, { resolve, progress });
+			});
+		};
+	}
+}

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

@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IPickOptions, IInputOptions, IQuickInputService, IQuickInput } from 'vs/platform/quickinput/common/quickInput';
+import { ExtHostContext, MainThreadQuickOpenShape, ExtHostQuickOpenShape, TransferQuickPickItems, MainContext, IExtHostContext, TransferQuickInput, TransferQuickInputButton, IInputBoxOptions } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { URI } from 'vs/base/common/uri';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ThemeIcon } from 'vs/platform/theme/common/themeService';
+
+interface QuickInputSession {
+	input: IQuickInput;
+	handlesToItems: Map<number, TransferQuickPickItems>;
+}
+
+@extHostNamedCustomer(MainContext.MainThreadQuickOpen)
+export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
+
+	private readonly _proxy: ExtHostQuickOpenShape;
+	private readonly _quickInputService: IQuickInputService;
+	private readonly _items: Record<number, {
+		resolve(items: TransferQuickPickItems[]): void;
+		reject(error: Error): void;
+	}> = {};
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IQuickInputService quickInputService: IQuickInputService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostQuickOpen);
+		this._quickInputService = quickInputService;
+	}
+
+	public dispose(): void {
+	}
+
+	$show(instance: number, options: IPickOptions<TransferQuickPickItems>, token: CancellationToken): Promise<number | number[] | undefined> {
+		const contents = new Promise<TransferQuickPickItems[]>((resolve, reject) => {
+			this._items[instance] = { resolve, reject };
+		});
+
+		options = {
+			...options,
+			onDidFocus: el => {
+				if (el) {
+					this._proxy.$onItemSelected((<TransferQuickPickItems>el).handle);
+				}
+			}
+		};
+
+		if (options.canPickMany) {
+			return this._quickInputService.pick(contents, options as { canPickMany: true }, token).then(items => {
+				if (items) {
+					return items.map(item => item.handle);
+				}
+				return undefined;
+			});
+		} else {
+			return this._quickInputService.pick(contents, options, token).then(item => {
+				if (item) {
+					return item.handle;
+				}
+				return undefined;
+			});
+		}
+	}
+
+	$setItems(instance: number, items: TransferQuickPickItems[]): Promise<void> {
+		if (this._items[instance]) {
+			this._items[instance].resolve(items);
+			delete this._items[instance];
+		}
+		return Promise.resolve();
+	}
+
+	$setError(instance: number, error: Error): Promise<void> {
+		if (this._items[instance]) {
+			this._items[instance].reject(error);
+			delete this._items[instance];
+		}
+		return Promise.resolve();
+	}
+
+	// ---- input
+
+	$input(options: IInputBoxOptions | undefined, validateInput: boolean, token: CancellationToken): Promise<string | undefined> {
+		const inputOptions: IInputOptions = Object.create(null);
+
+		if (options) {
+			inputOptions.password = options.password;
+			inputOptions.placeHolder = options.placeHolder;
+			inputOptions.valueSelection = options.valueSelection;
+			inputOptions.prompt = options.prompt;
+			inputOptions.value = options.value;
+			inputOptions.ignoreFocusLost = options.ignoreFocusOut;
+		}
+
+		if (validateInput) {
+			inputOptions.validateInput = (value) => {
+				return this._proxy.$validateInput(value);
+			};
+		}
+
+		return this._quickInputService.input(inputOptions, token);
+	}
+
+	// ---- QuickInput
+
+	private sessions = new Map<number, QuickInputSession>();
+
+	$createOrUpdate(params: TransferQuickInput): Promise<void> {
+		const sessionId = params.id;
+		let session = this.sessions.get(sessionId);
+		if (!session) {
+			if (params.type === 'quickPick') {
+				const input = this._quickInputService.createQuickPick();
+				input.onDidAccept(() => {
+					this._proxy.$onDidAccept(sessionId);
+				});
+				input.onDidChangeActive(items => {
+					this._proxy.$onDidChangeActive(sessionId, items.map(item => (item as TransferQuickPickItems).handle));
+				});
+				input.onDidChangeSelection(items => {
+					this._proxy.$onDidChangeSelection(sessionId, items.map(item => (item as TransferQuickPickItems).handle));
+				});
+				input.onDidTriggerButton(button => {
+					this._proxy.$onDidTriggerButton(sessionId, (button as TransferQuickInputButton).handle);
+				});
+				input.onDidChangeValue(value => {
+					this._proxy.$onDidChangeValue(sessionId, value);
+				});
+				input.onDidHide(() => {
+					this._proxy.$onDidHide(sessionId);
+				});
+				session = {
+					input,
+					handlesToItems: new Map()
+				};
+			} else {
+				const input = this._quickInputService.createInputBox();
+				input.onDidAccept(() => {
+					this._proxy.$onDidAccept(sessionId);
+				});
+				input.onDidTriggerButton(button => {
+					this._proxy.$onDidTriggerButton(sessionId, (button as TransferQuickInputButton).handle);
+				});
+				input.onDidChangeValue(value => {
+					this._proxy.$onDidChangeValue(sessionId, value);
+				});
+				input.onDidHide(() => {
+					this._proxy.$onDidHide(sessionId);
+				});
+				session = {
+					input,
+					handlesToItems: new Map()
+				};
+			}
+			this.sessions.set(sessionId, session);
+		}
+		const { input, handlesToItems } = session;
+		for (const param in params) {
+			if (param === 'id' || param === 'type') {
+				continue;
+			}
+			if (param === 'visible') {
+				if (params.visible) {
+					input.show();
+				} else {
+					input.hide();
+				}
+			} else if (param === 'items') {
+				handlesToItems.clear();
+				params[param].forEach((item: TransferQuickPickItems) => {
+					handlesToItems.set(item.handle, item);
+				});
+				(input as any)[param] = params[param];
+			} else if (param === 'activeItems' || param === 'selectedItems') {
+				(input as any)[param] = params[param]
+					.filter((handle: number) => handlesToItems.has(handle))
+					.map((handle: number) => handlesToItems.get(handle));
+			} else if (param === 'buttons') {
+				(input as any)[param] = params.buttons!.map(button => {
+					if (button.handle === -1) {
+						return this._quickInputService.backButton;
+					}
+					const { iconPath, tooltip, handle } = button;
+					if ('id' in iconPath) {
+						return {
+							iconClass: ThemeIcon.asClassName(iconPath),
+							tooltip,
+							handle
+						};
+					} else {
+						return {
+							iconPath: {
+								dark: URI.revive(iconPath.dark),
+								light: iconPath.light && URI.revive(iconPath.light)
+							},
+							tooltip,
+							handle
+						};
+					}
+				});
+			} else {
+				(input as any)[param] = params[param];
+			}
+		}
+		return Promise.resolve(undefined);
+	}
+
+	$dispose(sessionId: number): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (session) {
+			session.input.dispose();
+			this.sessions.delete(sessionId);
+		}
+		return Promise.resolve(undefined);
+	}
+}

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

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, IExtHostContext, ExtHostExtensionServiceShape } from '../common/extHost.protocol';
+import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+
+@extHostCustomer
+export class MainThreadRemoteConnectionData extends Disposable {
+
+	private readonly _proxy: ExtHostExtensionServiceShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IWorkbenchEnvironmentService protected readonly _environmentService: IWorkbenchEnvironmentService,
+		@IRemoteAuthorityResolverService remoteAuthorityResolverService: IRemoteAuthorityResolverService
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostExtensionService);
+
+		const remoteAuthority = this._environmentService.remoteAuthority;
+		if (remoteAuthority) {
+			this._register(remoteAuthorityResolverService.onDidChangeConnectionData(() => {
+				const connectionData = remoteAuthorityResolverService.getConnectionData(remoteAuthority);
+				if (connectionData) {
+					this._proxy.$updateRemoteConnectionData(connectionData);
+				}
+			}));
+		}
+	}
+}

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

@@ -0,0 +1,440 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { Event, Emitter } from 'vs/base/common/event';
+import { IDisposable, DisposableStore, combinedDisposable } from 'vs/base/common/lifecycle';
+import { ISCMService, ISCMRepository, ISCMProvider, ISCMResource, ISCMResourceGroup, ISCMResourceDecorations, IInputValidation, ISCMViewService } from 'vs/workbench/contrib/scm/common/scm';
+import { ExtHostContext, MainThreadSCMShape, ExtHostSCMShape, SCMProviderFeatures, SCMRawResourceSplices, SCMGroupFeatures, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { Command } from 'vs/editor/common/modes';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ISplice, Sequence } from 'vs/base/common/sequence';
+import { CancellationToken } from 'vs/base/common/cancellation';
+
+class MainThreadSCMResourceGroup implements ISCMResourceGroup {
+
+	readonly elements: ISCMResource[] = [];
+
+	private readonly _onDidSplice = new Emitter<ISplice<ISCMResource>>();
+	readonly onDidSplice = this._onDidSplice.event;
+
+	get hideWhenEmpty(): boolean { return !!this.features.hideWhenEmpty; }
+
+	private readonly _onDidChange = new Emitter<void>();
+	readonly onDidChange: Event<void> = this._onDidChange.event;
+
+	constructor(
+		private readonly sourceControlHandle: number,
+		private readonly handle: number,
+		public provider: ISCMProvider,
+		public features: SCMGroupFeatures,
+		public label: string,
+		public id: string
+	) { }
+
+	toJSON(): any {
+		return {
+			$mid: 4,
+			sourceControlHandle: this.sourceControlHandle,
+			groupHandle: this.handle
+		};
+	}
+
+	splice(start: number, deleteCount: number, toInsert: ISCMResource[]) {
+		this.elements.splice(start, deleteCount, ...toInsert);
+		this._onDidSplice.fire({ start, deleteCount, toInsert });
+	}
+
+	$updateGroup(features: SCMGroupFeatures): void {
+		this.features = { ...this.features, ...features };
+		this._onDidChange.fire();
+	}
+
+	$updateGroupLabel(label: string): void {
+		this.label = label;
+		this._onDidChange.fire();
+	}
+}
+
+class MainThreadSCMResource implements ISCMResource {
+
+	constructor(
+		private readonly proxy: ExtHostSCMShape,
+		private readonly sourceControlHandle: number,
+		private readonly groupHandle: number,
+		private readonly handle: number,
+		readonly sourceUri: URI,
+		readonly resourceGroup: ISCMResourceGroup,
+		readonly decorations: ISCMResourceDecorations,
+		readonly contextValue: string | undefined
+	) { }
+
+	open(preserveFocus: boolean): Promise<void> {
+		return this.proxy.$executeResourceCommand(this.sourceControlHandle, this.groupHandle, this.handle, preserveFocus);
+	}
+
+	toJSON(): any {
+		return {
+			$mid: 3,
+			sourceControlHandle: this.sourceControlHandle,
+			groupHandle: this.groupHandle,
+			handle: this.handle
+		};
+	}
+}
+
+class MainThreadSCMProvider implements ISCMProvider {
+
+	private static ID_HANDLE = 0;
+	private _id = `scm${MainThreadSCMProvider.ID_HANDLE++}`;
+	get id(): string { return this._id; }
+
+	readonly groups = new Sequence<MainThreadSCMResourceGroup>();
+	private readonly _groupsByHandle: { [handle: number]: MainThreadSCMResourceGroup; } = Object.create(null);
+
+	// get groups(): ISequence<ISCMResourceGroup> {
+	// 	return {
+	// 		elements: this._groups,
+	// 		onDidSplice: this._onDidSplice.event
+	// 	};
+
+	// 	// return this._groups
+	// 	// 	.filter(g => g.resources.elements.length > 0 || !g.features.hideWhenEmpty);
+	// }
+
+	private readonly _onDidChangeResources = new Emitter<void>();
+	readonly onDidChangeResources: Event<void> = this._onDidChangeResources.event;
+
+	private features: SCMProviderFeatures = {};
+
+	get handle(): number { return this._handle; }
+	get label(): string { return this._label; }
+	get rootUri(): URI | undefined { return this._rootUri; }
+	get contextValue(): string { return this._contextValue; }
+
+	get commitTemplate(): string { return this.features.commitTemplate || ''; }
+	get acceptInputCommand(): Command | undefined { return this.features.acceptInputCommand; }
+	get statusBarCommands(): Command[] | undefined { return this.features.statusBarCommands; }
+	get count(): number | undefined { return this.features.count; }
+
+	private readonly _onDidChangeCommitTemplate = new Emitter<string>();
+	readonly onDidChangeCommitTemplate: Event<string> = this._onDidChangeCommitTemplate.event;
+
+	private readonly _onDidChangeStatusBarCommands = new Emitter<Command[]>();
+	get onDidChangeStatusBarCommands(): Event<Command[]> { return this._onDidChangeStatusBarCommands.event; }
+
+	private readonly _onDidChange = new Emitter<void>();
+	readonly onDidChange: Event<void> = this._onDidChange.event;
+
+	constructor(
+		private readonly proxy: ExtHostSCMShape,
+		private readonly _handle: number,
+		private readonly _contextValue: string,
+		private readonly _label: string,
+		private readonly _rootUri: URI | undefined
+	) { }
+
+	$updateSourceControl(features: SCMProviderFeatures): void {
+		this.features = { ...this.features, ...features };
+		this._onDidChange.fire();
+
+		if (typeof features.commitTemplate !== 'undefined') {
+			this._onDidChangeCommitTemplate.fire(this.commitTemplate!);
+		}
+
+		if (typeof features.statusBarCommands !== 'undefined') {
+			this._onDidChangeStatusBarCommands.fire(this.statusBarCommands!);
+		}
+	}
+
+	$registerGroups(_groups: [number /*handle*/, string /*id*/, string /*label*/, SCMGroupFeatures][]): void {
+		const groups = _groups.map(([handle, id, label, features]) => {
+			const group = new MainThreadSCMResourceGroup(
+				this.handle,
+				handle,
+				this,
+				features,
+				label,
+				id
+			);
+
+			this._groupsByHandle[handle] = group;
+			return group;
+		});
+
+		this.groups.splice(this.groups.elements.length, 0, groups);
+	}
+
+	$updateGroup(handle: number, features: SCMGroupFeatures): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		group.$updateGroup(features);
+	}
+
+	$updateGroupLabel(handle: number, label: string): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		group.$updateGroupLabel(label);
+	}
+
+	$spliceGroupResourceStates(splices: SCMRawResourceSplices[]): void {
+		for (const [groupHandle, groupSlices] of splices) {
+			const group = this._groupsByHandle[groupHandle];
+
+			if (!group) {
+				console.warn(`SCM group ${groupHandle} not found in provider ${this.label}`);
+				continue;
+			}
+
+			// reverse the splices sequence in order to apply them correctly
+			groupSlices.reverse();
+
+			for (const [start, deleteCount, rawResources] of groupSlices) {
+				const resources = rawResources.map(rawResource => {
+					const [handle, sourceUri, icons, tooltip, strikeThrough, faded, contextValue] = rawResource;
+					const icon = icons[0];
+					const iconDark = icons[1] || icon;
+					const decorations = {
+						icon: icon ? URI.revive(icon) : undefined,
+						iconDark: iconDark ? URI.revive(iconDark) : undefined,
+						tooltip,
+						strikeThrough,
+						faded
+					};
+
+					return new MainThreadSCMResource(
+						this.proxy,
+						this.handle,
+						groupHandle,
+						handle,
+						URI.revive(sourceUri),
+						group,
+						decorations,
+						contextValue || undefined
+					);
+				});
+
+				group.splice(start, deleteCount, resources);
+			}
+		}
+
+		this._onDidChangeResources.fire();
+	}
+
+	$unregisterGroup(handle: number): void {
+		const group = this._groupsByHandle[handle];
+
+		if (!group) {
+			return;
+		}
+
+		delete this._groupsByHandle[handle];
+		this.groups.splice(this.groups.elements.indexOf(group), 1);
+	}
+
+	async getOriginalResource(uri: URI): Promise<URI | null> {
+		if (!this.features.hasQuickDiffProvider) {
+			return null;
+		}
+
+		const result = await this.proxy.$provideOriginalResource(this.handle, uri, CancellationToken.None);
+		return result && URI.revive(result);
+	}
+
+	toJSON(): any {
+		return {
+			$mid: 5,
+			handle: this.handle
+		};
+	}
+
+	dispose(): void {
+
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadSCM)
+export class MainThreadSCM implements MainThreadSCMShape {
+
+	private readonly _proxy: ExtHostSCMShape;
+	private _repositories = new Map<number, ISCMRepository>();
+	private _repositoryDisposables = new Map<number, IDisposable>();
+	private readonly _disposables = new DisposableStore();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ISCMService private readonly scmService: ISCMService,
+		@ISCMViewService private readonly scmViewService: ISCMViewService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostSCM);
+	}
+
+	dispose(): void {
+		this._repositories.forEach(r => r.dispose());
+		this._repositories.clear();
+
+		this._repositoryDisposables.forEach(d => d.dispose());
+		this._repositoryDisposables.clear();
+
+		this._disposables.dispose();
+	}
+
+	$registerSourceControl(handle: number, id: string, label: string, rootUri: UriComponents | undefined): void {
+		const provider = new MainThreadSCMProvider(this._proxy, handle, id, label, rootUri ? URI.revive(rootUri) : undefined);
+		const repository = this.scmService.registerSCMProvider(provider);
+		this._repositories.set(handle, repository);
+
+		const disposable = combinedDisposable(
+			Event.filter(this.scmViewService.onDidFocusRepository, r => r === repository)(_ => this._proxy.$setSelectedSourceControl(handle)),
+			repository.input.onDidChange(({ value }) => this._proxy.$onInputBoxValueChange(handle, value))
+		);
+
+		if (this.scmViewService.focusedRepository === repository) {
+			setTimeout(() => this._proxy.$setSelectedSourceControl(handle), 0);
+		}
+
+		if (repository.input.value) {
+			setTimeout(() => this._proxy.$onInputBoxValueChange(handle, repository.input.value), 0);
+		}
+
+		this._repositoryDisposables.set(handle, disposable);
+	}
+
+	$updateSourceControl(handle: number, features: SCMProviderFeatures): void {
+		const repository = this._repositories.get(handle);
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$updateSourceControl(features);
+	}
+
+	$unregisterSourceControl(handle: number): void {
+		const repository = this._repositories.get(handle);
+
+		if (!repository) {
+			return;
+		}
+
+		this._repositoryDisposables.get(handle)!.dispose();
+		this._repositoryDisposables.delete(handle);
+
+		repository.dispose();
+		this._repositories.delete(handle);
+	}
+
+	$registerGroups(sourceControlHandle: number, groups: [number /*handle*/, string /*id*/, string /*label*/, SCMGroupFeatures][], splices: SCMRawResourceSplices[]): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$registerGroups(groups);
+		provider.$spliceGroupResourceStates(splices);
+	}
+
+	$updateGroup(sourceControlHandle: number, groupHandle: number, features: SCMGroupFeatures): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$updateGroup(groupHandle, features);
+	}
+
+	$updateGroupLabel(sourceControlHandle: number, groupHandle: number, label: string): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$updateGroupLabel(groupHandle, label);
+	}
+
+	$spliceResourceStates(sourceControlHandle: number, splices: SCMRawResourceSplices[]): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$spliceGroupResourceStates(splices);
+	}
+
+	$unregisterGroup(sourceControlHandle: number, handle: number): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		const provider = repository.provider as MainThreadSCMProvider;
+		provider.$unregisterGroup(handle);
+	}
+
+	$setInputBoxValue(sourceControlHandle: number, value: string): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		repository.input.setValue(value, false);
+	}
+
+	$setInputBoxPlaceholder(sourceControlHandle: number, placeholder: string): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		repository.input.placeholder = placeholder;
+	}
+
+	$setInputBoxVisibility(sourceControlHandle: number, visible: boolean): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		repository.input.visible = visible;
+	}
+
+	$setValidationProviderIsEnabled(sourceControlHandle: number, enabled: boolean): void {
+		const repository = this._repositories.get(sourceControlHandle);
+
+		if (!repository) {
+			return;
+		}
+
+		if (enabled) {
+			repository.input.validateInput = async (value, pos): Promise<IInputValidation | undefined> => {
+				const result = await this._proxy.$validateInput(sourceControlHandle, value, pos);
+				return result && { message: result[0], type: result[1] };
+			};
+		} else {
+			repository.input.validateInput = async () => undefined;
+		}
+	}
+}

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

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { shouldSynchronizeModel } from 'vs/editor/common/services/modelService';
+import { localize } from 'vs/nls';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { IProgressStep, IProgress } from 'vs/platform/progress/common/progress';
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ITextFileSaveParticipant, ITextFileService, ITextFileEditorModel } from 'vs/workbench/services/textfile/common/textfiles';
+import { SaveReason } from 'vs/workbench/common/editor';
+import { ExtHostContext, ExtHostDocumentSaveParticipantShape, IExtHostContext } from '../common/extHost.protocol';
+import { canceled } from 'vs/base/common/errors';
+import { IDisposable } from 'vs/base/common/lifecycle';
+
+class ExtHostSaveParticipant implements ITextFileSaveParticipant {
+
+	private readonly _proxy: ExtHostDocumentSaveParticipantShape;
+
+	constructor(extHostContext: IExtHostContext) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant);
+	}
+
+	async participate(editorModel: ITextFileEditorModel, env: { reason: SaveReason; }, _progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void> {
+
+		if (!editorModel.textEditorModel || !shouldSynchronizeModel(editorModel.textEditorModel)) {
+			// the model never made it to the extension
+			// host meaning we cannot participate in its save
+			return undefined;
+		}
+
+		return new Promise<any>((resolve, reject) => {
+
+			token.onCancellationRequested(() => reject(canceled()));
+
+			setTimeout(
+				() => reject(new Error(localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms"))),
+				1750
+			);
+			this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
+				if (!values.every(success => success)) {
+					return Promise.reject(new Error('listener failed'));
+				}
+				return undefined;
+			}).then(resolve, reject);
+		});
+	}
+}
+
+// The save participant can change a model before its saved to support various scenarios like trimming trailing whitespace
+@extHostCustomer
+export class SaveParticipant {
+
+	private _saveParticipantDisposable: IDisposable;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IInstantiationService instantiationService: IInstantiationService,
+		@ITextFileService private readonly _textFileService: ITextFileService
+	) {
+		this._saveParticipantDisposable = this._textFileService.files.addSaveParticipant(instantiationService.createInstance(ExtHostSaveParticipant, extHostContext));
+	}
+
+	dispose(): void {
+		this._saveParticipantDisposable.dispose();
+	}
+}

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

@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { dispose, IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IFileMatch, IFileQuery, IRawFileMatch2, ISearchComplete, ISearchCompleteStats, ISearchProgressItem, ISearchResultProvider, ISearchService, ITextQuery, QueryType, SearchProviderType } from 'vs/workbench/services/search/common/search';
+import { ExtHostContext, ExtHostSearchShape, IExtHostContext, MainContext, MainThreadSearchShape } from '../common/extHost.protocol';
+
+@extHostNamedCustomer(MainContext.MainThreadSearch)
+export class MainThreadSearch implements MainThreadSearchShape {
+
+	private readonly _proxy: ExtHostSearchShape;
+	private readonly _searchProvider = new Map<number, RemoteSearchProvider>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ISearchService private readonly _searchService: ISearchService,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostSearch);
+	}
+
+	dispose(): void {
+		this._searchProvider.forEach(value => value.dispose());
+		this._searchProvider.clear();
+	}
+
+	$registerTextSearchProvider(handle: number, scheme: string): void {
+		this._searchProvider.set(handle, new RemoteSearchProvider(this._searchService, SearchProviderType.text, scheme, handle, this._proxy));
+	}
+
+	$registerFileSearchProvider(handle: number, scheme: string): void {
+		this._searchProvider.set(handle, new RemoteSearchProvider(this._searchService, SearchProviderType.file, scheme, handle, this._proxy));
+	}
+
+	$unregisterProvider(handle: number): void {
+		dispose(this._searchProvider.get(handle));
+		this._searchProvider.delete(handle);
+	}
+
+	$handleFileMatch(handle: number, session: number, data: UriComponents[]): void {
+		const provider = this._searchProvider.get(handle);
+		if (!provider) {
+			throw new Error('Got result for unknown provider');
+		}
+
+		provider.handleFindMatch(session, data);
+	}
+
+	$handleTextMatch(handle: number, session: number, data: IRawFileMatch2[]): void {
+		const provider = this._searchProvider.get(handle);
+		if (!provider) {
+			throw new Error('Got result for unknown provider');
+		}
+
+		provider.handleFindMatch(session, data);
+	}
+
+	$handleTelemetry(eventName: string, data: any): void {
+		this._telemetryService.publicLog(eventName, data);
+	}
+}
+
+class SearchOperation {
+
+	private static _idPool = 0;
+
+	constructor(
+		readonly progress?: (match: IFileMatch) => any,
+		readonly id: number = ++SearchOperation._idPool,
+		readonly matches = new Map<string, IFileMatch>()
+	) {
+		//
+	}
+
+	addMatch(match: IFileMatch): void {
+		const existingMatch = this.matches.get(match.resource.toString());
+		if (existingMatch) {
+			// TODO@rob clean up text/file result types
+			// If a file search returns the same file twice, we would enter this branch.
+			// It's possible that could happen, #90813
+			if (existingMatch.results && match.results) {
+				existingMatch.results.push(...match.results);
+			}
+		} else {
+			this.matches.set(match.resource.toString(), match);
+		}
+
+		if (this.progress) {
+			this.progress(match);
+		}
+	}
+}
+
+class RemoteSearchProvider implements ISearchResultProvider, IDisposable {
+
+	private readonly _registrations = new DisposableStore();
+	private readonly _searches = new Map<number, SearchOperation>();
+
+	constructor(
+		searchService: ISearchService,
+		type: SearchProviderType,
+		private readonly _scheme: string,
+		private readonly _handle: number,
+		private readonly _proxy: ExtHostSearchShape
+	) {
+		this._registrations.add(searchService.registerSearchResultProvider(this._scheme, type, this));
+	}
+
+	dispose(): void {
+		this._registrations.dispose();
+	}
+
+	fileSearch(query: IFileQuery, token: CancellationToken = CancellationToken.None): Promise<ISearchComplete> {
+		return this.doSearch(query, undefined, token);
+	}
+
+	textSearch(query: ITextQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): Promise<ISearchComplete> {
+		return this.doSearch(query, onProgress, token);
+	}
+
+	doSearch(query: ITextQuery | IFileQuery, onProgress?: (p: ISearchProgressItem) => void, token: CancellationToken = CancellationToken.None): Promise<ISearchComplete> {
+		if (!query.folderQueries.length) {
+			throw new Error('Empty folderQueries');
+		}
+
+		const search = new SearchOperation(onProgress);
+		this._searches.set(search.id, search);
+
+		const searchP = query.type === QueryType.File
+			? this._proxy.$provideFileSearchResults(this._handle, search.id, query, token)
+			: this._proxy.$provideTextSearchResults(this._handle, search.id, query, token);
+
+		return Promise.resolve(searchP).then((result: ISearchCompleteStats) => {
+			this._searches.delete(search.id);
+			return { results: Array.from(search.matches.values()), stats: result.stats, limitHit: result.limitHit };
+		}, err => {
+			this._searches.delete(search.id);
+			return Promise.reject(err);
+		});
+	}
+
+	clearCache(cacheKey: string): Promise<void> {
+		return Promise.resolve(this._proxy.$clearCache(cacheKey));
+	}
+
+	handleFindMatch(session: number, dataOrUri: Array<UriComponents | IRawFileMatch2>): void {
+		const searchOp = this._searches.get(session);
+
+		if (!searchOp) {
+			// ignore...
+			return;
+		}
+
+		dataOrUri.forEach(result => {
+			if ((<IRawFileMatch2>result).results) {
+				searchOp.addMatch({
+					resource: URI.revive((<IRawFileMatch2>result).resource),
+					results: (<IRawFileMatch2>result).results
+				});
+			} else {
+				searchOp.addMatch({
+					resource: URI.revive(<UriComponents>result)
+				});
+			}
+		});
+	}
+}

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

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IStatusbarService, StatusbarAlignment as MainThreadStatusBarAlignment, IStatusbarEntryAccessor, IStatusbarEntry } from 'vs/workbench/services/statusbar/common/statusbar';
+import { MainThreadStatusBarShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { ThemeColor } from 'vs/platform/theme/common/themeService';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { dispose } from 'vs/base/common/lifecycle';
+import { Command } from 'vs/editor/common/modes';
+import { IAccessibilityInformation } from 'vs/platform/accessibility/common/accessibility';
+
+@extHostNamedCustomer(MainContext.MainThreadStatusBar)
+export class MainThreadStatusBar implements MainThreadStatusBarShape {
+
+	private readonly entries: Map<number, { accessor: IStatusbarEntryAccessor, alignment: MainThreadStatusBarAlignment, priority: number }> = new Map();
+	static readonly CODICON_REGEXP = /\$\((.*?)\)/g;
+
+	constructor(
+		_extHostContext: IExtHostContext,
+		@IStatusbarService private readonly statusbarService: IStatusbarService
+	) { }
+
+	dispose(): void {
+		this.entries.forEach(entry => entry.accessor.dispose());
+		this.entries.clear();
+	}
+
+	$setEntry(id: number, statusId: string, statusName: string, text: string, tooltip: string | undefined, command: Command | undefined, color: string | ThemeColor | undefined, alignment: MainThreadStatusBarAlignment, priority: number | undefined, accessibilityInformation: IAccessibilityInformation): void {
+		// if there are icons in the text use the tooltip for the aria label
+		let ariaLabel: string;
+		let role: string | undefined = undefined;
+		if (accessibilityInformation) {
+			ariaLabel = accessibilityInformation.label;
+			role = accessibilityInformation.role;
+		} else {
+			ariaLabel = text ? text.replace(MainThreadStatusBar.CODICON_REGEXP, (_match, codiconName) => codiconName) : '';
+		}
+		const entry: IStatusbarEntry = { text, tooltip, command, color, ariaLabel, role };
+
+		if (typeof priority === 'undefined') {
+			priority = 0;
+		}
+
+		// Reset existing entry if alignment or priority changed
+		let existingEntry = this.entries.get(id);
+		if (existingEntry && (existingEntry.alignment !== alignment || existingEntry.priority !== priority)) {
+			dispose(existingEntry.accessor);
+			this.entries.delete(id);
+			existingEntry = undefined;
+		}
+
+		// Create new entry if not existing
+		if (!existingEntry) {
+			this.entries.set(id, { accessor: this.statusbarService.addEntry(entry, statusId, statusName, alignment, priority), alignment, priority });
+		}
+
+		// Otherwise update
+		else {
+			existingEntry.accessor.update(entry);
+		}
+	}
+
+	$dispose(id: number) {
+		const entry = this.entries.get(id);
+		if (entry) {
+			dispose(entry.accessor);
+			this.entries.delete(id);
+		}
+	}
+}

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

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { MainThreadStorageShape, MainContext, IExtHostContext, ExtHostStorageShape, ExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IExtensionIdWithVersion, IStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
+
+@extHostNamedCustomer(MainContext.MainThreadStorage)
+export class MainThreadStorage implements MainThreadStorageShape {
+
+	private readonly _storageService: IStorageService;
+	private readonly _storageKeysSyncRegistryService: IStorageKeysSyncRegistryService;
+	private readonly _proxy: ExtHostStorageShape;
+	private readonly _storageListener: IDisposable;
+	private readonly _sharedStorageKeysToWatch: Map<string, boolean> = new Map<string, boolean>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IStorageService storageService: IStorageService,
+		@IStorageKeysSyncRegistryService storageKeysSyncRegistryService: IStorageKeysSyncRegistryService,
+	) {
+		this._storageService = storageService;
+		this._storageKeysSyncRegistryService = storageKeysSyncRegistryService;
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostStorage);
+
+		this._storageListener = this._storageService.onDidChangeStorage(e => {
+			const shared = e.scope === StorageScope.GLOBAL;
+			if (shared && this._sharedStorageKeysToWatch.has(e.key)) {
+				try {
+					this._proxy.$acceptValue(shared, e.key, this._getValue(shared, e.key));
+				} catch (error) {
+					// ignore parsing errors that can happen
+				}
+			}
+		});
+	}
+
+	dispose(): void {
+		this._storageListener.dispose();
+	}
+
+	$getValue<T>(shared: boolean, key: string): Promise<T | undefined> {
+		if (shared) {
+			this._sharedStorageKeysToWatch.set(key, true);
+		}
+		try {
+			return Promise.resolve(this._getValue<T>(shared, key));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+
+	private _getValue<T>(shared: boolean, key: string): T | undefined {
+		const jsonValue = this._storageService.get(key, shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE);
+		if (!jsonValue) {
+			return undefined;
+		}
+		return JSON.parse(jsonValue);
+	}
+
+	$setValue(shared: boolean, key: string, value: object): Promise<void> {
+		let jsonValue: string;
+		try {
+			jsonValue = JSON.stringify(value);
+			this._storageService.store(key, jsonValue, shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE);
+		} catch (err) {
+			return Promise.reject(err);
+		}
+		return Promise.resolve(undefined);
+	}
+
+	$registerExtensionStorageKeysToSync(extension: IExtensionIdWithVersion, keys: string[]): void {
+		this._storageKeysSyncRegistryService.registerExtensionStorageKeys(extension, keys);
+	}
+}

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

@@ -0,0 +1,712 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { generateUuid } from 'vs/base/common/uuid';
+import * as Types from 'vs/base/common/types';
+import * as Platform from 'vs/base/common/platform';
+import { IStringDictionary, forEach } from 'vs/base/common/collections';
+import { IDisposable } from 'vs/base/common/lifecycle';
+
+import { IWorkspace, IWorkspaceContextService, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
+
+import {
+	ContributedTask, ConfiguringTask, KeyedTaskIdentifier, TaskExecution, Task, TaskEvent, TaskEventKind,
+	PresentationOptions, CommandOptions, CommandConfiguration, RuntimeType, CustomTask, TaskScope, TaskSource,
+	TaskSourceKind, ExtensionTaskSource, RunOptions, TaskSet, TaskDefinition
+} from 'vs/workbench/contrib/tasks/common/tasks';
+
+
+import { ResolveSet, ResolvedVariables } from 'vs/workbench/contrib/tasks/common/taskSystem';
+import { ITaskService, TaskFilter, ITaskProvider } from 'vs/workbench/contrib/tasks/common/taskService';
+
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, MainThreadTaskShape, ExtHostTaskShape, MainContext, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import {
+	TaskDefinitionDTO, TaskExecutionDTO, ProcessExecutionOptionsDTO, TaskPresentationOptionsDTO,
+	ProcessExecutionDTO, ShellExecutionDTO, ShellExecutionOptionsDTO, CustomExecutionDTO, TaskDTO, TaskSourceDTO, TaskHandleDTO, TaskFilterDTO, TaskProcessStartedDTO, TaskProcessEndedDTO, TaskSystemInfoDTO,
+	RunOptionsDTO
+} from 'vs/workbench/api/common/shared/tasks';
+import { IConfigurationResolverService } from 'vs/workbench/services/configurationResolver/common/configurationResolver';
+import { ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
+
+namespace TaskExecutionDTO {
+	export function from(value: TaskExecution): TaskExecutionDTO {
+		return {
+			id: value.id,
+			task: TaskDTO.from(value.task)
+		};
+	}
+}
+
+namespace TaskProcessStartedDTO {
+	export function from(value: TaskExecution, processId: number): TaskProcessStartedDTO {
+		return {
+			id: value.id,
+			processId
+		};
+	}
+}
+
+namespace TaskProcessEndedDTO {
+	export function from(value: TaskExecution, exitCode: number): TaskProcessEndedDTO {
+		return {
+			id: value.id,
+			exitCode
+		};
+	}
+}
+
+namespace TaskDefinitionDTO {
+	export function from(value: KeyedTaskIdentifier): TaskDefinitionDTO {
+		const result = Object.assign(Object.create(null), value);
+		delete result._key;
+		return result;
+	}
+	export function to(value: TaskDefinitionDTO, executeOnly: boolean): KeyedTaskIdentifier | undefined {
+		let result = TaskDefinition.createTaskIdentifier(value, console);
+		if (result === undefined && executeOnly) {
+			result = {
+				_key: generateUuid(),
+				type: '$executeOnly'
+			};
+		}
+		return result;
+	}
+}
+
+namespace TaskPresentationOptionsDTO {
+	export function from(value: PresentationOptions | undefined): TaskPresentationOptionsDTO | undefined {
+		if (value === undefined || value === null) {
+			return undefined;
+		}
+		return Object.assign(Object.create(null), value);
+	}
+	export function to(value: TaskPresentationOptionsDTO | undefined): PresentationOptions {
+		if (value === undefined || value === null) {
+			return PresentationOptions.defaults;
+		}
+		return Object.assign(Object.create(null), PresentationOptions.defaults, value);
+	}
+}
+
+namespace RunOptionsDTO {
+	export function from(value: RunOptions): RunOptionsDTO | undefined {
+		if (value === undefined || value === null) {
+			return undefined;
+		}
+		return Object.assign(Object.create(null), value);
+	}
+	export function to(value: RunOptionsDTO | undefined): RunOptions {
+		if (value === undefined || value === null) {
+			return RunOptions.defaults;
+		}
+		return Object.assign(Object.create(null), RunOptions.defaults, value);
+	}
+}
+
+namespace ProcessExecutionOptionsDTO {
+	export function from(value: CommandOptions): ProcessExecutionOptionsDTO | undefined {
+		if (value === undefined || value === null) {
+			return undefined;
+		}
+		return {
+			cwd: value.cwd,
+			env: value.env
+		};
+	}
+	export function to(value: ProcessExecutionOptionsDTO | undefined): CommandOptions {
+		if (value === undefined || value === null) {
+			return CommandOptions.defaults;
+		}
+		return {
+			cwd: value.cwd || CommandOptions.defaults.cwd,
+			env: value.env
+		};
+	}
+}
+
+namespace ProcessExecutionDTO {
+	export function is(value: ShellExecutionDTO | ProcessExecutionDTO | CustomExecutionDTO): value is ProcessExecutionDTO {
+		const candidate = value as ProcessExecutionDTO;
+		return candidate && !!candidate.process;
+	}
+	export function from(value: CommandConfiguration): ProcessExecutionDTO {
+		const process: string = Types.isString(value.name) ? value.name : value.name!.value;
+		const args: string[] = value.args ? value.args.map(value => Types.isString(value) ? value : value.value) : [];
+		const result: ProcessExecutionDTO = {
+			process: process,
+			args: args
+		};
+		if (value.options) {
+			result.options = ProcessExecutionOptionsDTO.from(value.options);
+		}
+		return result;
+	}
+	export function to(value: ProcessExecutionDTO): CommandConfiguration {
+		const result: CommandConfiguration = {
+			runtime: RuntimeType.Process,
+			name: value.process,
+			args: value.args,
+			presentation: undefined
+		};
+		result.options = ProcessExecutionOptionsDTO.to(value.options);
+		return result;
+	}
+}
+
+namespace ShellExecutionOptionsDTO {
+	export function from(value: CommandOptions): ShellExecutionOptionsDTO | undefined {
+		if (value === undefined || value === null) {
+			return undefined;
+		}
+		const result: ShellExecutionOptionsDTO = {
+			cwd: value.cwd || CommandOptions.defaults.cwd,
+			env: value.env
+		};
+		if (value.shell) {
+			result.executable = value.shell.executable;
+			result.shellArgs = value.shell.args;
+			result.shellQuoting = value.shell.quoting;
+		}
+		return result;
+	}
+	export function to(value: ShellExecutionOptionsDTO): CommandOptions | undefined {
+		if (value === undefined || value === null) {
+			return undefined;
+		}
+		const result: CommandOptions = {
+			cwd: value.cwd,
+			env: value.env
+		};
+		if (value.executable) {
+			result.shell = {
+				executable: value.executable
+			};
+			if (value.shellArgs) {
+				result.shell.args = value.shellArgs;
+			}
+			if (value.shellQuoting) {
+				result.shell.quoting = value.shellQuoting;
+			}
+		}
+		return result;
+	}
+}
+
+namespace ShellExecutionDTO {
+	export function is(value: ShellExecutionDTO | ProcessExecutionDTO | CustomExecutionDTO): value is ShellExecutionDTO {
+		const candidate = value as ShellExecutionDTO;
+		return candidate && (!!candidate.commandLine || !!candidate.command);
+	}
+	export function from(value: CommandConfiguration): ShellExecutionDTO {
+		const result: ShellExecutionDTO = {};
+		if (value.name && Types.isString(value.name) && (value.args === undefined || value.args === null || value.args.length === 0)) {
+			result.commandLine = value.name;
+		} else {
+			result.command = value.name;
+			result.args = value.args;
+		}
+		if (value.options) {
+			result.options = ShellExecutionOptionsDTO.from(value.options);
+		}
+		return result;
+	}
+	export function to(value: ShellExecutionDTO): CommandConfiguration {
+		const result: CommandConfiguration = {
+			runtime: RuntimeType.Shell,
+			name: value.commandLine ? value.commandLine : value.command,
+			args: value.args,
+			presentation: undefined
+		};
+		if (value.options) {
+			result.options = ShellExecutionOptionsDTO.to(value.options);
+		}
+		return result;
+	}
+}
+
+namespace CustomExecutionDTO {
+	export function is(value: ShellExecutionDTO | ProcessExecutionDTO | CustomExecutionDTO): value is CustomExecutionDTO {
+		const candidate = value as CustomExecutionDTO;
+		return candidate && candidate.customExecution === 'customExecution';
+	}
+
+	export function from(value: CommandConfiguration): CustomExecutionDTO {
+		return {
+			customExecution: 'customExecution'
+		};
+	}
+
+	export function to(value: CustomExecutionDTO): CommandConfiguration {
+		return {
+			runtime: RuntimeType.CustomExecution,
+			presentation: undefined
+		};
+	}
+}
+
+namespace TaskSourceDTO {
+	export function from(value: TaskSource): TaskSourceDTO {
+		const result: TaskSourceDTO = {
+			label: value.label
+		};
+		if (value.kind === TaskSourceKind.Extension) {
+			result.extensionId = value.extension;
+			if (value.workspaceFolder) {
+				result.scope = value.workspaceFolder.uri;
+			} else {
+				result.scope = value.scope;
+			}
+		} else if (value.kind === TaskSourceKind.Workspace) {
+			result.extensionId = '$core';
+			result.scope = value.config.workspaceFolder ? value.config.workspaceFolder.uri : TaskScope.Global;
+		}
+		return result;
+	}
+	export function to(value: TaskSourceDTO, workspace: IWorkspaceContextService): ExtensionTaskSource {
+		let scope: TaskScope;
+		let workspaceFolder: IWorkspaceFolder | undefined;
+		if ((value.scope === undefined) || ((typeof value.scope === 'number') && (value.scope !== TaskScope.Global))) {
+			if (workspace.getWorkspace().folders.length === 0) {
+				scope = TaskScope.Global;
+				workspaceFolder = undefined;
+			} else {
+				scope = TaskScope.Folder;
+				workspaceFolder = workspace.getWorkspace().folders[0];
+			}
+		} else if (typeof value.scope === 'number') {
+			scope = value.scope;
+		} else {
+			scope = TaskScope.Folder;
+			workspaceFolder = Types.withNullAsUndefined(workspace.getWorkspaceFolder(URI.revive(value.scope)));
+		}
+		const result: ExtensionTaskSource = {
+			kind: TaskSourceKind.Extension,
+			label: value.label,
+			extension: value.extensionId,
+			scope,
+			workspaceFolder
+		};
+		return result;
+	}
+}
+
+namespace TaskHandleDTO {
+	export function is(value: any): value is TaskHandleDTO {
+		const candidate: TaskHandleDTO = value;
+		return candidate && Types.isString(candidate.id) && !!candidate.workspaceFolder;
+	}
+}
+
+namespace TaskDTO {
+	export function from(task: Task | ConfiguringTask): TaskDTO | undefined {
+		if (task === undefined || task === null || (!CustomTask.is(task) && !ContributedTask.is(task) && !ConfiguringTask.is(task))) {
+			return undefined;
+		}
+		const result: TaskDTO = {
+			_id: task._id,
+			name: task.configurationProperties.name,
+			definition: TaskDefinitionDTO.from(task.getDefinition(true)),
+			source: TaskSourceDTO.from(task._source),
+			execution: undefined,
+			presentationOptions: !ConfiguringTask.is(task) && task.command ? TaskPresentationOptionsDTO.from(task.command.presentation) : undefined,
+			isBackground: task.configurationProperties.isBackground,
+			problemMatchers: [],
+			hasDefinedMatchers: ContributedTask.is(task) ? task.hasDefinedMatchers : false,
+			runOptions: RunOptionsDTO.from(task.runOptions),
+		};
+		if (task.configurationProperties.group) {
+			result.group = task.configurationProperties.group;
+		}
+		if (task.configurationProperties.detail) {
+			result.detail = task.configurationProperties.detail;
+		}
+		if (!ConfiguringTask.is(task) && task.command) {
+			switch (task.command.runtime) {
+				case RuntimeType.Process: result.execution = ProcessExecutionDTO.from(task.command); break;
+				case RuntimeType.Shell: result.execution = ShellExecutionDTO.from(task.command); break;
+				case RuntimeType.CustomExecution: result.execution = CustomExecutionDTO.from(task.command); break;
+			}
+		}
+		if (task.configurationProperties.problemMatchers) {
+			for (let matcher of task.configurationProperties.problemMatchers) {
+				if (Types.isString(matcher)) {
+					result.problemMatchers.push(matcher);
+				}
+			}
+		}
+		return result;
+	}
+
+	export function to(task: TaskDTO | undefined, workspace: IWorkspaceContextService, executeOnly: boolean): ContributedTask | undefined {
+		if (!task || (typeof task.name !== 'string')) {
+			return undefined;
+		}
+
+		let command: CommandConfiguration | undefined;
+		if (task.execution) {
+			if (ShellExecutionDTO.is(task.execution)) {
+				command = ShellExecutionDTO.to(task.execution);
+			} else if (ProcessExecutionDTO.is(task.execution)) {
+				command = ProcessExecutionDTO.to(task.execution);
+			} else if (CustomExecutionDTO.is(task.execution)) {
+				command = CustomExecutionDTO.to(task.execution);
+			}
+		}
+
+		if (!command) {
+			return undefined;
+		}
+		command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
+		const source = TaskSourceDTO.to(task.source, workspace);
+
+		const label = nls.localize('task.label', '{0}: {1}', source.label, task.name);
+		const definition = TaskDefinitionDTO.to(task.definition, executeOnly)!;
+		const id = (CustomExecutionDTO.is(task.execution!) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
+		const result: ContributedTask = new ContributedTask(
+			id, // uuidMap.getUUID(identifier)
+			source,
+			label,
+			definition.type,
+			definition,
+			command,
+			task.hasDefinedMatchers,
+			RunOptionsDTO.to(task.runOptions),
+			{
+				name: task.name,
+				identifier: label,
+				group: task.group,
+				isBackground: !!task.isBackground,
+				problemMatchers: task.problemMatchers.slice(),
+				detail: task.detail
+			}
+		);
+		return result;
+	}
+}
+
+namespace TaskFilterDTO {
+	export function from(value: TaskFilter): TaskFilterDTO {
+		return value;
+	}
+	export function to(value: TaskFilterDTO | undefined): TaskFilter | undefined {
+		return value;
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadTask)
+export class MainThreadTask implements MainThreadTaskShape {
+
+	private readonly _extHostContext: IExtHostContext | undefined;
+	private readonly _proxy: ExtHostTaskShape;
+	private readonly _providers: Map<number, { disposable: IDisposable, provider: ITaskProvider }>;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ITaskService private readonly _taskService: ITaskService,
+		@IWorkspaceContextService private readonly _workspaceContextServer: IWorkspaceContextService,
+		@IConfigurationResolverService private readonly _configurationResolverService: IConfigurationResolverService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTask);
+		this._providers = new Map();
+		this._taskService.onDidStateChange(async (event: TaskEvent) => {
+			const task = event.__task!;
+			if (event.kind === TaskEventKind.Start) {
+				const execution = TaskExecutionDTO.from(task.getTaskExecution());
+				let resolvedDefinition: TaskDefinitionDTO = execution.task!.definition;
+				if (execution.task?.execution && CustomExecutionDTO.is(execution.task.execution) && event.resolvedVariables) {
+					const dictionary: IStringDictionary<string> = {};
+					Array.from(event.resolvedVariables.entries()).forEach(entry => dictionary[entry[0]] = entry[1]);
+					resolvedDefinition = await this._configurationResolverService.resolveAny(task.getWorkspaceFolder(),
+						execution.task.definition, dictionary);
+				}
+				this._proxy.$onDidStartTask(execution, event.terminalId!, resolvedDefinition);
+			} else if (event.kind === TaskEventKind.ProcessStarted) {
+				this._proxy.$onDidStartTaskProcess(TaskProcessStartedDTO.from(task.getTaskExecution(), event.processId!));
+			} else if (event.kind === TaskEventKind.ProcessEnded) {
+				this._proxy.$onDidEndTaskProcess(TaskProcessEndedDTO.from(task.getTaskExecution(), event.exitCode!));
+			} else if (event.kind === TaskEventKind.End) {
+				this._proxy.$OnDidEndTask(TaskExecutionDTO.from(task.getTaskExecution()));
+			}
+		});
+	}
+
+	public dispose(): void {
+		this._providers.forEach((value) => {
+			value.disposable.dispose();
+		});
+		this._providers.clear();
+	}
+
+	$createTaskId(taskDTO: TaskDTO): Promise<string> {
+		return new Promise((resolve, reject) => {
+			let task = TaskDTO.to(taskDTO, this._workspaceContextServer, true);
+			if (task) {
+				resolve(task._id);
+			} else {
+				reject(new Error('Task could not be created from DTO'));
+			}
+		});
+	}
+
+	public $registerTaskProvider(handle: number, type: string): Promise<void> {
+		const provider: ITaskProvider = {
+			provideTasks: (validTypes: IStringDictionary<boolean>) => {
+				return Promise.resolve(this._proxy.$provideTasks(handle, validTypes)).then((value) => {
+					const tasks: Task[] = [];
+					for (let dto of value.tasks) {
+						const task = TaskDTO.to(dto, this._workspaceContextServer, true);
+						if (task) {
+							tasks.push(task);
+						} else {
+							console.error(`Task System: can not convert task: ${JSON.stringify(dto.definition, undefined, 0)}. Task will be dropped`);
+						}
+					}
+					return {
+						tasks,
+						extension: value.extension
+					} as TaskSet;
+				});
+			},
+			resolveTask: (task: ConfiguringTask) => {
+				const dto = TaskDTO.from(task);
+
+				if (dto) {
+					dto.name = ((dto.name === undefined) ? '' : dto.name); // Using an empty name causes the name to default to the one given by the provider.
+					return Promise.resolve(this._proxy.$resolveTask(handle, dto)).then(resolvedTask => {
+						if (resolvedTask) {
+							return TaskDTO.to(resolvedTask, this._workspaceContextServer, true);
+						}
+
+						return undefined;
+					});
+				}
+				return Promise.resolve<ContributedTask | undefined>(undefined);
+			}
+		};
+		const disposable = this._taskService.registerTaskProvider(provider, type);
+		this._providers.set(handle, { disposable, provider });
+		return Promise.resolve(undefined);
+	}
+
+	public $unregisterTaskProvider(handle: number): Promise<void> {
+		const provider = this._providers.get(handle);
+		if (provider) {
+			provider.disposable.dispose();
+			this._providers.delete(handle);
+		}
+		return Promise.resolve(undefined);
+	}
+
+	public $fetchTasks(filter?: TaskFilterDTO): Promise<TaskDTO[]> {
+		return this._taskService.tasks(TaskFilterDTO.to(filter)).then((tasks) => {
+			const result: TaskDTO[] = [];
+			for (let task of tasks) {
+				const item = TaskDTO.from(task);
+				if (item) {
+					result.push(item);
+				}
+			}
+			return result;
+		});
+	}
+
+	private getWorkspace(value: UriComponents | string): string | IWorkspace | IWorkspaceFolder | null {
+		let workspace;
+		if (typeof value === 'string') {
+			workspace = value;
+		} else {
+			const workspaceObject = this._workspaceContextServer.getWorkspace();
+			const uri = URI.revive(value);
+			if (workspaceObject.configuration?.toString() === uri.toString()) {
+				workspace = workspaceObject;
+			} else {
+				workspace = this._workspaceContextServer.getWorkspaceFolder(uri);
+			}
+		}
+		return workspace;
+	}
+
+	public async $getTaskExecution(value: TaskHandleDTO | TaskDTO): Promise<TaskExecutionDTO> {
+		if (TaskHandleDTO.is(value)) {
+			const workspace = this.getWorkspace(value.workspaceFolder);
+			if (workspace) {
+				const task = await this._taskService.getTask(workspace, value.id, true);
+				if (task) {
+					return {
+						id: task._id,
+						task: TaskDTO.from(task)
+					};
+				}
+				throw new Error('Task not found');
+			} else {
+				throw new Error('No workspace folder');
+			}
+		} else {
+			const task = TaskDTO.to(value, this._workspaceContextServer, true)!;
+			return {
+				id: task._id,
+				task: TaskDTO.from(task)
+			};
+		}
+	}
+
+	// Passing in a TaskHandleDTO will cause the task to get re-resolved, which is important for tasks are coming from the core,
+	// such as those gotten from a fetchTasks, since they can have missing configuration properties.
+	public $executeTask(value: TaskHandleDTO | TaskDTO): Promise<TaskExecutionDTO> {
+		return new Promise<TaskExecutionDTO>((resolve, reject) => {
+			if (TaskHandleDTO.is(value)) {
+				const workspace = this.getWorkspace(value.workspaceFolder);
+				if (workspace) {
+					this._taskService.getTask(workspace, value.id, true).then((task: Task | undefined) => {
+						if (!task) {
+							reject(new Error('Task not found'));
+						} else {
+							this._taskService.run(task).then(undefined, reason => {
+								// eat the error, it has already been surfaced to the user and we don't care about it here
+							});
+							const result: TaskExecutionDTO = {
+								id: value.id,
+								task: TaskDTO.from(task)
+							};
+							resolve(result);
+						}
+					}, (_error) => {
+						reject(new Error('Task not found'));
+					});
+				} else {
+					reject(new Error('No workspace folder'));
+				}
+			} else {
+				const task = TaskDTO.to(value, this._workspaceContextServer, true)!;
+				this._taskService.run(task).then(undefined, reason => {
+					// eat the error, it has already been surfaced to the user and we don't care about it here
+				});
+				const result: TaskExecutionDTO = {
+					id: task._id,
+					task: TaskDTO.from(task)
+				};
+				resolve(result);
+			}
+		});
+	}
+
+
+	public $customExecutionComplete(id: string, result?: number): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			this._taskService.getActiveTasks().then((tasks) => {
+				for (let task of tasks) {
+					if (id === task._id) {
+						this._taskService.extensionCallbackTaskComplete(task, result).then((value) => {
+							resolve(undefined);
+						}, (error) => {
+							reject(error);
+						});
+						return;
+					}
+				}
+				reject(new Error('Task to mark as complete not found'));
+			});
+		});
+	}
+
+	public $terminateTask(id: string): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			this._taskService.getActiveTasks().then((tasks) => {
+				for (let task of tasks) {
+					if (id === task._id) {
+						this._taskService.terminate(task).then((value) => {
+							resolve(undefined);
+						}, (error) => {
+							reject(undefined);
+						});
+						return;
+					}
+				}
+				reject(new Error('Task to terminate not found'));
+			});
+		});
+	}
+
+	public $registerTaskSystem(key: string, info: TaskSystemInfoDTO): void {
+		let platform: Platform.Platform;
+		switch (info.platform) {
+			case 'Web':
+				platform = Platform.Platform.Web;
+				break;
+			case 'win32':
+				platform = Platform.Platform.Windows;
+				break;
+			case 'darwin':
+				platform = Platform.Platform.Mac;
+				break;
+			case 'linux':
+				platform = Platform.Platform.Linux;
+				break;
+			default:
+				platform = Platform.platform;
+		}
+		this._taskService.registerTaskSystem(key, {
+			platform: platform,
+			uriProvider: (path: string): URI => {
+				return URI.parse(`${info.scheme}://${info.authority}${path}`);
+			},
+			context: this._extHostContext,
+			resolveVariables: (workspaceFolder: IWorkspaceFolder, toResolve: ResolveSet, target: ConfigurationTarget): Promise<ResolvedVariables | undefined> => {
+				const vars: string[] = [];
+				toResolve.variables.forEach(item => vars.push(item));
+				return Promise.resolve(this._proxy.$resolveVariables(workspaceFolder.uri, { process: toResolve.process, variables: vars })).then(values => {
+					const partiallyResolvedVars = new Array<string>();
+					forEach(values.variables, (entry) => {
+						partiallyResolvedVars.push(entry.value);
+					});
+					return new Promise<ResolvedVariables | undefined>((resolve, reject) => {
+						this._configurationResolverService.resolveWithInteraction(workspaceFolder, partiallyResolvedVars, 'tasks', undefined, target).then(resolvedVars => {
+							if (!resolvedVars) {
+								resolve(undefined);
+							}
+
+							const result: ResolvedVariables = {
+								process: undefined,
+								variables: new Map<string, string>()
+							};
+							for (let i = 0; i < partiallyResolvedVars.length; i++) {
+								const variableName = vars[i].substring(2, vars[i].length - 1);
+								if (resolvedVars && values.variables[vars[i]] === vars[i]) {
+									const resolved = resolvedVars.get(variableName);
+									if (typeof resolved === 'string') {
+										result.variables.set(variableName, resolved);
+									}
+								} else {
+									result.variables.set(variableName, partiallyResolvedVars[i]);
+								}
+							}
+							if (Types.isString(values.process)) {
+								result.process = values.process;
+							}
+							resolve(result);
+						}, reason => {
+							reject(reason);
+						});
+					});
+				});
+			},
+			getDefaultShellAndArgs: (): Promise<{ shell: string, args: string[] | string | undefined }> => {
+				return Promise.resolve(this._proxy.$getDefaultShellAndArgs());
+			},
+			findExecutable: (command: string, cwd?: string, paths?: string[]): Promise<string | undefined> => {
+				return this._proxy.$findExecutable(command, cwd, paths);
+			}
+		});
+	}
+
+	async $registerSupportedExecutions(custom?: boolean, shell?: boolean, process?: boolean): Promise<void> {
+		return this._taskService.registerSupportedExecutions(custom, shell, process);
+	}
+
+}

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

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { MainThreadTelemetryShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ClassifiedEvent, StrictPropertyCheck, GDPRClassification } from 'vs/platform/telemetry/common/gdprTypings';
+
+@extHostNamedCustomer(MainContext.MainThreadTelemetry)
+export class MainThreadTelemetry implements MainThreadTelemetryShape {
+
+	private static readonly _name = 'pluginHostTelemetry';
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService
+	) {
+		//
+	}
+
+	dispose(): void {
+		//
+	}
+
+	$publicLog(eventName: string, data: any = Object.create(null)): void {
+		// __GDPR__COMMON__ "pluginHostTelemetry" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true }
+		data[MainThreadTelemetry._name] = true;
+		this._telemetryService.publicLog(eventName, data);
+	}
+
+	$publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data: StrictPropertyCheck<T, E>): void {
+		this.$publicLog(eventName, data as any);
+	}
+}
+
+

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

@@ -0,0 +1,430 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  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 { IShellLaunchConfig, ITerminalProcessExtHostProxy, ISpawnExtHostProcessRequest, ITerminalDimensions, EXT_HOST_CREATION_DELAY, IAvailableShellsRequest, IDefaultShellAndArgsRequest, IStartExtensionTerminalRequest } from 'vs/workbench/contrib/terminal/common/terminal';
+import { ExtHostContext, ExtHostTerminalServiceShape, MainThreadTerminalServiceShape, MainContext, IExtHostContext, IShellLaunchConfigDto, TerminalLaunchConfig, ITerminalDimensionsDto } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { URI } from 'vs/base/common/uri';
+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 { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { TerminalDataBufferer } from 'vs/workbench/contrib/terminal/common/terminalDataBuffering';
+import { IEnvironmentVariableService, ISerializableEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariable';
+import { deserializeEnvironmentVariableCollection, serializeEnvironmentVariableCollection } from 'vs/workbench/contrib/terminal/common/environmentVariableShared';
+import { ILogService } from 'vs/platform/log/common/log';
+
+@extHostNamedCustomer(MainContext.MainThreadTerminalService)
+export class MainThreadTerminalService implements MainThreadTerminalServiceShape {
+
+	private _proxy: ExtHostTerminalServiceShape;
+	private _remoteAuthority: string | null;
+	private readonly _toDispose = new DisposableStore();
+	private readonly _terminalProcessProxies = new Map<number, ITerminalProcessExtHostProxy>();
+	private _dataEventTracker: TerminalDataEventTracker | undefined;
+	/**
+	 * 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
+	 * provided through this, even from multiple ext link providers. Xterm should remove lower
+	 * priority intersecting links itself.
+	 */
+	private _linkProvider: IDisposable | undefined;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ITerminalService private readonly _terminalService: ITerminalService,
+		@ITerminalInstanceService readonly terminalInstanceService: ITerminalInstanceService,
+		@IRemoteAgentService private readonly _remoteAgentService: IRemoteAgentService,
+		@IInstantiationService private readonly _instantiationService: IInstantiationService,
+		@IEnvironmentVariableService private readonly _environmentVariableService: IEnvironmentVariableService,
+		@ILogService private readonly _logService: ILogService,
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTerminalService);
+		this._remoteAuthority = extHostContext.remoteAuthority;
+
+		// ITerminalService listeners
+		this._toDispose.add(_terminalService.onInstanceCreated((instance) => {
+			// Delay this message so the TerminalInstance constructor has a chance to finish and
+			// return the ID normally to the extension host. The ID that is passed here will be
+			// used to register non-extension API terminals in the extension host.
+			setTimeout(() => {
+				this._onTerminalOpened(instance);
+				this._onInstanceDimensionsChanged(instance);
+			}, EXT_HOST_CREATION_DELAY);
+		}));
+
+		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.configHelper.onWorkspacePermissionsChanged(isAllowed => this._onWorkspacePermissionsChanged(isAllowed)));
+		this._toDispose.add(_terminalService.onRequestAvailableShells(e => this._onRequestAvailableShells(e)));
+
+		// ITerminalInstanceService listeners
+		if (terminalInstanceService.onRequestDefaultShellAndArgs) {
+			this._toDispose.add(terminalInstanceService.onRequestDefaultShellAndArgs(e => this._onRequestDefaultShellAndArgs(e)));
+		}
+
+		// Set initial ext host state
+		this._terminalService.terminalInstances.forEach(t => {
+			this._onTerminalOpened(t);
+			t.processReady.then(() => this._onTerminalProcessIdReady(t));
+		});
+		const activeInstance = this._terminalService.getActiveInstance();
+		if (activeInstance) {
+			this._proxy.$acceptActiveTerminalChanged(activeInstance.id);
+		}
+		if (this._environmentVariableService.collections.size > 0) {
+			const collectionAsArray = [...this._environmentVariableService.collections.entries()];
+			const serializedCollections: [string, ISerializableEnvironmentVariableCollection][] = collectionAsArray.map(e => {
+				return [e[0], serializeEnvironmentVariableCollection(e[1].map)];
+			});
+			this._proxy.$initEnvironmentVariableCollections(serializedCollections);
+		}
+
+		this._terminalService.extHostReady(extHostContext.remoteAuthority!); // TODO@Tyriar: remove null assertion
+	}
+
+	public dispose(): void {
+		this._toDispose.dispose();
+		this._linkProvider?.dispose();
+
+		// TODO@Daniel: Should all the previously created terminals be disposed
+		// when the extension host process goes down ?
+	}
+
+	public $createTerminal(launchConfig: TerminalLaunchConfig): Promise<{ id: number, name: string }> {
+		const shellLaunchConfig: IShellLaunchConfig = {
+			name: launchConfig.name,
+			executable: launchConfig.shellPath,
+			args: launchConfig.shellArgs,
+			cwd: typeof launchConfig.cwd === 'string' ? launchConfig.cwd : URI.revive(launchConfig.cwd),
+			waitOnExit: launchConfig.waitOnExit,
+			ignoreConfigurationCwd: true,
+			env: launchConfig.env,
+			strictEnv: launchConfig.strictEnv,
+			hideFromUser: launchConfig.hideFromUser,
+			isExtensionTerminal: launchConfig.isExtensionTerminal,
+			isFeatureTerminal: launchConfig.isFeatureTerminal
+		};
+		const terminal = this._terminalService.createTerminal(shellLaunchConfig);
+		return Promise.resolve({
+			id: terminal.id,
+			name: terminal.title
+		});
+	}
+
+	public $show(terminalId: number, preserveFocus: boolean): void {
+		const terminalInstance = this._terminalService.getInstanceFromId(terminalId);
+		if (terminalInstance) {
+			this._terminalService.setActiveInstance(terminalInstance);
+			this._terminalService.showPanel(!preserveFocus);
+		}
+	}
+
+	public $hide(terminalId: number): void {
+		const instance = this._terminalService.getActiveInstance();
+		if (instance && instance.id === terminalId) {
+			this._terminalService.hidePanel();
+		}
+	}
+
+	public $dispose(terminalId: number): void {
+		const terminalInstance = this._terminalService.getInstanceFromId(terminalId);
+		if (terminalInstance) {
+			terminalInstance.dispose();
+		}
+	}
+
+	public $sendText(terminalId: number, text: string, addNewLine: boolean): void {
+		const terminalInstance = this._terminalService.getInstanceFromId(terminalId);
+		if (terminalInstance) {
+			terminalInstance.sendText(text, addNewLine);
+		}
+	}
+
+	public $startSendingDataEvents(): void {
+		if (!this._dataEventTracker) {
+			this._dataEventTracker = this._instantiationService.createInstance(TerminalDataEventTracker, (id, data) => {
+				this._onTerminalData(id, data);
+			});
+			// Send initial events if they exist
+			this._terminalService.terminalInstances.forEach(t => {
+				t.initialDataEvents?.forEach(d => this._onTerminalData(t.id, d));
+			});
+		}
+	}
+
+	public $stopSendingDataEvents(): void {
+		if (this._dataEventTracker) {
+			this._dataEventTracker.dispose();
+			this._dataEventTracker = undefined;
+		}
+	}
+
+	public $startLinkProvider(): void {
+		this._linkProvider?.dispose();
+		this._linkProvider = this._terminalService.registerLinkProvider(new ExtensionTerminalLinkProvider(this._proxy));
+	}
+
+	public $stopLinkProvider(): void {
+		this._linkProvider?.dispose();
+		this._linkProvider = undefined;
+	}
+
+	public $registerProcessSupport(isSupported: boolean): void {
+		this._terminalService.registerProcessSupport(isSupported);
+	}
+
+	private _onActiveTerminalChanged(terminalId: number | null): void {
+		this._proxy.$acceptActiveTerminalChanged(terminalId);
+	}
+
+	private _onTerminalData(terminalId: number, data: string): void {
+		this._proxy.$acceptTerminalProcessData(terminalId, data);
+	}
+
+	private _onTitleChanged(terminalId: number, name: string): void {
+		this._proxy.$acceptTerminalTitleChange(terminalId, name);
+	}
+
+	private _onWorkspacePermissionsChanged(isAllowed: boolean): void {
+		this._proxy.$acceptWorkspacePermissionsChanged(isAllowed);
+	}
+
+	private _onTerminalDisposed(terminalInstance: ITerminalInstance): void {
+		this._proxy.$acceptTerminalClosed(terminalInstance.id, terminalInstance.exitCode);
+	}
+
+	private _onTerminalOpened(terminalInstance: ITerminalInstance): void {
+		const shellLaunchConfigDto: IShellLaunchConfigDto = {
+			name: terminalInstance.shellLaunchConfig.name,
+			executable: terminalInstance.shellLaunchConfig.executable,
+			args: terminalInstance.shellLaunchConfig.args,
+			cwd: terminalInstance.shellLaunchConfig.cwd,
+			env: terminalInstance.shellLaunchConfig.env,
+			hideFromUser: terminalInstance.shellLaunchConfig.hideFromUser
+		};
+		if (terminalInstance.title) {
+			this._proxy.$acceptTerminalOpened(terminalInstance.id, terminalInstance.title, shellLaunchConfigDto);
+		} else {
+			terminalInstance.waitForTitle().then(title => {
+				this._proxy.$acceptTerminalOpened(terminalInstance.id, title, shellLaunchConfigDto);
+			});
+		}
+	}
+
+	private _onTerminalProcessIdReady(terminalInstance: ITerminalInstance): void {
+		if (terminalInstance.processId === undefined) {
+			return;
+		}
+		this._proxy.$acceptTerminalProcessId(terminalInstance.id, terminalInstance.processId);
+	}
+
+	private _onInstanceDimensionsChanged(instance: ITerminalInstance): void {
+		this._proxy.$acceptTerminalDimensions(instance.id, instance.cols, instance.rows);
+	}
+
+	private _onInstanceMaximumDimensionsChanged(instance: ITerminalInstance): void {
+		this._proxy.$acceptTerminalMaximumDimensions(instance.id, 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
+		};
+
+		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);
+
+		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);
+
+		// Note that onReisze is not being listened to here as it needs to fire when max dimensions
+		// change, excluding the dimension override
+		const initialDimensions: ITerminalDimensionsDto | undefined = request.cols && request.rows ? {
+			columns: request.cols,
+			rows: request.rows
+		} : undefined;
+
+		this._proxy.$startExtensionTerminal(
+			proxy.terminalId,
+			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));
+	}
+
+	public $sendProcessTitle(terminalId: number, title: string): void {
+		this._getTerminalProcess(terminalId).emitTitle(title);
+	}
+
+	public $sendProcessData(terminalId: number, data: string): void {
+		this._getTerminalProcess(terminalId).emitData(data);
+	}
+
+	public $sendProcessReady(terminalId: number, pid: number, cwd: string): void {
+		this._getTerminalProcess(terminalId).emitReady(pid, cwd);
+	}
+
+	public $sendProcessExit(terminalId: number, exitCode: number | undefined): void {
+		this._getTerminalProcess(terminalId).emitExit(exitCode);
+		this._terminalProcessProxies.delete(terminalId);
+	}
+
+	public $sendOverrideDimensions(terminalId: number, dimensions: ITerminalDimensions | undefined): void {
+		this._getTerminalProcess(terminalId).emitOverrideDimensions(dimensions);
+	}
+
+	public $sendProcessInitialCwd(terminalId: number, initialCwd: string): void {
+		this._getTerminalProcess(terminalId).emitInitialCwd(initialCwd);
+	}
+
+	public $sendProcessCwd(terminalId: number, cwd: string): void {
+		this._getTerminalProcess(terminalId).emitCwd(cwd);
+	}
+
+	public $sendResolvedLaunchConfig(terminalId: number, shellLaunchConfig: IShellLaunchConfig): void {
+		const instance = this._terminalService.getInstanceFromId(terminalId);
+		if (instance) {
+			this._getTerminalProcess(terminalId).emitResolvedShellLaunchConfig(shellLaunchConfig);
+		}
+	}
+
+	private async _onRequestLatency(terminalId: number): Promise<void> {
+		const COUNT = 2;
+		let sum = 0;
+		for (let i = 0; i < COUNT; i++) {
+			const sw = StopWatch.create(true);
+			await this._proxy.$acceptProcessRequestLatency(terminalId);
+			sw.stop();
+			sum += sw.elapsed();
+		}
+		this._getTerminalProcess(terminalId).emitLatency(sum / COUNT);
+	}
+
+	private _isPrimaryExtHost(): boolean {
+		// The "primary" ext host is the remote ext host if there is one, otherwise the local
+		const conn = this._remoteAgentService.getConnection();
+		if (conn) {
+			return this._remoteAuthority === conn.remoteAuthority;
+		}
+		return true;
+	}
+
+	private async _onRequestAvailableShells(req: IAvailableShellsRequest): Promise<void> {
+		if (this._isPrimaryExtHost()) {
+			req.callback(await this._proxy.$getAvailableShells());
+		}
+	}
+
+	private async _onRequestDefaultShellAndArgs(req: IDefaultShellAndArgsRequest): Promise<void> {
+		if (this._isPrimaryExtHost()) {
+			const res = await this._proxy.$getDefaultShellAndArgs(req.useAutomationShell);
+			req.callback(res.shell, res.args);
+		}
+	}
+
+	private _getTerminalProcess(terminalId: number): ITerminalProcessExtHostProxy {
+		const terminal = this._terminalProcessProxies.get(terminalId);
+		if (!terminal) {
+			throw new Error(`Unknown terminal: ${terminalId}`);
+		}
+		return terminal;
+	}
+
+	$setEnvironmentVariableCollection(extensionIdentifier: string, persistent: boolean, collection: ISerializableEnvironmentVariableCollection | undefined): void {
+		if (collection) {
+			const translatedCollection = {
+				persistent,
+				map: deserializeEnvironmentVariableCollection(collection)
+			};
+			this._environmentVariableService.set(extensionIdentifier, translatedCollection);
+		} else {
+			this._environmentVariableService.delete(extensionIdentifier);
+		}
+	}
+}
+
+/**
+ * Encapsulates temporary tracking of data events from terminal instances, once disposed all
+ * listeners are removed.
+ */
+class TerminalDataEventTracker extends Disposable {
+	private readonly _bufferer: TerminalDataBufferer;
+
+	constructor(
+		private readonly _callback: (id: number, data: string) => void,
+		@ITerminalService private readonly _terminalService: ITerminalService
+	) {
+		super();
+
+		this._register(this._bufferer = new TerminalDataBufferer(this._callback));
+
+		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)));
+	}
+
+	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));
+	}
+}
+
+class ExtensionTerminalLinkProvider implements ITerminalExternalLinkProvider {
+	constructor(
+		private readonly _proxy: ExtHostTerminalServiceShape
+	) {
+	}
+
+	async provideLinks(instance: ITerminalInstance, line: string): Promise<ITerminalLink[] | undefined> {
+		const proxy = this._proxy;
+		const extHostLinks = await proxy.$provideLinks(instance.id, line);
+		return extHostLinks.map(dto => ({
+			id: dto.id,
+			startIndex: dto.startIndex,
+			length: dto.length,
+			label: dto.label,
+			activate: () => proxy.$activateLink(instance.id, dto.id)
+		}));
+	}
+}

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

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainContext, IExtHostContext, ExtHostThemingShape, ExtHostContext, MainThreadThemingShape } from '../common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IThemeService } from 'vs/platform/theme/common/themeService';
+
+@extHostNamedCustomer(MainContext.MainThreadTheming)
+export class MainThreadTheming implements MainThreadThemingShape {
+
+	private readonly _themeService: IThemeService;
+	private readonly _proxy: ExtHostThemingShape;
+	private readonly _themeChangeListener: IDisposable;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IThemeService themeService: IThemeService
+	) {
+		this._themeService = themeService;
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTheming);
+
+		this._themeChangeListener = this._themeService.onDidColorThemeChange(e => {
+			this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
+		});
+		this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
+	}
+
+	dispose(): void {
+		this._themeChangeListener.dispose();
+	}
+}

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

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter } from 'vs/base/common/event';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { URI } from 'vs/base/common/uri';
+import { ILogService } from 'vs/platform/log/common/log';
+import { MainContext, MainThreadTimelineShape, IExtHostContext, ExtHostTimelineShape, ExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { TimelineChangeEvent, TimelineOptions, TimelineProviderDescriptor, ITimelineService, InternalTimelineOptions } from 'vs/workbench/contrib/timeline/common/timeline';
+
+@extHostNamedCustomer(MainContext.MainThreadTimeline)
+export class MainThreadTimeline implements MainThreadTimelineShape {
+	private readonly _proxy: ExtHostTimelineShape;
+	private readonly _providerEmitters = new Map<string, Emitter<TimelineChangeEvent>>();
+
+	constructor(
+		context: IExtHostContext,
+		@ILogService private readonly logService: ILogService,
+		@ITimelineService private readonly _timelineService: ITimelineService
+	) {
+		this._proxy = context.getProxy(ExtHostContext.ExtHostTimeline);
+	}
+
+	$registerTimelineProvider(provider: TimelineProviderDescriptor): void {
+		this.logService.trace(`MainThreadTimeline#registerTimelineProvider: id=${provider.id}`);
+
+		const proxy = this._proxy;
+
+		const emitters = this._providerEmitters;
+		let onDidChange = emitters.get(provider.id);
+		if (onDidChange === undefined) {
+			onDidChange = new Emitter<TimelineChangeEvent>();
+			emitters.set(provider.id, onDidChange);
+		}
+
+		this._timelineService.registerTimelineProvider({
+			...provider,
+			onDidChange: onDidChange.event,
+			provideTimeline(uri: URI, options: TimelineOptions, token: CancellationToken, internalOptions?: InternalTimelineOptions) {
+				return proxy.$getTimeline(provider.id, uri, options, token, internalOptions);
+			},
+			dispose() {
+				emitters.delete(provider.id);
+				onDidChange?.dispose();
+			}
+		});
+	}
+
+	$unregisterTimelineProvider(id: string): void {
+		this.logService.trace(`MainThreadTimeline#unregisterTimelineProvider: id=${id}`);
+
+		this._timelineService.unregisterTimelineProvider(id);
+	}
+
+	$emitTimelineChangeEvent(e: TimelineChangeEvent): void {
+		this.logService.trace(`MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`);
+
+		const emitter = this._providerEmitters.get(e.id!);
+		emitter?.fire(e);
+	}
+
+	dispose(): void {
+		// noop
+	}
+}

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

@@ -0,0 +1,244 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { ExtHostContext, MainThreadTreeViewsShape, ExtHostTreeViewsShape, MainContext, IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { ITreeViewDataProvider, ITreeItem, IViewsService, ITreeView, IViewsRegistry, ITreeViewDescriptor, IRevealOptions, Extensions, ResolvableTreeItem } from 'vs/workbench/common/views';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { distinct } from 'vs/base/common/arrays';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { isUndefinedOrNull, isNumber } from 'vs/base/common/types';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { ILogService } from 'vs/platform/log/common/log';
+
+@extHostNamedCustomer(MainContext.MainThreadTreeViews)
+export class MainThreadTreeViews extends Disposable implements MainThreadTreeViewsShape {
+
+	private readonly _proxy: ExtHostTreeViewsShape;
+	private readonly _dataProviders: Map<string, TreeViewDataProvider> = new Map<string, TreeViewDataProvider>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IViewsService private readonly viewsService: IViewsService,
+		@INotificationService private readonly notificationService: INotificationService,
+		@IExtensionService private readonly extensionService: IExtensionService,
+		@ILogService private readonly logService: ILogService
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTreeViews);
+	}
+
+	$registerTreeViewDataProvider(treeViewId: string, options: { showCollapseAll: boolean, canSelectMany: boolean }): void {
+		this.logService.trace('MainThreadTreeViews#$registerTreeViewDataProvider', treeViewId, options);
+
+		this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+			const dataProvider = new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService);
+			this._dataProviders.set(treeViewId, dataProvider);
+			const viewer = this.getTreeView(treeViewId);
+			if (viewer) {
+				// Order is important here. The internal tree isn't created until the dataProvider is set.
+				// Set all other properties first!
+				viewer.showCollapseAllAction = !!options.showCollapseAll;
+				viewer.canSelectMany = !!options.canSelectMany;
+				viewer.dataProvider = dataProvider;
+				this.registerListeners(treeViewId, viewer);
+				this._proxy.$setVisible(treeViewId, viewer.visible);
+			} else {
+				this.notificationService.error('No view is registered with id: ' + treeViewId);
+			}
+		});
+	}
+
+	$reveal(treeViewId: string, item: ITreeItem, parentChain: ITreeItem[], options: IRevealOptions): Promise<void> {
+		this.logService.trace('MainThreadTreeViews#$reveal', treeViewId, item, parentChain, options);
+
+		return this.viewsService.openView(treeViewId, options.focus)
+			.then(() => {
+				const viewer = this.getTreeView(treeViewId);
+				if (viewer) {
+					return this.reveal(viewer, this._dataProviders.get(treeViewId)!, item, parentChain, options);
+				}
+				return undefined;
+			});
+	}
+
+	$refresh(treeViewId: string, itemsToRefreshByHandle: { [treeItemHandle: string]: ITreeItem }): Promise<void> {
+		this.logService.trace('MainThreadTreeViews#$refresh', treeViewId, itemsToRefreshByHandle);
+
+		const viewer = this.getTreeView(treeViewId);
+		const dataProvider = this._dataProviders.get(treeViewId);
+		if (viewer && dataProvider) {
+			const itemsToRefresh = dataProvider.getItemsToRefresh(itemsToRefreshByHandle);
+			return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : undefined);
+		}
+		return Promise.resolve();
+	}
+
+	$setMessage(treeViewId: string, message: string): void {
+		this.logService.trace('MainThreadTreeViews#$setMessage', treeViewId, message);
+
+		const viewer = this.getTreeView(treeViewId);
+		if (viewer) {
+			viewer.message = message;
+		}
+	}
+
+	$setTitle(treeViewId: string, title: string, description: string | undefined): void {
+		this.logService.trace('MainThreadTreeViews#$setTitle', treeViewId, title, description);
+
+		const viewer = this.getTreeView(treeViewId);
+		if (viewer) {
+			viewer.title = title;
+			viewer.description = description;
+		}
+	}
+
+	private async reveal(treeView: ITreeView, dataProvider: TreeViewDataProvider, itemIn: ITreeItem, parentChain: ITreeItem[], options: IRevealOptions): Promise<void> {
+		options = options ? options : { select: false, focus: false };
+		const select = isUndefinedOrNull(options.select) ? false : options.select;
+		const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
+		let expand = Math.min(isNumber(options.expand) ? options.expand : options.expand === true ? 1 : 0, 3);
+
+		if (dataProvider.isEmpty()) {
+			// Refresh if empty
+			await treeView.refresh();
+		}
+		for (const parent of parentChain) {
+			const parentItem = dataProvider.getItem(parent.handle);
+			if (parentItem) {
+				await treeView.expand(parentItem);
+			}
+		}
+		const item = dataProvider.getItem(itemIn.handle);
+		if (item) {
+			await treeView.reveal(item);
+			if (select) {
+				treeView.setSelection([item]);
+			}
+			if (focus) {
+				treeView.setFocus(item);
+			}
+			let itemsToExpand = [item];
+			for (; itemsToExpand.length > 0 && expand > 0; expand--) {
+				await treeView.expand(itemsToExpand);
+				itemsToExpand = itemsToExpand.reduce((result, itemValue) => {
+					const item = dataProvider.getItem(itemValue.handle);
+					if (item && item.children && item.children.length) {
+						result.push(...item.children);
+					}
+					return result;
+				}, [] as ITreeItem[]);
+			}
+		}
+	}
+
+	private registerListeners(treeViewId: string, treeView: ITreeView): void {
+		this._register(treeView.onDidExpandItem(item => this._proxy.$setExpanded(treeViewId, item.handle, true)));
+		this._register(treeView.onDidCollapseItem(item => this._proxy.$setExpanded(treeViewId, item.handle, false)));
+		this._register(treeView.onDidChangeSelection(items => this._proxy.$setSelection(treeViewId, items.map(({ handle }) => handle))));
+		this._register(treeView.onDidChangeVisibility(isVisible => this._proxy.$setVisible(treeViewId, isVisible)));
+	}
+
+	private getTreeView(treeViewId: string): ITreeView | null {
+		const viewDescriptor: ITreeViewDescriptor = <ITreeViewDescriptor>Registry.as<IViewsRegistry>(Extensions.ViewsRegistry).getView(treeViewId);
+		return viewDescriptor ? viewDescriptor.treeView : null;
+	}
+
+	dispose(): void {
+		this._dataProviders.forEach((dataProvider, treeViewId) => {
+			const treeView = this.getTreeView(treeViewId);
+			if (treeView) {
+				treeView.dataProvider = undefined;
+			}
+		});
+		this._dataProviders.clear();
+		super.dispose();
+	}
+}
+
+type TreeItemHandle = string;
+
+class TreeViewDataProvider implements ITreeViewDataProvider {
+
+	private readonly itemsMap: Map<TreeItemHandle, ITreeItem> = new Map<TreeItemHandle, ITreeItem>();
+	private hasResolve: Promise<boolean>;
+
+	constructor(private readonly treeViewId: string,
+		private readonly _proxy: ExtHostTreeViewsShape,
+		private readonly notificationService: INotificationService
+	) {
+		this.hasResolve = this._proxy.$hasResolve(this.treeViewId);
+	}
+
+	getChildren(treeItem?: ITreeItem): Promise<ITreeItem[]> {
+		return Promise.resolve(this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
+			.then(
+				children => this.postGetChildren(children),
+				err => {
+					this.notificationService.error(err);
+					return [];
+				}));
+	}
+
+	getItemsToRefresh(itemsToRefreshByHandle: { [treeItemHandle: string]: ITreeItem }): ITreeItem[] {
+		const itemsToRefresh: ITreeItem[] = [];
+		if (itemsToRefreshByHandle) {
+			for (const treeItemHandle of Object.keys(itemsToRefreshByHandle)) {
+				const currentTreeItem = this.getItem(treeItemHandle);
+				if (currentTreeItem) { // Refresh only if the item exists
+					const treeItem = itemsToRefreshByHandle[treeItemHandle];
+					// Update the current item with refreshed item
+					this.updateTreeItem(currentTreeItem, treeItem);
+					if (treeItemHandle === treeItem.handle) {
+						itemsToRefresh.push(currentTreeItem);
+					} else {
+						// Update maps when handle is changed and refresh parent
+						this.itemsMap.delete(treeItemHandle);
+						this.itemsMap.set(currentTreeItem.handle, currentTreeItem);
+						const parent = treeItem.parentHandle ? this.itemsMap.get(treeItem.parentHandle) : null;
+						if (parent) {
+							itemsToRefresh.push(parent);
+						}
+					}
+				}
+			}
+		}
+		return itemsToRefresh;
+	}
+
+	getItem(treeItemHandle: string): ITreeItem | undefined {
+		return this.itemsMap.get(treeItemHandle);
+	}
+
+	isEmpty(): boolean {
+		return this.itemsMap.size === 0;
+	}
+
+	private async postGetChildren(elements: ITreeItem[]): Promise<ResolvableTreeItem[]> {
+		const result: ResolvableTreeItem[] = [];
+		const hasResolve = await this.hasResolve;
+		if (elements) {
+			for (const element of elements) {
+				const resolvable = new ResolvableTreeItem(element, hasResolve ? () => {
+					return this._proxy.$resolve(this.treeViewId, element.handle);
+				} : undefined);
+				this.itemsMap.set(element.handle, resolvable);
+				result.push(resolvable);
+			}
+		}
+		return result;
+	}
+
+	private updateTreeItem(current: ITreeItem, treeItem: ITreeItem): void {
+		treeItem.children = treeItem.children ? treeItem.children : undefined;
+		if (current) {
+			const properties = distinct([...Object.keys(current), ...Object.keys(treeItem)]);
+			for (const property of properties) {
+				(<any>current)[property] = (<any>treeItem)[property];
+			}
+		}
+	}
+}

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

@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainThreadTunnelServiceShape, IExtHostContext, MainContext, ExtHostContext, ExtHostTunnelServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { IRemoteExplorerService, MakeAddress } from 'vs/workbench/services/remote/common/remoteExplorerService';
+import { ITunnelProvider, ITunnelService, TunnelOptions } from 'vs/platform/remote/common/tunnel';
+import { Disposable } from 'vs/base/common/lifecycle';
+import type { TunnelDescription } from 'vs/platform/remote/common/remoteAuthorityResolver';
+
+@extHostNamedCustomer(MainContext.MainThreadTunnelService)
+export class MainThreadTunnelService extends Disposable implements MainThreadTunnelServiceShape {
+	private readonly _proxy: ExtHostTunnelServiceShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IRemoteExplorerService private readonly remoteExplorerService: IRemoteExplorerService,
+		@ITunnelService private readonly tunnelService: ITunnelService
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTunnelService);
+		this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
+		this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
+	}
+
+	async $openTunnel(tunnelOptions: TunnelOptions): Promise<TunnelDto | undefined> {
+		const tunnel = await this.remoteExplorerService.forward(tunnelOptions.remoteAddress, tunnelOptions.localAddressPort, tunnelOptions.label);
+		if (tunnel) {
+			return TunnelDto.fromServiceTunnel(tunnel);
+		}
+		return undefined;
+	}
+
+	async $closeTunnel(remote: { host: string, port: number }): Promise<void> {
+		return this.remoteExplorerService.close(remote);
+	}
+
+	async $getTunnels(): Promise<TunnelDescription[]> {
+		return (await this.tunnelService.tunnels).map(tunnel => {
+			return {
+				remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
+				localAddress: tunnel.localAddress
+			};
+		});
+	}
+
+	async $registerCandidateFinder(): Promise<void> {
+		this.remoteExplorerService.registerCandidateFinder(() => this._proxy.$findCandidatePorts());
+	}
+
+	async $tunnelServiceReady(): Promise<void> {
+		return this.remoteExplorerService.restore();
+	}
+
+	async $setTunnelProvider(): Promise<void> {
+		const tunnelProvider: ITunnelProvider = {
+			forwardPort: (tunnelOptions: TunnelOptions) => {
+				const forward = this._proxy.$forwardPort(tunnelOptions);
+				if (forward) {
+					return forward.then(tunnel => {
+						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,
+							dispose: (silent: boolean) => {
+								if (!silent) {
+									this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port });
+								}
+							}
+						};
+					});
+				}
+				return undefined;
+			}
+		};
+		this.tunnelService.setTunnelProvider(tunnelProvider);
+	}
+
+	async $setCandidateFilter(): Promise<void> {
+		this._register(this.remoteExplorerService.setCandidateFilter(async (candidates: { host: string, port: number, detail: string }[]): Promise<{ host: string, port: number, detail: string }[]> => {
+			const filters: boolean[] = await this._proxy.$filterCandidates(candidates);
+			const filteredCandidates: { host: string, port: number, detail: string }[] = [];
+			if (filters.length !== candidates.length) {
+				return candidates;
+			}
+			for (let i = 0; i < candidates.length; i++) {
+				if (filters[i]) {
+					filteredCandidates.push(candidates[i]);
+				}
+			}
+			return filteredCandidates;
+		}));
+	}
+
+	dispose(): void {
+
+	}
+}

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

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ExtHostContext, IExtHostContext, MainContext, MainThreadUrlsShape, ExtHostUrlsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../common/extHostCustomers';
+import { IURLService, IURLHandler, IOpenURLOptions } from 'vs/platform/url/common/url';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IExtensionUrlHandler } from 'vs/workbench/services/extensions/browser/extensionUrlHandler';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+class ExtensionUrlHandler implements IURLHandler {
+
+	constructor(
+		private readonly proxy: ExtHostUrlsShape,
+		private readonly handle: number,
+		readonly extensionId: ExtensionIdentifier
+	) { }
+
+	handleURL(uri: URI, options?: IOpenURLOptions): Promise<boolean> {
+		if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
+			return Promise.resolve(false);
+		}
+
+		return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
+	}
+}
+
+@extHostNamedCustomer(MainContext.MainThreadUrls)
+export class MainThreadUrls implements MainThreadUrlsShape {
+
+	private readonly proxy: ExtHostUrlsShape;
+	private handlers = new Map<number, { extensionId: ExtensionIdentifier, disposable: IDisposable }>();
+
+	constructor(
+		context: IExtHostContext,
+		@IURLService private readonly urlService: IURLService,
+		@IExtensionUrlHandler private readonly extensionUrlHandler: IExtensionUrlHandler
+	) {
+		this.proxy = context.getProxy(ExtHostContext.ExtHostUrls);
+	}
+
+	$registerUriHandler(handle: number, extensionId: ExtensionIdentifier): Promise<void> {
+		const handler = new ExtensionUrlHandler(this.proxy, handle, extensionId);
+		const disposable = this.urlService.registerHandler(handler);
+
+		this.handlers.set(handle, { extensionId, disposable });
+		this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
+
+		return Promise.resolve(undefined);
+	}
+
+	$unregisterUriHandler(handle: number): Promise<void> {
+		const tuple = this.handlers.get(handle);
+
+		if (!tuple) {
+			return Promise.resolve(undefined);
+		}
+
+		const { extensionId, disposable } = tuple;
+
+		this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
+		this.handlers.delete(handle);
+		disposable.dispose();
+
+		return Promise.resolve(undefined);
+	}
+
+	async $createAppUri(uri: UriComponents): Promise<URI> {
+		return this.urlService.create(uri);
+	}
+
+	dispose(): void {
+		this.handlers.forEach(({ disposable }) => disposable.dispose());
+		this.handlers.clear();
+	}
+}

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

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { MainThreadCustomEditors } from 'vs/workbench/api/browser/mainThreadCustomEditors';
+import { MainThreadWebviewPanels } from 'vs/workbench/api/browser/mainThreadWebviewPanels';
+import { MainThreadWebviews } from 'vs/workbench/api/browser/mainThreadWebviews';
+import { MainThreadWebviewsViews } from 'vs/workbench/api/browser/mainThreadWebviewViews';
+import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
+import { extHostCustomer } from '../common/extHostCustomers';
+
+@extHostCustomer
+export class MainThreadWebviewManager extends Disposable {
+	constructor(
+		context: extHostProtocol.IExtHostContext,
+		@IInstantiationService instantiationService: IInstantiationService,
+	) {
+		super();
+
+		const webviews = this._register(instantiationService.createInstance(MainThreadWebviews, context));
+		context.set(extHostProtocol.MainContext.MainThreadWebviews, webviews);
+
+		const webviewPanels = this._register(instantiationService.createInstance(MainThreadWebviewPanels, context, webviews));
+		context.set(extHostProtocol.MainContext.MainThreadWebviewPanels, webviewPanels);
+
+		const customEditors = this._register(instantiationService.createInstance(MainThreadCustomEditors, context, webviews, webviewPanels));
+		context.set(extHostProtocol.MainContext.MainThreadCustomEditors, customEditors);
+
+		const webviewViews = this._register(instantiationService.createInstance(MainThreadWebviewsViews, context, webviews));
+		context.set(extHostProtocol.MainContext.MainThreadWebviewViews, webviewViews);
+	}
+}

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

@@ -0,0 +1,336 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+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 * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
+import { editorGroupToViewColumn, EditorViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
+import { IEditorInput } from 'vs/workbench/common/editor';
+import { DiffEditorInput } from 'vs/workbench/common/editor/diffEditorInput';
+import { WebviewIcons } 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 { 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';
+
+/**
+ * Bi-directional map between webview handles and inputs.
+ */
+class WebviewInputStore {
+	private readonly _handlesToInputs = new Map<string, WebviewInput>();
+	private readonly _inputsToHandles = new Map<WebviewInput, string>();
+
+	public add(handle: string, input: WebviewInput): void {
+		this._handlesToInputs.set(handle, input);
+		this._inputsToHandles.set(input, handle);
+	}
+
+	public getHandleForInput(input: WebviewInput): string | undefined {
+		return this._inputsToHandles.get(input);
+	}
+
+	public getInputForHandle(handle: string): WebviewInput | undefined {
+		return this._handlesToInputs.get(handle);
+	}
+
+	public delete(handle: string): void {
+		const input = this.getInputForHandle(handle);
+		this._handlesToInputs.delete(handle);
+		if (input) {
+			this._inputsToHandles.delete(input);
+		}
+	}
+
+	public get size(): number {
+		return this._handlesToInputs.size;
+	}
+
+	[Symbol.iterator](): Iterator<WebviewInput> {
+		return this._handlesToInputs.values();
+	}
+}
+
+class WebviewViewTypeTransformer {
+	public constructor(
+		public readonly prefix: string,
+	) { }
+
+	public fromExternal(viewType: string): string {
+		return this.prefix + viewType;
+	}
+
+	public toExternal(viewType: string): string | undefined {
+		return viewType.startsWith(this.prefix)
+			? viewType.substr(this.prefix.length)
+			: undefined;
+	}
+}
+
+export class MainThreadWebviewPanels extends Disposable implements extHostProtocol.MainThreadWebviewPanelsShape {
+
+	private readonly webviewPanelViewType = new WebviewViewTypeTransformer('mainThreadWebview-');
+
+	private readonly _proxy: extHostProtocol.ExtHostWebviewPanelsShape;
+
+	private readonly _webviewInputs = new WebviewInputStore();
+
+	private readonly _editorProviders = new Map<string, IDisposable>();
+	private readonly _webviewFromDiffEditorHandles = new Set<string>();
+
+	private readonly _revivers = new Map<string, IDisposable>();
+
+	constructor(
+		context: extHostProtocol.IExtHostContext,
+		private readonly _mainThreadWebviews: MainThreadWebviews,
+		@IExtensionService extensionService: IExtensionService,
+		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IWebviewWorkbenchService private readonly _webviewWorkbenchService: IWebviewWorkbenchService,
+	) {
+		super();
+
+		this._proxy = context.getProxy(extHostProtocol.ExtHostContext.ExtHostWebviewPanels);
+
+		this._register(_editorService.onDidActiveEditorChange(() => {
+			const activeInput = this._editorService.activeEditor;
+			if (activeInput instanceof DiffEditorInput && activeInput.primary instanceof WebviewInput && activeInput.secondary instanceof WebviewInput) {
+				this.registerWebviewFromDiffEditorListeners(activeInput);
+			}
+
+			this.updateWebviewViewStates(activeInput);
+		}));
+
+		this._register(_editorService.onDidVisibleEditorsChange(() => {
+			this.updateWebviewViewStates(this._editorService.activeEditor);
+		}));
+
+		// This reviver's only job is to activate extensions.
+		// This should trigger the real reviver to be registered from the extension host side.
+		this._register(_webviewWorkbenchService.registerResolver({
+			canResolve: (webview: WebviewInput) => {
+				const viewType = this.webviewPanelViewType.toExternal(webview.viewType);
+				if (typeof viewType === 'string') {
+					extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
+				}
+				return false;
+			},
+			resolveWebview: () => { throw new Error('not implemented'); }
+		}));
+	}
+
+	dispose() {
+		super.dispose();
+
+		dispose(this._editorProviders.values());
+		this._editorProviders.clear();
+	}
+
+	public get webviewInputs(): Iterable<WebviewInput> { return this._webviewInputs; }
+
+	public addWebviewInput(handle: extHostProtocol.WebviewHandle, input: WebviewInput): void {
+		this._webviewInputs.add(handle, input);
+		this._mainThreadWebviews.addWebview(handle, input.webview);
+
+		input.webview.onDidDispose(() => {
+			this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
+				this._webviewInputs.delete(handle);
+			});
+		});
+	}
+
+	public $createWebviewPanel(
+		extensionData: extHostProtocol.WebviewExtensionDescription,
+		handle: extHostProtocol.WebviewHandle,
+		viewType: string,
+		title: string,
+		showOptions: { viewColumn?: EditorViewColumn, preserveFocus?: boolean; },
+		options: WebviewInputOptions
+	): void {
+		const mainThreadShowOptions: ICreateWebViewShowOptions = Object.create(null);
+		if (showOptions) {
+			mainThreadShowOptions.preserveFocus = !!showOptions.preserveFocus;
+			mainThreadShowOptions.group = viewColumnToEditorGroup(this._editorGroupService, showOptions.viewColumn);
+		}
+
+		const extension = reviveWebviewExtension(extensionData);
+
+		const webview = this._webviewWorkbenchService.createWebview(handle, this.webviewPanelViewType.fromExternal(viewType), title, mainThreadShowOptions, reviveWebviewOptions(options), extension);
+		this.addWebviewInput(handle, webview);
+
+		/* __GDPR__
+			"webviews:createWebviewPanel" : {
+				"extensionId" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		this._telemetryService.publicLog('webviews:createWebviewPanel', { extensionId: extension.id.value });
+	}
+
+	public $disposeWebview(handle: extHostProtocol.WebviewHandle): void {
+		const webview = this.getWebviewInput(handle);
+		webview.dispose();
+	}
+
+	public $setTitle(handle: extHostProtocol.WebviewHandle, value: string): void {
+		const webview = this.getWebviewInput(handle);
+		webview.setName(value);
+	}
+
+
+	public $setIconPath(handle: extHostProtocol.WebviewHandle, value: { light: UriComponents, dark: UriComponents; } | undefined): void {
+		const webview = this.getWebviewInput(handle);
+		webview.iconPath = reviveWebviewIcon(value);
+	}
+
+	public $reveal(handle: extHostProtocol.WebviewHandle, showOptions: extHostProtocol.WebviewPanelShowOptions): void {
+		const webview = this.getWebviewInput(handle);
+		if (webview.isDisposed()) {
+			return;
+		}
+
+		const targetGroup = this._editorGroupService.getGroup(viewColumnToEditorGroup(this._editorGroupService, showOptions.viewColumn)) || this._editorGroupService.getGroup(webview.group || 0);
+		if (targetGroup) {
+			this._webviewWorkbenchService.revealWebview(webview, targetGroup, !!showOptions.preserveFocus);
+		}
+	}
+
+	public $registerSerializer(viewType: string)
+		: void {
+		if (this._revivers.has(viewType)) {
+			throw new Error(`Reviver for ${viewType} already registered`);
+		}
+
+		this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
+			canResolve: (webviewInput) => {
+				return webviewInput.viewType === this.webviewPanelViewType.fromExternal(viewType);
+			},
+			resolveWebview: async (webviewInput): Promise<void> => {
+				const viewType = this.webviewPanelViewType.toExternal(webviewInput.viewType);
+				if (!viewType) {
+					webviewInput.webview.html = this._mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType);
+					return;
+				}
+
+
+				const handle = webviewInput.id;
+
+				this.addWebviewInput(handle, webviewInput);
+
+				let state = undefined;
+				if (webviewInput.webview.state) {
+					try {
+						state = JSON.parse(webviewInput.webview.state);
+					} catch (e) {
+						console.error('Could not load webview state', e, webviewInput.webview.state);
+					}
+				}
+
+				try {
+					await this._proxy.$deserializeWebviewPanel(handle, viewType, webviewInput.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), webviewInput.webview.options);
+				} catch (error) {
+					onUnexpectedError(error);
+					webviewInput.webview.html = this._mainThreadWebviews.getWebviewResolvedFailedContent(viewType);
+				}
+			}
+		}));
+	}
+
+	public $unregisterSerializer(viewType: string): void {
+		const reviver = this._revivers.get(viewType);
+		if (!reviver) {
+			throw new Error(`No reviver for ${viewType} registered`);
+		}
+
+		reviver.dispose();
+		this._revivers.delete(viewType);
+	}
+
+	private registerWebviewFromDiffEditorListeners(diffEditorInput: DiffEditorInput): void {
+		const primary = diffEditorInput.primary as WebviewInput;
+		const secondary = diffEditorInput.secondary as WebviewInput;
+
+		if (this._webviewFromDiffEditorHandles.has(primary.id) || this._webviewFromDiffEditorHandles.has(secondary.id)) {
+			return;
+		}
+
+		this._webviewFromDiffEditorHandles.add(primary.id);
+		this._webviewFromDiffEditorHandles.add(secondary.id);
+
+		const disposables = new DisposableStore();
+		disposables.add(primary.webview.onDidFocus(() => this.updateWebviewViewStates(primary)));
+		disposables.add(secondary.webview.onDidFocus(() => this.updateWebviewViewStates(secondary)));
+		disposables.add(diffEditorInput.onDispose(() => {
+			this._webviewFromDiffEditorHandles.delete(primary.id);
+			this._webviewFromDiffEditorHandles.delete(secondary.id);
+			dispose(disposables);
+		}));
+	}
+
+	private updateWebviewViewStates(activeEditorInput: IEditorInput | undefined) {
+		if (!this._webviewInputs.size) {
+			return;
+		}
+
+		const viewStates: extHostProtocol.WebviewPanelViewStateData = {};
+
+		const updateViewStatesForInput = (group: IEditorGroup, topLevelInput: IEditorInput, editorInput: IEditorInput) => {
+			if (!(editorInput instanceof WebviewInput)) {
+				return;
+			}
+
+			editorInput.updateGroup(group.id);
+
+			const handle = this._webviewInputs.getHandleForInput(editorInput);
+			if (handle) {
+				viewStates[handle] = {
+					visible: topLevelInput === group.activeEditor,
+					active: editorInput === activeEditorInput,
+					position: editorGroupToViewColumn(this._editorGroupService, group.id),
+				};
+			}
+		};
+
+		for (const group of this._editorGroupService.groups) {
+			for (const input of group.editors) {
+				if (input instanceof DiffEditorInput) {
+					updateViewStatesForInput(group, input, input.primary);
+					updateViewStatesForInput(group, input, input.secondary);
+				} else {
+					updateViewStatesForInput(group, input, input);
+				}
+			}
+		}
+
+		if (Object.keys(viewStates).length) {
+			this._proxy.$onDidChangeWebviewPanelViewStates(viewStates);
+		}
+	}
+
+	private getWebviewInput(handle: extHostProtocol.WebviewHandle): WebviewInput {
+		const webview = this.tryGetWebviewInput(handle);
+		if (!webview) {
+			throw new Error(`Unknown webview handle:${handle}`);
+		}
+		return webview;
+	}
+
+	private tryGetWebviewInput(handle: extHostProtocol.WebviewHandle): WebviewInput | undefined {
+		return this._webviewInputs.getInputForHandle(handle);
+	}
+}
+
+
+function reviveWebviewIcon(
+	value: { light: UriComponents, dark: UriComponents; } | undefined
+): WebviewIcons | undefined {
+	return value
+		? { light: URI.revive(value.light), dark: URI.revive(value.dark) }
+		: undefined;
+}
+

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

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { Disposable, dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { MainThreadWebviews, reviveWebviewExtension } from 'vs/workbench/api/browser/mainThreadWebviews';
+import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
+import { IWebviewViewService, WebviewView } from 'vs/workbench/contrib/webviewView/browser/webviewViewService';
+
+
+export class MainThreadWebviewsViews extends Disposable implements extHostProtocol.MainThreadWebviewViewsShape {
+
+	private readonly _proxy: extHostProtocol.ExtHostWebviewViewsShape;
+
+	private readonly _webviewViews = new Map<string, WebviewView>();
+	private readonly _webviewViewProviders = new Map<string, IDisposable>();
+
+	constructor(
+		context: extHostProtocol.IExtHostContext,
+		private readonly mainThreadWebviews: MainThreadWebviews,
+		@IWebviewViewService private readonly _webviewViewService: IWebviewViewService,
+	) {
+		super();
+
+		this._proxy = context.getProxy(extHostProtocol.ExtHostContext.ExtHostWebviewViews);
+	}
+
+	dispose() {
+		super.dispose();
+
+		dispose(this._webviewViewProviders.values());
+		this._webviewViewProviders.clear();
+
+		dispose(this._webviewViews.values());
+	}
+
+	public $setWebviewViewTitle(handle: extHostProtocol.WebviewHandle, value: string | undefined): void {
+		const webviewView = this.getWebviewView(handle);
+		webviewView.title = value;
+	}
+
+	public $setWebviewViewDescription(handle: extHostProtocol.WebviewHandle, value: string | undefined): void {
+		const webviewView = this.getWebviewView(handle);
+		webviewView.description = value;
+	}
+
+	public $show(handle: extHostProtocol.WebviewHandle, preserveFocus: boolean): void {
+		const webviewView = this.getWebviewView(handle);
+		webviewView.show(preserveFocus);
+	}
+
+	public $registerWebviewViewProvider(
+		extensionData: extHostProtocol.WebviewExtensionDescription,
+		viewType: string,
+		options?: { retainContextWhenHidden?: boolean }
+	): void {
+		if (this._webviewViewProviders.has(viewType)) {
+			throw new Error(`View provider for ${viewType} already registered`);
+		}
+
+		const extension = reviveWebviewExtension(extensionData);
+
+		const registration = this._webviewViewService.register(viewType, {
+			resolve: async (webviewView: WebviewView, cancellation: CancellationToken) => {
+				const handle = webviewView.webview.id;
+
+				this._webviewViews.set(handle, webviewView);
+				this.mainThreadWebviews.addWebview(handle, webviewView.webview);
+
+				let state = undefined;
+				if (webviewView.webview.state) {
+					try {
+						state = JSON.parse(webviewView.webview.state);
+					} catch (e) {
+						console.error('Could not load webview state', e, webviewView.webview.state);
+					}
+				}
+
+				webviewView.webview.extension = extension;
+
+				if (options) {
+					webviewView.webview.options = options;
+				}
+
+				webviewView.onDidChangeVisibility(visible => {
+					this._proxy.$onDidChangeWebviewViewVisibility(handle, visible);
+				});
+
+				webviewView.onDispose(() => {
+					this._proxy.$disposeWebviewView(handle);
+					this._webviewViews.delete(handle);
+				});
+
+				try {
+					await this._proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
+				} catch (error) {
+					onUnexpectedError(error);
+					webviewView.webview.html = this.mainThreadWebviews.getWebviewResolvedFailedContent(viewType);
+				}
+			}
+		});
+
+		this._webviewViewProviders.set(viewType, registration);
+	}
+
+	public $unregisterWebviewViewProvider(viewType: string): void {
+		const provider = this._webviewViewProviders.get(viewType);
+		if (!provider) {
+			throw new Error(`No view provider for ${viewType} registered`);
+		}
+
+		provider.dispose();
+		this._webviewViewProviders.delete(viewType);
+	}
+
+	private getWebviewView(handle: string): WebviewView {
+		const webviewView = this._webviewViews.get(handle);
+		if (!webviewView) {
+			throw new Error('unknown webview view');
+		}
+		return webviewView;
+	}
+}
+

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

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, DisposableStore } from 'vs/base/common/lifecycle';
+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';
+
+export class MainThreadWebviews extends Disposable implements extHostProtocol.MainThreadWebviewsShape {
+
+	private static readonly standardSupportedLinkSchemes = new Set([
+		Schemas.http,
+		Schemas.https,
+		Schemas.mailto,
+		Schemas.vscode,
+		'vscode-insider',
+	]);
+
+	private readonly _proxy: extHostProtocol.ExtHostWebviewsShape;
+
+	private readonly _webviews = new Map<string, Webview>();
+
+	constructor(
+		context: extHostProtocol.IExtHostContext,
+		@IOpenerService private readonly _openerService: IOpenerService,
+		@IProductService private readonly _productService: IProductService,
+	) {
+		super();
+
+		this._proxy = context.getProxy(extHostProtocol.ExtHostContext.ExtHostWebviews);
+	}
+
+	public addWebview(handle: extHostProtocol.WebviewHandle, webview: WebviewOverlay): void {
+		this._webviews.set(handle, webview);
+		this.hookupWebviewEventDelegate(handle, webview);
+	}
+
+	public $setHtml(handle: extHostProtocol.WebviewHandle, value: string): void {
+		const webview = this.getWebview(handle);
+		webview.html = value;
+	}
+
+	public $setOptions(handle: extHostProtocol.WebviewHandle, options: IWebviewOptions): void {
+		const webview = this.getWebview(handle);
+		webview.contentOptions = reviveWebviewOptions(options);
+	}
+
+	public async $postMessage(handle: extHostProtocol.WebviewHandle, message: any): Promise<boolean> {
+		const webview = this.getWebview(handle);
+		webview.postMessage(message);
+		return true;
+	}
+
+	private hookupWebviewEventDelegate(handle: extHostProtocol.WebviewHandle, webview: WebviewOverlay) {
+		const disposables = new DisposableStore();
+
+		disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
+		disposables.add(webview.onMessage((message: any) => { this._proxy.$onMessage(handle, message); }));
+		disposables.add(webview.onMissingCsp((extension: ExtensionIdentifier) => this._proxy.$onMissingCsp(handle, extension.value)));
+
+		disposables.add(webview.onDidDispose(() => {
+			disposables.dispose();
+			this._webviews.delete(handle);
+		}));
+	}
+
+	private onDidClickLink(handle: extHostProtocol.WebviewHandle, link: string): void {
+		const webview = this.getWebview(handle);
+		if (this.isSupportedLink(webview, URI.parse(link))) {
+			this._openerService.open(link, { fromUserGesture: true });
+		}
+	}
+
+	private isSupportedLink(webview: Webview, link: URI): boolean {
+		if (MainThreadWebviews.standardSupportedLinkSchemes.has(link.scheme)) {
+			return true;
+		}
+		if (!isWeb && this._productService.urlProtocol === link.scheme) {
+			return true;
+		}
+		return !!webview.contentOptions.enableCommandUris && link.scheme === Schemas.command;
+	}
+
+	private getWebview(handle: extHostProtocol.WebviewHandle): Webview {
+		const webview = this._webviews.get(handle);
+		if (!webview) {
+			throw new Error(`Unknown webview handle:${handle}`);
+		}
+		return webview;
+	}
+
+	public getWebviewResolvedFailedContent(viewType: string) {
+		return `<!DOCTYPE html>
+		<html>
+			<head>
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
+			</head>
+			<body>${localize('errorMessage', "An error occurred while loading view: {0}", escape(viewType))}</body>
+		</html>`;
+	}
+}
+
+export function reviveWebviewExtension(extensionData: extHostProtocol.WebviewExtensionDescription): WebviewExtensionDescription {
+	return { id: extensionData.id, location: URI.revive(extensionData.location) };
+}
+
+export function reviveWebviewOptions(options: IWebviewOptions): WebviewInputOptions {
+	return {
+		...options,
+		allowScripts: options.enableScripts,
+		localResourceRoots: Array.isArray(options.localResourceRoots) ? options.localResourceRoots.map(r => URI.revive(r)) : undefined,
+	};
+}

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

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Event } from 'vs/base/common/event';
+import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IOpenerService } from 'vs/platform/opener/common/opener';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, ExtHostWindowShape, IExtHostContext, IOpenUriOptions, MainContext, MainThreadWindowShape } from '../common/extHost.protocol';
+import { IHostService } from 'vs/workbench/services/host/browser/host';
+
+@extHostNamedCustomer(MainContext.MainThreadWindow)
+export class MainThreadWindow implements MainThreadWindowShape {
+
+	private readonly proxy: ExtHostWindowShape;
+	private readonly disposables = new DisposableStore();
+	private readonly resolved = new Map<number, IDisposable>();
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IHostService private readonly hostService: IHostService,
+		@IOpenerService private readonly openerService: IOpenerService,
+	) {
+		this.proxy = extHostContext.getProxy(ExtHostContext.ExtHostWindow);
+
+		Event.latch(hostService.onDidChangeFocus)
+			(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
+	}
+
+	dispose(): void {
+		this.disposables.dispose();
+
+		for (const value of this.resolved.values()) {
+			value.dispose();
+		}
+		this.resolved.clear();
+	}
+
+	$getWindowVisibility(): Promise<boolean> {
+		return Promise.resolve(this.hostService.hasFocus);
+	}
+
+	async $openUri(uriComponents: UriComponents, uriString: string | undefined, options: IOpenUriOptions): Promise<boolean> {
+		const uri = URI.from(uriComponents);
+		let target: URI | string;
+		if (uriString && URI.parse(uriString).toString() === uri.toString()) {
+			// called with string and no transformation happened -> keep string
+			target = uriString;
+		} else {
+			// called with URI or transformed -> use uri
+			target = uri;
+		}
+		return this.openerService.open(target, { openExternal: true, allowTunneling: options.allowTunneling });
+	}
+
+	async $asExternalUri(uriComponents: UriComponents, options: IOpenUriOptions): Promise<UriComponents> {
+		const uri = URI.revive(uriComponents);
+		const result = await this.openerService.resolveExternalUri(uri, options);
+		return result.resolved;
+	}
+}

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

@@ -0,0 +1,205 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
+import { isPromiseCanceledError } from 'vs/base/common/errors';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { localize } from 'vs/nls';
+import { isNative } from 'vs/base/common/platform';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ILabelService } from 'vs/platform/label/common/label';
+import { IFileMatch, IPatternInfo, ISearchProgressItem, ISearchService } from 'vs/workbench/services/search/common/search';
+import { IWorkspaceContextService, WorkbenchState, IWorkspace, toWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ITextQueryBuilderOptions, QueryBuilder } from 'vs/workbench/contrib/search/common/queryBuilder';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IWorkspaceEditingService } from 'vs/workbench/services/workspaces/common/workspaceEditing';
+import { ExtHostContext, ExtHostWorkspaceShape, IExtHostContext, MainContext, MainThreadWorkspaceShape, IWorkspaceData, ITextSearchComplete } from '../common/extHost.protocol';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { isUntitledWorkspace } from 'vs/platform/workspaces/common/workspaces';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import { withNullAsUndefined } from 'vs/base/common/types';
+import { IFileService } from 'vs/platform/files/common/files';
+import { IRequestService } from 'vs/platform/request/common/request';
+import { checkGlobFileExists } from 'vs/workbench/api/common/shared/workspaceContains';
+
+@extHostNamedCustomer(MainContext.MainThreadWorkspace)
+export class MainThreadWorkspace implements MainThreadWorkspaceShape {
+
+	private readonly _toDispose = new DisposableStore();
+	private readonly _activeCancelTokens: { [id: number]: CancellationTokenSource } = Object.create(null);
+	private readonly _proxy: ExtHostWorkspaceShape;
+	private readonly _queryBuilder = this._instantiationService.createInstance(QueryBuilder);
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@ISearchService private readonly _searchService: ISearchService,
+		@IWorkspaceContextService private readonly _contextService: IWorkspaceContextService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@IWorkspaceEditingService private readonly _workspaceEditingService: IWorkspaceEditingService,
+		@INotificationService private readonly _notificationService: INotificationService,
+		@IRequestService private readonly _requestService: IRequestService,
+		@IInstantiationService private readonly _instantiationService: IInstantiationService,
+		@ILabelService private readonly _labelService: ILabelService,
+		@IEnvironmentService private readonly _environmentService: IEnvironmentService,
+		@IFileService fileService: IFileService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostWorkspace);
+		const workspace = this._contextService.getWorkspace();
+		// The workspace file is provided be a unknown file system provider. It might come
+		// from the extension host. So initialize now knowing that `rootPath` is undefined.
+		if (workspace.configuration && !isNative && !fileService.canHandleResource(workspace.configuration)) {
+			this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace));
+		} else {
+			this._contextService.getCompleteWorkspace().then(workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace)));
+		}
+		this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
+		this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
+	}
+
+	dispose(): void {
+		this._toDispose.dispose();
+
+		for (let requestId in this._activeCancelTokens) {
+			const tokenSource = this._activeCancelTokens[requestId];
+			tokenSource.cancel();
+		}
+	}
+
+	// --- workspace ---
+
+	$updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, foldersToAdd: { uri: UriComponents, name?: string }[]): Promise<void> {
+		const workspaceFoldersToAdd = foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name }));
+
+		// Indicate in status message
+		this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000 /* 10s */ });
+
+		return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
+	}
+
+	private getStatusMessage(extensionName: string, addCount: number, removeCount: number): string {
+		let message: string;
+
+		const wantsToAdd = addCount > 0;
+		const wantsToDelete = removeCount > 0;
+
+		// Add Folders
+		if (wantsToAdd && !wantsToDelete) {
+			if (addCount === 1) {
+				message = localize('folderStatusMessageAddSingleFolder', "Extension '{0}' added 1 folder to the workspace", extensionName);
+			} else {
+				message = localize('folderStatusMessageAddMultipleFolders', "Extension '{0}' added {1} folders to the workspace", extensionName, addCount);
+			}
+		}
+
+		// Delete Folders
+		else if (wantsToDelete && !wantsToAdd) {
+			if (removeCount === 1) {
+				message = localize('folderStatusMessageRemoveSingleFolder', "Extension '{0}' removed 1 folder from the workspace", extensionName);
+			} else {
+				message = localize('folderStatusMessageRemoveMultipleFolders', "Extension '{0}' removed {1} folders from the workspace", extensionName, removeCount);
+			}
+		}
+
+		// Change Folders
+		else {
+			message = localize('folderStatusChangeFolder', "Extension '{0}' changed folders of the workspace", extensionName);
+		}
+
+		return message;
+	}
+
+	private _onDidChangeWorkspace(): void {
+		this._proxy.$acceptWorkspaceData(this.getWorkspaceData(this._contextService.getWorkspace()));
+	}
+
+	private getWorkspaceData(workspace: IWorkspace): IWorkspaceData | null {
+		if (this._contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
+			return null;
+		}
+		return {
+			configuration: workspace.configuration || undefined,
+			isUntitled: workspace.configuration ? isUntitledWorkspace(workspace.configuration, this._environmentService) : false,
+			folders: workspace.folders,
+			id: workspace.id,
+			name: this._labelService.getWorkspaceLabel(workspace)
+		};
+	}
+
+	// --- search ---
+
+	$startFileSearch(includePattern: string | null, _includeFolder: UriComponents | null, excludePatternOrDisregardExcludes: string | false | null, maxResults: number | null, token: CancellationToken): Promise<UriComponents[] | null> {
+		const includeFolder = URI.revive(_includeFolder);
+		const workspace = this._contextService.getWorkspace();
+		if (!workspace.folders.length) {
+			return Promise.resolve(null);
+		}
+
+		const query = this._queryBuilder.file(
+			includeFolder ? [toWorkspaceFolder(includeFolder)] : workspace.folders,
+			{
+				maxResults: withNullAsUndefined(maxResults),
+				disregardExcludeSettings: (excludePatternOrDisregardExcludes === false) || undefined,
+				disregardSearchExcludeSettings: true,
+				disregardIgnoreFiles: true,
+				includePattern: withNullAsUndefined(includePattern),
+				excludePattern: typeof excludePatternOrDisregardExcludes === 'string' ? excludePatternOrDisregardExcludes : undefined,
+				_reason: 'startFileSearch'
+			});
+
+		return this._searchService.fileSearch(query, token).then(result => {
+			return result.results.map(m => m.resource);
+		}, err => {
+			if (!isPromiseCanceledError(err)) {
+				return Promise.reject(err);
+			}
+			return null;
+		});
+	}
+
+	$startTextSearch(pattern: IPatternInfo, _folder: UriComponents | null, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Promise<ITextSearchComplete | null> {
+		const folder = URI.revive(_folder);
+		const workspace = this._contextService.getWorkspace();
+		const folders = folder ? [folder] : workspace.folders.map(folder => folder.uri);
+
+		const query = this._queryBuilder.text(pattern, folders, options);
+		query._reason = 'startTextSearch';
+
+		const onProgress = (p: ISearchProgressItem) => {
+			if ((<IFileMatch>p).results) {
+				this._proxy.$handleTextSearchResult(<IFileMatch>p, requestId);
+			}
+		};
+
+		const search = this._searchService.textSearch(query, token, onProgress).then(
+			result => {
+				return { limitHit: result.limitHit };
+			},
+			err => {
+				if (!isPromiseCanceledError(err)) {
+					return Promise.reject(err);
+				}
+
+				return null;
+			});
+
+		return search;
+	}
+
+	$checkExists(folders: readonly UriComponents[], includes: string[], token: CancellationToken): Promise<boolean> {
+		return this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token));
+	}
+
+	// --- save & edit resources ---
+
+	$saveAll(includeUntitled?: boolean): Promise<boolean> {
+		return this._editorService.saveAll({ includeUntitled });
+	}
+
+	$resolveProxy(url: string): Promise<string | undefined> {
+		return this._requestService.resolveProxy(url);
+	}
+}

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

@@ -0,0 +1,604 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { forEach } from 'vs/base/common/collections';
+import { IJSONSchema } from 'vs/base/common/jsonSchema';
+import * as resources from 'vs/base/common/resources';
+import { ExtensionMessageCollector, ExtensionsRegistry, IExtensionPoint, IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { ViewContainer, IViewsRegistry, ITreeViewDescriptor, IViewContainersRegistry, Extensions as ViewContainerExtensions, TEST_VIEW_CONTAINER_ID, IViewDescriptor, ViewContainerLocation } from 'vs/workbench/common/views';
+import { TreeViewPane } from 'vs/workbench/browser/parts/views/treeView';
+import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
+import { coalesce, } from 'vs/base/common/arrays';
+import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
+import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { VIEWLET_ID as EXPLORER } from 'vs/workbench/contrib/files/common/files';
+import { VIEWLET_ID as SCM } from 'vs/workbench/contrib/scm/common/scm';
+import { VIEWLET_ID as DEBUG } from 'vs/workbench/contrib/debug/common/debug';
+import { VIEWLET_ID as REMOTE } from 'vs/workbench/contrib/remote/browser/remoteExplorer';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { URI } from 'vs/base/common/uri';
+import { ViewletRegistry, Extensions as ViewletExtensions, ShowViewletAction } from 'vs/workbench/browser/viewlet';
+import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';
+import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { IWorkbenchActionRegistry, Extensions as ActionExtensions, CATEGORIES } from 'vs/workbench/common/actions';
+import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
+import { ViewPaneContainer } from 'vs/workbench/browser/parts/views/viewPaneContainer';
+import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
+import { Codicon } from 'vs/base/common/codicons';
+import { CustomTreeView } from 'vs/workbench/contrib/views/browser/treeView';
+import { WebviewViewPane } from 'vs/workbench/contrib/webviewView/browser/webviewViewPane';
+
+export interface IUserFriendlyViewsContainerDescriptor {
+	id: string;
+	title: string;
+	icon: string;
+}
+
+const viewsContainerSchema: IJSONSchema = {
+	type: 'object',
+	properties: {
+		id: {
+			description: localize({ key: 'vscode.extension.contributes.views.containers.id', comment: ['Contribution refers to those that an extension contributes to VS Code through an extension/contribution point. '] }, "Unique id used to identify the container in which views can be contributed using 'views' contribution point"),
+			type: 'string',
+			pattern: '^[a-zA-Z0-9_-]+$'
+		},
+		title: {
+			description: localize('vscode.extension.contributes.views.containers.title', 'Human readable string used to render the container'),
+			type: 'string'
+		},
+		icon: {
+			description: localize('vscode.extension.contributes.views.containers.icon', "Path to the container icon. Icons are 24x24 centered on a 50x40 block and have a fill color of 'rgb(215, 218, 224)' or '#d7dae0'. It is recommended that icons be in SVG, though any image file type is accepted."),
+			type: 'string'
+		}
+	},
+	required: ['id', 'title', 'icon']
+};
+
+export const viewsContainersContribution: IJSONSchema = {
+	description: localize('vscode.extension.contributes.viewsContainers', 'Contributes views containers to the editor'),
+	type: 'object',
+	properties: {
+		'activitybar': {
+			description: localize('views.container.activitybar', "Contribute views containers to Activity Bar"),
+			type: 'array',
+			items: viewsContainerSchema
+		},
+		'panel': {
+			description: localize('views.container.panel', "Contribute views containers to Panel"),
+			type: 'array',
+			items: viewsContainerSchema
+		}
+	}
+};
+
+enum ViewType {
+	Tree = 'tree',
+	Webview = 'webview'
+}
+
+
+interface IUserFriendlyViewDescriptor {
+	type?: ViewType;
+
+	id: string;
+	name: string;
+	when?: string;
+
+	icon?: string;
+	contextualTitle?: string;
+	visibility?: string;
+
+	// From 'remoteViewDescriptor' type
+	group?: string;
+	remoteName?: string | string[];
+}
+
+enum InitialVisibility {
+	Visible = 'visible',
+	Hidden = 'hidden',
+	Collapsed = 'collapsed'
+}
+
+const viewDescriptor: IJSONSchema = {
+	type: 'object',
+	required: ['id', 'name'],
+	defaultSnippets: [{ body: { id: '${1:id}', name: '${2:name}' } }],
+	properties: {
+		type: {
+			markdownDescription: localize('vscode.extension.contributes.view.type', "Type of the the view. This can either be `tree` for a tree view based view or `webview` for a webview based view. The default is `tree`."),
+			type: 'string',
+			enum: [
+				'tree',
+				'webview',
+			],
+			markdownEnumDescriptions: [
+				localize('vscode.extension.contributes.view.tree', "The view is backed by a `TreeView` created by `createTreeView`."),
+				localize('vscode.extension.contributes.view.webview', "The view is backed by a `WebviewView` registered by `registerWebviewViewProvider`."),
+			]
+		},
+		id: {
+			markdownDescription: localize('vscode.extension.contributes.view.id', 'Identifier of the view. This should be unique across all views. It is recommended to include your extension id as part of the view id. Use this to register a data provider through `vscode.window.registerTreeDataProviderForView` API. Also to trigger activating your extension by registering `onView:${id}` event to `activationEvents`.'),
+			type: 'string'
+		},
+		name: {
+			description: localize('vscode.extension.contributes.view.name', 'The human-readable name of the view. Will be shown'),
+			type: 'string'
+		},
+		when: {
+			description: localize('vscode.extension.contributes.view.when', 'Condition which must be true to show this view'),
+			type: 'string'
+		},
+		icon: {
+			description: localize('vscode.extension.contributes.view.icon', "Path to the view icon. View icons are displayed when the name of the view cannot be shown. It is recommended that icons be in SVG, though any image file type is accepted."),
+			type: 'string'
+		},
+		contextualTitle: {
+			description: localize('vscode.extension.contributes.view.contextualTitle', "Human-readable context for when the view is moved out of its original location. By default, the view's container name will be used. Will be shown"),
+			type: 'string'
+		},
+		visibility: {
+			description: localize('vscode.extension.contributes.view.initialState', "Initial state of the view when the extension is first installed. Once the user has changed the view state by collapsing, moving, or hiding the view, the initial state will not be used again."),
+			type: 'string',
+			enum: [
+				'visible',
+				'hidden',
+				'collapsed'
+			],
+			default: 'visible',
+			enumDescriptions: [
+				localize('vscode.extension.contributes.view.initialState.visible', "The default initial state for the view. In most containers the view will be expanded, however; some built-in containers (explorer, scm, and debug) show all contributed views collapsed regardless of the `visibility`."),
+				localize('vscode.extension.contributes.view.initialState.hidden', "The view will not be shown in the view container, but will be discoverable through the views menu and other view entry points and can be un-hidden by the user."),
+				localize('vscode.extension.contributes.view.initialState.collapsed', "The view will show in the view container, but will be collapsed.")
+			]
+		}
+	}
+};
+
+const remoteViewDescriptor: IJSONSchema = {
+	type: 'object',
+	properties: {
+		id: {
+			description: localize('vscode.extension.contributes.view.id', 'Identifier of the view. This should be unique across all views. It is recommended to include your extension id as part of the view id. Use this to register a data provider through `vscode.window.registerTreeDataProviderForView` API. Also to trigger activating your extension by registering `onView:${id}` event to `activationEvents`.'),
+			type: 'string'
+		},
+		name: {
+			description: localize('vscode.extension.contributes.view.name', 'The human-readable name of the view. Will be shown'),
+			type: 'string'
+		},
+		when: {
+			description: localize('vscode.extension.contributes.view.when', 'Condition which must be true to show this view'),
+			type: 'string'
+		},
+		group: {
+			description: localize('vscode.extension.contributes.view.group', 'Nested group in the viewlet'),
+			type: 'string'
+		},
+		remoteName: {
+			description: localize('vscode.extension.contributes.view.remoteName', 'The name of the remote type associated with this view'),
+			type: ['string', 'array'],
+			items: {
+				type: 'string'
+			}
+		}
+	}
+};
+const viewsContribution: IJSONSchema = {
+	description: localize('vscode.extension.contributes.views', "Contributes views to the editor"),
+	type: 'object',
+	properties: {
+		'explorer': {
+			description: localize('views.explorer', "Contributes views to Explorer container in the Activity bar"),
+			type: 'array',
+			items: viewDescriptor,
+			default: []
+		},
+		'debug': {
+			description: localize('views.debug', "Contributes views to Debug container in the Activity bar"),
+			type: 'array',
+			items: viewDescriptor,
+			default: []
+		},
+		'scm': {
+			description: localize('views.scm', "Contributes views to SCM container in the Activity bar"),
+			type: 'array',
+			items: viewDescriptor,
+			default: []
+		},
+		'test': {
+			description: localize('views.test', "Contributes views to Test container in the Activity bar"),
+			type: 'array',
+			items: viewDescriptor,
+			default: []
+		},
+		'remote': {
+			description: localize('views.remote', "Contributes views to Remote container in the Activity bar. To contribute to this container, enableProposedApi needs to be turned on"),
+			type: 'array',
+			items: remoteViewDescriptor,
+			default: []
+		}
+	},
+	additionalProperties: {
+		description: localize('views.contributed', "Contributes views to contributed views container"),
+		type: 'array',
+		items: viewDescriptor,
+		default: []
+	}
+};
+
+export interface ICustomTreeViewDescriptor extends ITreeViewDescriptor {
+	readonly extensionId: ExtensionIdentifier;
+	readonly originalContainerId: string;
+}
+
+export interface ICustomWebviewViewDescriptor extends IViewDescriptor {
+	readonly extensionId: ExtensionIdentifier;
+	readonly originalContainerId: string;
+}
+
+export type ICustomViewDescriptor = ICustomTreeViewDescriptor | ICustomWebviewViewDescriptor;
+
+type ViewContainerExtensionPointType = { [loc: string]: IUserFriendlyViewsContainerDescriptor[] };
+const viewsContainersExtensionPoint: IExtensionPoint<ViewContainerExtensionPointType> = ExtensionsRegistry.registerExtensionPoint<ViewContainerExtensionPointType>({
+	extensionPoint: 'viewsContainers',
+	jsonSchema: viewsContainersContribution
+});
+
+type ViewExtensionPointType = { [loc: string]: IUserFriendlyViewDescriptor[] };
+const viewsExtensionPoint: IExtensionPoint<ViewExtensionPointType> = ExtensionsRegistry.registerExtensionPoint<ViewExtensionPointType>({
+	extensionPoint: 'views',
+	deps: [viewsContainersExtensionPoint],
+	jsonSchema: viewsContribution
+});
+
+const TEST_VIEW_CONTAINER_ORDER = 6;
+class ViewsExtensionHandler implements IWorkbenchContribution {
+
+	private viewContainersRegistry: IViewContainersRegistry;
+	private viewsRegistry: IViewsRegistry;
+
+	constructor(
+		@IInstantiationService private readonly instantiationService: IInstantiationService
+	) {
+		this.viewContainersRegistry = Registry.as<IViewContainersRegistry>(ViewContainerExtensions.ViewContainersRegistry);
+		this.viewsRegistry = Registry.as<IViewsRegistry>(ViewContainerExtensions.ViewsRegistry);
+		this.handleAndRegisterCustomViewContainers();
+		this.handleAndRegisterCustomViews();
+	}
+
+	private handleAndRegisterCustomViewContainers() {
+		this.registerTestViewContainer();
+		viewsContainersExtensionPoint.setHandler((extensions, { added, removed }) => {
+			if (removed.length) {
+				this.removeCustomViewContainers(removed);
+			}
+			if (added.length) {
+				this.addCustomViewContainers(added, this.viewContainersRegistry.all);
+			}
+		});
+	}
+
+	private addCustomViewContainers(extensionPoints: readonly IExtensionPointUser<ViewContainerExtensionPointType>[], existingViewContainers: ViewContainer[]): void {
+		const viewContainersRegistry = Registry.as<IViewContainersRegistry>(ViewContainerExtensions.ViewContainersRegistry);
+		let activityBarOrder = TEST_VIEW_CONTAINER_ORDER + viewContainersRegistry.all.filter(v => !!v.extensionId && viewContainersRegistry.getViewContainerLocation(v) === ViewContainerLocation.Sidebar).length + 1;
+		let panelOrder = 5 + viewContainersRegistry.all.filter(v => !!v.extensionId && viewContainersRegistry.getViewContainerLocation(v) === ViewContainerLocation.Panel).length + 1;
+		for (let { value, collector, description } of extensionPoints) {
+			forEach(value, entry => {
+				if (!this.isValidViewsContainer(entry.value, collector)) {
+					return;
+				}
+				switch (entry.key) {
+					case 'activitybar':
+						activityBarOrder = this.registerCustomViewContainers(entry.value, description, activityBarOrder, existingViewContainers, ViewContainerLocation.Sidebar);
+						break;
+					case 'panel':
+						panelOrder = this.registerCustomViewContainers(entry.value, description, panelOrder, existingViewContainers, ViewContainerLocation.Panel);
+						break;
+				}
+			});
+		}
+	}
+
+	private removeCustomViewContainers(extensionPoints: readonly IExtensionPointUser<ViewContainerExtensionPointType>[]): void {
+		const viewContainersRegistry = Registry.as<IViewContainersRegistry>(ViewContainerExtensions.ViewContainersRegistry);
+		const removedExtensions: Set<string> = extensionPoints.reduce((result, e) => { result.add(ExtensionIdentifier.toKey(e.description.identifier)); return result; }, new Set<string>());
+		for (const viewContainer of viewContainersRegistry.all) {
+			if (viewContainer.extensionId && removedExtensions.has(ExtensionIdentifier.toKey(viewContainer.extensionId))) {
+				// move only those views that do not belong to the removed extension
+				const views = this.viewsRegistry.getViews(viewContainer).filter(view => !removedExtensions.has(ExtensionIdentifier.toKey((view as ICustomViewDescriptor).extensionId)));
+				if (views.length) {
+					this.viewsRegistry.moveViews(views, this.getDefaultViewContainer());
+				}
+				this.deregisterCustomViewContainer(viewContainer);
+			}
+		}
+	}
+
+	private registerTestViewContainer(): void {
+		const title = localize('test', "Test");
+		const icon = Codicon.beaker.classNames;
+
+		this.registerCustomViewContainer(TEST_VIEW_CONTAINER_ID, title, icon, TEST_VIEW_CONTAINER_ORDER, undefined, ViewContainerLocation.Sidebar);
+	}
+
+	private isValidViewsContainer(viewsContainersDescriptors: IUserFriendlyViewsContainerDescriptor[], collector: ExtensionMessageCollector): boolean {
+		if (!Array.isArray(viewsContainersDescriptors)) {
+			collector.error(localize('viewcontainer requirearray', "views containers must be an array"));
+			return false;
+		}
+
+		for (let descriptor of viewsContainersDescriptors) {
+			if (typeof descriptor.id !== 'string') {
+				collector.error(localize('requireidstring', "property `{0}` is mandatory and must be of type `string`. Only alphanumeric characters, '_', and '-' are allowed.", 'id'));
+				return false;
+			}
+			if (!(/^[a-z0-9_-]+$/i.test(descriptor.id))) {
+				collector.error(localize('requireidstring', "property `{0}` is mandatory and must be of type `string`. Only alphanumeric characters, '_', and '-' are allowed.", 'id'));
+				return false;
+			}
+			if (typeof descriptor.title !== 'string') {
+				collector.error(localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'title'));
+				return false;
+			}
+			if (typeof descriptor.icon !== 'string') {
+				collector.error(localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'icon'));
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	private registerCustomViewContainers(containers: IUserFriendlyViewsContainerDescriptor[], extension: IExtensionDescription, order: number, existingViewContainers: ViewContainer[], location: ViewContainerLocation): number {
+		containers.forEach(descriptor => {
+			const icon = resources.joinPath(extension.extensionLocation, descriptor.icon);
+			const id = `workbench.view.extension.${descriptor.id}`;
+			const viewContainer = this.registerCustomViewContainer(id, descriptor.title, icon, order++, extension.identifier, location);
+
+			// Move those views that belongs to this container
+			if (existingViewContainers.length) {
+				const viewsToMove: IViewDescriptor[] = [];
+				for (const existingViewContainer of existingViewContainers) {
+					if (viewContainer !== existingViewContainer) {
+						viewsToMove.push(...this.viewsRegistry.getViews(existingViewContainer).filter(view => (view as ICustomViewDescriptor).originalContainerId === descriptor.id));
+					}
+				}
+				if (viewsToMove.length) {
+					this.viewsRegistry.moveViews(viewsToMove, viewContainer);
+				}
+			}
+		});
+		return order;
+	}
+
+	private registerCustomViewContainer(id: string, title: string, icon: URI | string, order: number, extensionId: ExtensionIdentifier | undefined, location: ViewContainerLocation): ViewContainer {
+		let viewContainer = this.viewContainersRegistry.get(id);
+
+		if (!viewContainer) {
+
+			viewContainer = this.viewContainersRegistry.registerViewContainer({
+				id,
+				name: title, extensionId,
+				ctorDescriptor: new SyncDescriptor(
+					ViewPaneContainer,
+					[id, { mergeViewWithContainerWhenSingleView: true }]
+				),
+				hideIfEmpty: true,
+				order,
+				icon,
+			}, location);
+
+			// Register Action to Open Viewlet
+			class OpenCustomViewletAction extends ShowViewletAction {
+				constructor(
+					id: string, label: string,
+					@IViewletService viewletService: IViewletService,
+					@IEditorGroupsService editorGroupService: IEditorGroupsService,
+					@IWorkbenchLayoutService layoutService: IWorkbenchLayoutService
+				) {
+					super(id, label, id, viewletService, editorGroupService, layoutService);
+				}
+			}
+			const registry = Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions);
+			registry.registerWorkbenchAction(
+				SyncActionDescriptor.create(OpenCustomViewletAction, id, localize('showViewlet', "Show {0}", title)),
+				`View: Show ${title}`,
+				CATEGORIES.View.value
+			);
+		}
+
+		return viewContainer;
+	}
+
+	private deregisterCustomViewContainer(viewContainer: ViewContainer): void {
+		this.viewContainersRegistry.deregisterViewContainer(viewContainer);
+		Registry.as<ViewletRegistry>(ViewletExtensions.Viewlets).deregisterViewlet(viewContainer.id);
+	}
+
+	private handleAndRegisterCustomViews() {
+		viewsExtensionPoint.setHandler((extensions, { added, removed }) => {
+			if (removed.length) {
+				this.removeViews(removed);
+			}
+			if (added.length) {
+				this.addViews(added);
+			}
+		});
+	}
+
+	private addViews(extensions: readonly IExtensionPointUser<ViewExtensionPointType>[]): void {
+		const viewIds: Set<string> = new Set<string>();
+		const allViewDescriptors: { views: IViewDescriptor[], viewContainer: ViewContainer }[] = [];
+
+		for (const extension of extensions) {
+			const { value, collector } = extension;
+
+			forEach(value, entry => {
+				if (!this.isValidViewDescriptors(entry.value, collector)) {
+					return;
+				}
+
+				if (entry.key === 'remote' && !extension.description.enableProposedApi) {
+					collector.warn(localize('ViewContainerRequiresProposedAPI', "View container '{0}' requires 'enableProposedApi' turned on to be added to 'Remote'.", entry.key));
+					return;
+				}
+
+				const viewContainer = this.getViewContainer(entry.key);
+				if (!viewContainer) {
+					collector.warn(localize('ViewContainerDoesnotExist', "View container '{0}' does not exist and all views registered to it will be added to 'Explorer'.", entry.key));
+				}
+				const container = viewContainer || this.getDefaultViewContainer();
+				const viewDescriptors = coalesce(entry.value.map((item, index) => {
+					// validate
+					if (viewIds.has(item.id)) {
+						collector.error(localize('duplicateView1', "Cannot register multiple views with same id `{0}`", item.id));
+						return null;
+					}
+					if (this.viewsRegistry.getView(item.id) !== null) {
+						collector.error(localize('duplicateView2', "A view with id `{0}` is already registered.", item.id));
+						return null;
+					}
+
+					const order = ExtensionIdentifier.equals(extension.description.identifier, container.extensionId)
+						? index + 1
+						: container.viewOrderDelegate
+							? container.viewOrderDelegate.getOrder(item.group)
+							: undefined;
+
+					const icon = item.icon ? resources.joinPath(extension.description.extensionLocation, item.icon) : undefined;
+					const initialVisibility = this.convertInitialVisibility(item.visibility);
+
+					const type = this.getViewType(item.type);
+					if (!type) {
+						collector.error(localize('unknownViewType', "Unknown view type `{0}`.", item.type));
+						return null;
+					}
+
+					const viewDescriptor = <ICustomTreeViewDescriptor>{
+						type: type,
+						ctorDescriptor: type === ViewType.Tree ? new SyncDescriptor(TreeViewPane) : new SyncDescriptor(WebviewViewPane),
+						id: item.id,
+						name: item.name,
+						when: ContextKeyExpr.deserialize(item.when),
+						containerIcon: icon || viewContainer?.icon,
+						containerTitle: item.contextualTitle || viewContainer?.name,
+						canToggleVisibility: true,
+						canMoveView: viewContainer?.id !== REMOTE,
+						treeView: type === ViewType.Tree ? this.instantiationService.createInstance(CustomTreeView, item.id, item.name) : undefined,
+						collapsed: this.showCollapsed(container) || initialVisibility === InitialVisibility.Collapsed,
+						order: order,
+						extensionId: extension.description.identifier,
+						originalContainerId: entry.key,
+						group: item.group,
+						remoteAuthority: item.remoteName || (<any>item).remoteAuthority, // TODO@roblou - delete after remote extensions are updated
+						hideByDefault: initialVisibility === InitialVisibility.Hidden
+					};
+
+
+					viewIds.add(viewDescriptor.id);
+					return viewDescriptor;
+				}));
+
+				allViewDescriptors.push({ viewContainer: container, views: viewDescriptors });
+
+			});
+		}
+
+		this.viewsRegistry.registerViews2(allViewDescriptors);
+	}
+
+	private getViewType(type: string | undefined): ViewType | undefined {
+		if (type === ViewType.Webview) {
+			return ViewType.Webview;
+		}
+		if (!type || type === ViewType.Tree) {
+			return ViewType.Tree;
+		}
+		return undefined;
+	}
+
+	private getDefaultViewContainer(): ViewContainer {
+		return this.viewContainersRegistry.get(EXPLORER)!;
+	}
+
+	private removeViews(extensions: readonly IExtensionPointUser<ViewExtensionPointType>[]): void {
+		const removedExtensions: Set<string> = extensions.reduce((result, e) => { result.add(ExtensionIdentifier.toKey(e.description.identifier)); return result; }, new Set<string>());
+		for (const viewContainer of this.viewContainersRegistry.all) {
+			const removedViews = this.viewsRegistry.getViews(viewContainer).filter(v => (v as ICustomViewDescriptor).extensionId && removedExtensions.has(ExtensionIdentifier.toKey((v as ICustomViewDescriptor).extensionId)));
+			if (removedViews.length) {
+				this.viewsRegistry.deregisterViews(removedViews, viewContainer);
+			}
+		}
+	}
+
+	private convertInitialVisibility(value: any): InitialVisibility | undefined {
+		if (Object.values(InitialVisibility).includes(value)) {
+			return value;
+		}
+		return undefined;
+	}
+
+	private isValidViewDescriptors(viewDescriptors: IUserFriendlyViewDescriptor[], collector: ExtensionMessageCollector): boolean {
+		if (!Array.isArray(viewDescriptors)) {
+			collector.error(localize('requirearray', "views must be an array"));
+			return false;
+		}
+
+		for (let descriptor of viewDescriptors) {
+			if (typeof descriptor.id !== 'string') {
+				collector.error(localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'id'));
+				return false;
+			}
+			if (typeof descriptor.name !== 'string') {
+				collector.error(localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'name'));
+				return false;
+			}
+			if (descriptor.when && typeof descriptor.when !== 'string') {
+				collector.error(localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'when'));
+				return false;
+			}
+			if (descriptor.icon && typeof descriptor.icon !== 'string') {
+				collector.error(localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'icon'));
+				return false;
+			}
+			if (descriptor.contextualTitle && typeof descriptor.contextualTitle !== 'string') {
+				collector.error(localize('optstring', "property `{0}` can be omitted or must be of type `string`", 'contextualTitle'));
+				return false;
+			}
+			if (descriptor.visibility && !this.convertInitialVisibility(descriptor.visibility)) {
+				collector.error(localize('optenum', "property `{0}` can be omitted or must be one of {1}", 'visibility', Object.values(InitialVisibility).join(', ')));
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	private getViewContainer(value: string): ViewContainer | undefined {
+		switch (value) {
+			case 'explorer': return this.viewContainersRegistry.get(EXPLORER);
+			case 'debug': return this.viewContainersRegistry.get(DEBUG);
+			case 'scm': return this.viewContainersRegistry.get(SCM);
+			case 'remote': return this.viewContainersRegistry.get(REMOTE);
+			default: return this.viewContainersRegistry.get(`workbench.view.extension.${value}`);
+		}
+	}
+
+	private showCollapsed(container: ViewContainer): boolean {
+		switch (container.id) {
+			case EXPLORER:
+			case SCM:
+			case DEBUG:
+				return true;
+		}
+		return false;
+	}
+}
+
+const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
+workbenchRegistry.registerWorkbenchContribution(ViewsExtensionHandler, LifecyclePhase.Starting);

lib/vscode/src/vs/workbench/api/common/apiCommands.ts

@@ -0,0 +1,306 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from 'vscode';
+import { URI } from 'vs/base/common/uri';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import { CommandsRegistry, ICommandService, ICommandHandler } from 'vs/platform/commands/common/commands';
+import { ITextEditorOptions } from 'vs/platform/editor/common/editor';
+import { EditorViewColumn } from 'vs/workbench/api/common/shared/editor';
+import { EditorGroupLayout } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IOpenWindowOptions, IWindowOpenable, IOpenEmptyWindowOptions } from 'vs/platform/windows/common/windows';
+import { IWorkspacesService, hasWorkspaceFileExtension, IRecent } from 'vs/platform/workspaces/common/workspaces';
+import { Schemas } from 'vs/base/common/network';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IViewDescriptorService, IViewsService, ViewVisibilityState } from 'vs/workbench/common/views';
+
+// -----------------------------------------------------------------
+// The following commands are registered on both sides separately.
+//
+// We are trying to maintain backwards compatibility for cases where
+// API commands are encoded as markdown links, for example.
+// -----------------------------------------------------------------
+
+export interface ICommandsExecutor {
+	executeCommand<T>(id: string, ...args: any[]): Promise<T | undefined>;
+}
+
+function adjustHandler(handler: (executor: ICommandsExecutor, ...args: any[]) => any): ICommandHandler {
+	return (accessor, ...args: any[]) => {
+		return handler(accessor.get(ICommandService), ...args);
+	};
+}
+
+interface IOpenFolderAPICommandOptions {
+	forceNewWindow?: boolean;
+	forceReuseWindow?: boolean;
+	noRecentEntry?: boolean;
+}
+
+export class OpenFolderAPICommand {
+	public static readonly ID = 'vscode.openFolder';
+	public static execute(executor: ICommandsExecutor, uri?: URI, forceNewWindow?: boolean): Promise<any>;
+	public static execute(executor: ICommandsExecutor, uri?: URI, options?: IOpenFolderAPICommandOptions): Promise<any>;
+	public static execute(executor: ICommandsExecutor, uri?: URI, arg: boolean | IOpenFolderAPICommandOptions = {}): Promise<any> {
+		if (typeof arg === 'boolean') {
+			arg = { forceNewWindow: arg };
+		}
+		if (!uri) {
+			return executor.executeCommand('_files.pickFolderAndOpen', { forceNewWindow: arg.forceNewWindow });
+		}
+		const options: IOpenWindowOptions = { forceNewWindow: arg.forceNewWindow, forceReuseWindow: arg.forceReuseWindow, noRecentEntry: arg.noRecentEntry };
+		uri = URI.revive(uri);
+		const uriToOpen: IWindowOpenable = (hasWorkspaceFileExtension(uri) || uri.scheme === Schemas.untitled) ? { workspaceUri: uri } : { folderUri: uri };
+		return executor.executeCommand('_files.windowOpen', [uriToOpen], options);
+	}
+}
+CommandsRegistry.registerCommand({
+	id: OpenFolderAPICommand.ID,
+	handler: adjustHandler(OpenFolderAPICommand.execute),
+	description: {
+		description: 'Open a folder or workspace in the current window or new window depending on the newWindow argument. Note that opening in the same window will shutdown the current extension host process and start a new one on the given folder/workspace unless the newWindow parameter is set to true.',
+		args: [
+			{ name: 'uri', description: '(optional) Uri of the folder or workspace file to open. If not provided, a native dialog will ask the user for the folder', constraint: (value: any) => value === undefined || value instanceof URI },
+			{ name: 'options', description: '(optional) Options. Object with the following properties: `forceNewWindow `: Whether to open the folder/workspace in a new window or the same. Defaults to opening in the same window. `noRecentEntry`: Wheter the opened URI will appear in the \'Open Recent\' list. Defaults to true.  Note, for backward compatibility, options can also be of type boolean, representing the `forceNewWindow` setting.', constraint: (value: any) => value === undefined || typeof value === 'object' || typeof value === 'boolean' }
+		]
+	}
+});
+
+interface INewWindowAPICommandOptions {
+	reuseWindow?: boolean;
+	remoteAuthority?: string;
+}
+
+export class NewWindowAPICommand {
+	public static readonly ID = 'vscode.newWindow';
+	public static execute(executor: ICommandsExecutor, options?: INewWindowAPICommandOptions): Promise<any> {
+		const commandOptions: IOpenEmptyWindowOptions = {
+			forceReuseWindow: options && options.reuseWindow,
+			remoteAuthority: options && options.remoteAuthority
+		};
+
+		return executor.executeCommand('_files.newWindow', commandOptions);
+	}
+}
+CommandsRegistry.registerCommand({
+	id: NewWindowAPICommand.ID,
+	handler: adjustHandler(NewWindowAPICommand.execute),
+	description: {
+		description: 'Opens an new window',
+		args: [
+		]
+	}
+});
+
+export class DiffAPICommand {
+	public static readonly ID = 'vscode.diff';
+	public static execute(executor: ICommandsExecutor, left: URI, right: URI, label: string, options?: typeConverters.TextEditorOpenOptions): Promise<any> {
+		return executor.executeCommand('_workbench.diff', [
+			left, right,
+			label,
+			undefined,
+			typeConverters.TextEditorOpenOptions.from(options),
+			options ? typeConverters.ViewColumn.from(options.viewColumn) : undefined
+		]);
+	}
+}
+CommandsRegistry.registerCommand(DiffAPICommand.ID, adjustHandler(DiffAPICommand.execute));
+
+export class OpenAPICommand {
+	public static readonly ID = 'vscode.open';
+	public static execute(executor: ICommandsExecutor, resource: URI, columnOrOptions?: vscode.ViewColumn | typeConverters.TextEditorOpenOptions, label?: string): Promise<any> {
+		let options: ITextEditorOptions | undefined;
+		let position: EditorViewColumn | undefined;
+
+		if (columnOrOptions) {
+			if (typeof columnOrOptions === 'number') {
+				position = typeConverters.ViewColumn.from(columnOrOptions);
+			} else {
+				options = typeConverters.TextEditorOpenOptions.from(columnOrOptions);
+				position = typeConverters.ViewColumn.from(columnOrOptions.viewColumn);
+			}
+		}
+
+		return executor.executeCommand('_workbench.open', [
+			resource,
+			options,
+			position,
+			label
+		]);
+	}
+}
+CommandsRegistry.registerCommand(OpenAPICommand.ID, adjustHandler(OpenAPICommand.execute));
+
+export class OpenWithAPICommand {
+	public static readonly ID = 'vscode.openWith';
+	public static execute(executor: ICommandsExecutor, resource: URI, viewType: string, columnOrOptions?: vscode.ViewColumn | typeConverters.TextEditorOpenOptions): Promise<any> {
+		let options: ITextEditorOptions | undefined;
+		let position: EditorViewColumn | undefined;
+
+		if (typeof columnOrOptions === 'number') {
+			position = typeConverters.ViewColumn.from(columnOrOptions);
+		} else if (typeof columnOrOptions !== 'undefined') {
+			options = typeConverters.TextEditorOpenOptions.from(columnOrOptions);
+		}
+
+		return executor.executeCommand('_workbench.openWith', [
+			resource,
+			viewType,
+			options,
+			position
+		]);
+	}
+}
+CommandsRegistry.registerCommand(OpenWithAPICommand.ID, adjustHandler(OpenWithAPICommand.execute));
+
+CommandsRegistry.registerCommand('_workbench.removeFromRecentlyOpened', function (accessor: ServicesAccessor, uri: URI) {
+	const workspacesService = accessor.get(IWorkspacesService);
+	return workspacesService.removeRecentlyOpened([uri]);
+});
+
+export class RemoveFromRecentlyOpenedAPICommand {
+	public static readonly ID = 'vscode.removeFromRecentlyOpened';
+	public static execute(executor: ICommandsExecutor, path: string | URI): Promise<any> {
+		if (typeof path === 'string') {
+			path = path.match(/^[^:/?#]+:\/\//) ? URI.parse(path) : URI.file(path);
+		} else {
+			path = URI.revive(path); // called from extension host
+		}
+		return executor.executeCommand('_workbench.removeFromRecentlyOpened', path);
+	}
+}
+CommandsRegistry.registerCommand(RemoveFromRecentlyOpenedAPICommand.ID, adjustHandler(RemoveFromRecentlyOpenedAPICommand.execute));
+
+export interface OpenIssueReporterArgs {
+	readonly extensionId: string;
+	readonly issueTitle?: string;
+	readonly issueBody?: string;
+}
+
+export class OpenIssueReporter {
+	public static readonly ID = 'vscode.openIssueReporter';
+
+	public static execute(executor: ICommandsExecutor, args: string | OpenIssueReporterArgs): Promise<void> {
+		const commandArgs = typeof args === 'string'
+			? { extensionId: args }
+			: args;
+		return executor.executeCommand('workbench.action.openIssueReporter', commandArgs);
+	}
+}
+
+interface RecentEntry {
+	uri: URI;
+	type: 'workspace' | 'folder' | 'file';
+	label?: string;
+}
+
+CommandsRegistry.registerCommand('_workbench.addToRecentlyOpened', async function (accessor: ServicesAccessor, recentEntry: RecentEntry) {
+	const workspacesService = accessor.get(IWorkspacesService);
+	let recent: IRecent | undefined = undefined;
+	const uri = recentEntry.uri;
+	const label = recentEntry.label;
+	if (recentEntry.type === 'workspace') {
+		const workspace = await workspacesService.getWorkspaceIdentifier(uri);
+		recent = { workspace, label };
+	} else if (recentEntry.type === 'folder') {
+		recent = { folderUri: uri, label };
+	} else {
+		recent = { fileUri: uri, label };
+	}
+	return workspacesService.addRecentlyOpened([recent]);
+});
+
+CommandsRegistry.registerCommand('_workbench.getRecentlyOpened', async function (accessor: ServicesAccessor) {
+	const workspacesService = accessor.get(IWorkspacesService);
+	return workspacesService.getRecentlyOpened();
+});
+
+export class SetEditorLayoutAPICommand {
+	public static readonly ID = 'vscode.setEditorLayout';
+	public static execute(executor: ICommandsExecutor, layout: EditorGroupLayout): Promise<any> {
+		return executor.executeCommand('layoutEditorGroups', layout);
+	}
+}
+CommandsRegistry.registerCommand({
+	id: SetEditorLayoutAPICommand.ID,
+	handler: adjustHandler(SetEditorLayoutAPICommand.execute),
+	description: {
+		description: 'Set Editor Layout',
+		args: [{
+			name: 'args',
+			schema: {
+				'type': 'object',
+				'required': ['groups'],
+				'properties': {
+					'orientation': {
+						'type': 'number',
+						'default': 0,
+						'enum': [0, 1]
+					},
+					'groups': {
+						'$ref': '#/definitions/editorGroupsSchema', // defined in keybindingService.ts ...
+						'default': [{}, {}],
+					}
+				}
+			}
+		}]
+	}
+});
+
+CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (accessor: ServicesAccessor, level: number) {
+	const logService = accessor.get(ILogService);
+	const environmentService = accessor.get(IEnvironmentService);
+
+	if (environmentService.isExtensionDevelopment && !!environmentService.extensionTestsLocationURI) {
+		logService.setLevel(level);
+	}
+});
+
+CommandsRegistry.registerCommand('_extensionTests.getLogLevel', function (accessor: ServicesAccessor) {
+	const logService = accessor.get(ILogService);
+
+	return logService.getLevel();
+});
+
+
+CommandsRegistry.registerCommand('_workbench.action.moveViews', async function (accessor: ServicesAccessor, options: { viewIds: string[], destinationId: string }) {
+	const viewDescriptorService = accessor.get(IViewDescriptorService);
+
+	const destination = viewDescriptorService.getViewContainerById(options.destinationId);
+	if (!destination) {
+		return;
+	}
+
+	// FYI, don't use `moveViewsToContainer` in 1 shot, because it expects all views to have the same current location
+	for (const viewId of options.viewIds) {
+		const viewDescriptor = viewDescriptorService.getViewDescriptorById(viewId);
+		if (viewDescriptor?.canMoveView) {
+			viewDescriptorService.moveViewsToContainer([viewDescriptor], destination, ViewVisibilityState.Default);
+		}
+	}
+
+	await accessor.get(IViewsService).openViewContainer(destination.id, true);
+});
+
+export class MoveViewsAPICommand {
+	public static readonly ID = 'vscode.moveViews';
+	public static execute(executor: ICommandsExecutor, options: { viewIds: string[], destinationId: string }): Promise<any> {
+		if (!Array.isArray(options?.viewIds) || typeof options?.destinationId !== 'string') {
+			return Promise.reject('Invalid arguments');
+		}
+
+		return executor.executeCommand('_workbench.action.moveViews', options);
+	}
+}
+CommandsRegistry.registerCommand({
+	id: MoveViewsAPICommand.ID,
+	handler: adjustHandler(MoveViewsAPICommand.execute),
+	description: {
+		description: 'Move Views',
+		args: []
+	}
+});

lib/vscode/src/vs/workbench/api/common/cache.ts

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export class Cache<T> {
+
+	private static readonly enableDebugLogging = false;
+
+	private readonly _data = new Map<number, readonly T[]>();
+	private _idPool = 1;
+
+	constructor(
+		private readonly id: string
+	) { }
+
+	add(item: readonly T[]): number {
+		const id = this._idPool++;
+		this._data.set(id, item);
+		this.logDebugInfo();
+		return id;
+	}
+
+	get(pid: number, id: number): T | undefined {
+		return this._data.has(pid) ? this._data.get(pid)![id] : undefined;
+	}
+
+	delete(id: number) {
+		this._data.delete(id);
+		this.logDebugInfo();
+	}
+
+	private logDebugInfo() {
+		if (!Cache.enableDebugLogging) {
+			return;
+		}
+		console.log(`${this.id} cache size — ${this._data.size}`);
+	}
+}

lib/vscode/src/vs/workbench/api/common/configurationExtensionPoint.ts

@@ -0,0 +1,323 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import * as objects from 'vs/base/common/objects';
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IJSONSchema } from 'vs/base/common/jsonSchema';
+import { ExtensionsRegistry, IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { IConfigurationNode, IConfigurationRegistry, Extensions, resourceLanguageSettingsSchemaId, validateProperty, ConfigurationScope, OVERRIDE_PROPERTY_PATTERN } from 'vs/platform/configuration/common/configurationRegistry';
+import { IJSONContributionRegistry, Extensions as JSONExtensions } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { workspaceSettingsSchemaId, launchSchemaId, tasksSchemaId } from 'vs/workbench/services/configuration/common/configuration';
+import { isObject } from 'vs/base/common/types';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { IStringDictionary } from 'vs/base/common/collections';
+
+const configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
+
+const configurationEntrySchema: IJSONSchema = {
+	type: 'object',
+	defaultSnippets: [{ body: { title: '', properties: {} } }],
+	properties: {
+		title: {
+			description: nls.localize('vscode.extension.contributes.configuration.title', 'A summary of the settings. This label will be used in the settings file as separating comment.'),
+			type: 'string'
+		},
+		properties: {
+			description: nls.localize('vscode.extension.contributes.configuration.properties', 'Description of the configuration properties.'),
+			type: 'object',
+			additionalProperties: {
+				anyOf: [
+					{ $ref: 'http://json-schema.org/draft-07/schema#' },
+					{
+						type: 'object',
+						properties: {
+							isExecutable: {
+								type: 'boolean',
+								deprecationMessage: 'This property is deprecated. Instead use `scope` property and set it to `machine` value.'
+							},
+							scope: {
+								type: 'string',
+								enum: ['application', 'machine', 'window', 'resource', 'language-overridable', 'machine-overridable'],
+								default: 'window',
+								enumDescriptions: [
+									nls.localize('scope.application.description', "Configuration that can be configured only in the user settings."),
+									nls.localize('scope.machine.description', "Configuration that can be configured only in the user settings or only in the remote settings."),
+									nls.localize('scope.window.description', "Configuration that can be configured in the user, remote or workspace settings."),
+									nls.localize('scope.resource.description', "Configuration that can be configured in the user, remote, workspace or folder settings."),
+									nls.localize('scope.language-overridable.description', "Resource configuration that can be configured in language specific settings."),
+									nls.localize('scope.machine-overridable.description', "Machine configuration that can be configured also in workspace or folder settings.")
+								],
+								description: nls.localize('scope.description', "Scope in which the configuration is applicable. Available scopes are `application`, `machine`, `window`, `resource`, and `machine-overridable`.")
+							},
+							enumDescriptions: {
+								type: 'array',
+								items: {
+									type: 'string',
+								},
+								description: nls.localize('scope.enumDescriptions', 'Descriptions for enum values')
+							},
+							markdownEnumDescriptions: {
+								type: 'array',
+								items: {
+									type: 'string',
+								},
+								description: nls.localize('scope.markdownEnumDescriptions', 'Descriptions for enum values in the markdown format.')
+							},
+							markdownDescription: {
+								type: 'string',
+								description: nls.localize('scope.markdownDescription', 'The description in the markdown format.')
+							},
+							deprecationMessage: {
+								type: 'string',
+								description: nls.localize('scope.deprecationMessage', 'If set, the property is marked as deprecated and the given message is shown as an explanation.')
+							},
+							markdownDeprecationMessage: {
+								type: 'string',
+								description: nls.localize('scope.markdownDeprecationMessage', 'If set, the property is marked as deprecated and the given message is shown as an explanation in the markdown format.')
+							}
+						}
+					}
+				]
+			}
+		}
+	}
+};
+
+// BEGIN VSCode extension point `configurationDefaults`
+const defaultConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint<IConfigurationNode>({
+	extensionPoint: 'configurationDefaults',
+	jsonSchema: {
+		description: nls.localize('vscode.extension.contributes.defaultConfiguration', 'Contributes default editor configuration settings by language.'),
+		type: 'object',
+		patternProperties: {
+			'^\\[.*\\]$': {
+				type: 'object',
+				default: {},
+				$ref: resourceLanguageSettingsSchemaId,
+			}
+		},
+		errorMessage: nls.localize('config.property.defaultConfiguration.languageExpected', "Language selector expected (e.g. [\"java\"])"),
+		additionalProperties: false
+	}
+});
+defaultConfigurationExtPoint.setHandler((extensions, { added, removed }) => {
+	if (removed.length) {
+		const removedDefaultConfigurations = removed.map<IStringDictionary<any>>(extension => objects.deepClone(extension.value));
+		configurationRegistry.deregisterDefaultConfigurations(removedDefaultConfigurations);
+	}
+	if (added.length) {
+		const addedDefaultConfigurations = added.map<IStringDictionary<any>>(extension => {
+			const defaults: IStringDictionary<any> = objects.deepClone(extension.value);
+			for (const key of Object.keys(defaults)) {
+				if (!OVERRIDE_PROPERTY_PATTERN.test(key) || typeof defaults[key] !== 'object') {
+					extension.collector.warn(nls.localize('config.property.defaultConfiguration.warning', "Cannot register configuration defaults for '{0}'. Only defaults for language specific settings are supported.", key));
+					delete defaults[key];
+				}
+			}
+			return defaults;
+		});
+		configurationRegistry.registerDefaultConfigurations(addedDefaultConfigurations);
+	}
+});
+// END VSCode extension point `configurationDefaults`
+
+
+// BEGIN VSCode extension point `configuration`
+const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint<IConfigurationNode>({
+	extensionPoint: 'configuration',
+	deps: [defaultConfigurationExtPoint],
+	jsonSchema: {
+		description: nls.localize('vscode.extension.contributes.configuration', 'Contributes configuration settings.'),
+		oneOf: [
+			configurationEntrySchema,
+			{
+				type: 'array',
+				items: configurationEntrySchema
+			}
+		]
+	}
+});
+
+const extensionConfigurations: Map<string, IConfigurationNode[]> = new Map<string, IConfigurationNode[]>();
+
+configurationExtPoint.setHandler((extensions, { added, removed }) => {
+
+	if (removed.length) {
+		const removedConfigurations: IConfigurationNode[] = [];
+		for (const extension of removed) {
+			const key = ExtensionIdentifier.toKey(extension.description.identifier);
+			removedConfigurations.push(...(extensionConfigurations.get(key) || []));
+			extensionConfigurations.delete(key);
+		}
+		configurationRegistry.deregisterConfigurations(removedConfigurations);
+	}
+
+	function handleConfiguration(node: IConfigurationNode, extension: IExtensionPointUser<any>): IConfigurationNode[] {
+		const configurations: IConfigurationNode[] = [];
+		let configuration = objects.deepClone(node);
+
+		if (configuration.title && (typeof configuration.title !== 'string')) {
+			extension.collector.error(nls.localize('invalid.title', "'configuration.title' must be a string"));
+		}
+
+		validateProperties(configuration, extension);
+
+		configuration.id = node.id || extension.description.identifier.value;
+		configuration.extensionInfo = { id: extension.description.identifier.value };
+		configuration.title = configuration.title || extension.description.displayName || extension.description.identifier.value;
+		configurations.push(configuration);
+		return configurations;
+	}
+
+	if (added.length) {
+		const addedConfigurations: IConfigurationNode[] = [];
+		for (let extension of added) {
+			const configurations: IConfigurationNode[] = [];
+			const value = <IConfigurationNode | IConfigurationNode[]>extension.value;
+			if (!Array.isArray(value)) {
+				configurations.push(...handleConfiguration(value, extension));
+			} else {
+				value.forEach(v => configurations.push(...handleConfiguration(v, extension)));
+			}
+			extensionConfigurations.set(ExtensionIdentifier.toKey(extension.description.identifier), configurations);
+			addedConfigurations.push(...configurations);
+		}
+
+		configurationRegistry.registerConfigurations(addedConfigurations, false);
+	}
+
+});
+// END VSCode extension point `configuration`
+
+function validateProperties(configuration: IConfigurationNode, extension: IExtensionPointUser<any>): void {
+	let properties = configuration.properties;
+	if (properties) {
+		if (typeof properties !== 'object') {
+			extension.collector.error(nls.localize('invalid.properties', "'configuration.properties' must be an object"));
+			configuration.properties = {};
+		}
+		for (let key in properties) {
+			const message = validateProperty(key);
+			if (message) {
+				delete properties[key];
+				extension.collector.warn(message);
+				continue;
+			}
+			const propertyConfiguration = properties[key];
+			if (!isObject(propertyConfiguration)) {
+				delete properties[key];
+				extension.collector.error(nls.localize('invalid.property', "'configuration.property' must be an object"));
+				continue;
+			}
+			if (propertyConfiguration.scope) {
+				if (propertyConfiguration.scope.toString() === 'application') {
+					propertyConfiguration.scope = ConfigurationScope.APPLICATION;
+				} else if (propertyConfiguration.scope.toString() === 'machine') {
+					propertyConfiguration.scope = ConfigurationScope.MACHINE;
+				} else if (propertyConfiguration.scope.toString() === 'resource') {
+					propertyConfiguration.scope = ConfigurationScope.RESOURCE;
+				} else if (propertyConfiguration.scope.toString() === 'machine-overridable') {
+					propertyConfiguration.scope = ConfigurationScope.MACHINE_OVERRIDABLE;
+				} else if (propertyConfiguration.scope.toString() === 'language-overridable') {
+					propertyConfiguration.scope = ConfigurationScope.LANGUAGE_OVERRIDABLE;
+				} else {
+					propertyConfiguration.scope = ConfigurationScope.WINDOW;
+				}
+			} else {
+				propertyConfiguration.scope = ConfigurationScope.WINDOW;
+			}
+		}
+	}
+	let subNodes = configuration.allOf;
+	if (subNodes) {
+		extension.collector.error(nls.localize('invalid.allOf', "'configuration.allOf' is deprecated and should no longer be used. Instead, pass multiple configuration sections as an array to the 'configuration' contribution point."));
+		for (let node of subNodes) {
+			validateProperties(node, extension);
+		}
+	}
+}
+
+const jsonRegistry = Registry.as<IJSONContributionRegistry>(JSONExtensions.JSONContribution);
+jsonRegistry.registerSchema('vscode://schemas/workspaceConfig', {
+	allowComments: true,
+	allowTrailingCommas: true,
+	default: {
+		folders: [
+			{
+				path: ''
+			}
+		],
+		settings: {
+		}
+	},
+	required: ['folders'],
+	properties: {
+		'folders': {
+			minItems: 0,
+			uniqueItems: true,
+			description: nls.localize('workspaceConfig.folders.description', "List of folders to be loaded in the workspace."),
+			items: {
+				type: 'object',
+				default: { path: '' },
+				oneOf: [{
+					properties: {
+						path: {
+							type: 'string',
+							description: nls.localize('workspaceConfig.path.description', "A file path. e.g. `/root/folderA` or `./folderA` for a relative path that will be resolved against the location of the workspace file.")
+						},
+						name: {
+							type: 'string',
+							description: nls.localize('workspaceConfig.name.description', "An optional name for the folder. ")
+						}
+					},
+					required: ['path']
+				}, {
+					properties: {
+						uri: {
+							type: 'string',
+							description: nls.localize('workspaceConfig.uri.description', "URI of the folder")
+						},
+						name: {
+							type: 'string',
+							description: nls.localize('workspaceConfig.name.description', "An optional name for the folder. ")
+						}
+					},
+					required: ['uri']
+				}]
+			}
+		},
+		'settings': {
+			type: 'object',
+			default: {},
+			description: nls.localize('workspaceConfig.settings.description', "Workspace settings"),
+			$ref: workspaceSettingsSchemaId
+		},
+		'launch': {
+			type: 'object',
+			default: { configurations: [], compounds: [] },
+			description: nls.localize('workspaceConfig.launch.description', "Workspace launch configurations"),
+			$ref: launchSchemaId
+		},
+		'tasks': {
+			type: 'object',
+			default: { version: '2.0.0', tasks: [] },
+			description: nls.localize('workspaceConfig.tasks.description', "Workspace task configurations"),
+			$ref: tasksSchemaId
+		},
+		'extensions': {
+			type: 'object',
+			default: {},
+			description: nls.localize('workspaceConfig.extensions.description', "Workspace extensions"),
+			$ref: 'vscode://schemas/extensions'
+		},
+		'remoteAuthority': {
+			type: 'string',
+			doNotSuggest: true,
+			description: nls.localize('workspaceConfig.remoteAuthority', "The remote server where the workspace is located. Only used by unsaved remote workspaces."),
+		}
+	},
+	errorMessage: nls.localize('unknownWorkspaceProperty', "Unknown workspace configuration property")
+});

lib/vscode/src/vs/workbench/api/common/extHost.common.services.ts

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { IExtHostOutputService, ExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+import { IExtHostWorkspace, ExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
+import { IExtHostDecorations, ExtHostDecorations } from 'vs/workbench/api/common/extHostDecorations';
+import { IExtHostConfiguration, ExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
+import { IExtHostCommands, ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { IExtHostTerminalService, WorkerExtHostTerminalService } from 'vs/workbench/api/common/extHostTerminalService';
+import { IExtHostTask, WorkerExtHostTask } from 'vs/workbench/api/common/extHostTask';
+import { IExtHostDebugService, WorkerExtHostDebugService } from 'vs/workbench/api/common/extHostDebugService';
+import { IExtHostSearch, ExtHostSearch } from 'vs/workbench/api/common/extHostSearch';
+import { IExtensionStoragePaths, ExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePaths';
+import { IExtHostStorage, ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { IExtHostTunnelService, ExtHostTunnelService } from 'vs/workbench/api/common/extHostTunnelService';
+import { IExtHostApiDeprecationService, ExtHostApiDeprecationService, } from 'vs/workbench/api/common/extHostApiDeprecationService';
+import { IExtHostWindow, ExtHostWindow } from 'vs/workbench/api/common/extHostWindow';
+import { IExtHostConsumerFileSystem, ExtHostConsumerFileSystem } from 'vs/workbench/api/common/extHostFileSystemConsumer';
+import { IExtHostFileSystemInfo, ExtHostFileSystemInfo } from 'vs/workbench/api/common/extHostFileSystemInfo';
+
+registerSingleton(IExtensionStoragePaths, ExtensionStoragePaths);
+registerSingleton(IExtHostApiDeprecationService, ExtHostApiDeprecationService);
+registerSingleton(IExtHostCommands, ExtHostCommands);
+registerSingleton(IExtHostConfiguration, ExtHostConfiguration);
+registerSingleton(IExtHostConsumerFileSystem, ExtHostConsumerFileSystem);
+registerSingleton(IExtHostDebugService, WorkerExtHostDebugService);
+registerSingleton(IExtHostDecorations, ExtHostDecorations);
+registerSingleton(IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors);
+registerSingleton(IExtHostFileSystemInfo, ExtHostFileSystemInfo);
+registerSingleton(IExtHostOutputService, ExtHostOutputService);
+registerSingleton(IExtHostSearch, ExtHostSearch);
+registerSingleton(IExtHostStorage, ExtHostStorage);
+registerSingleton(IExtHostTask, WorkerExtHostTask);
+registerSingleton(IExtHostTerminalService, WorkerExtHostTerminalService);
+registerSingleton(IExtHostTunnelService, ExtHostTunnelService);
+registerSingleton(IExtHostWindow, ExtHostWindow);
+registerSingleton(IExtHostWorkspace, ExtHostWorkspace);

lib/vscode/src/vs/workbench/api/common/extHostApiCommands.ts

@@ -0,0 +1,536 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
+import type * as vscode from 'vscode';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import * as types from 'vs/workbench/api/common/extHostTypes';
+import { IRawColorInfo, IWorkspaceEditDto, ICallHierarchyItemDto, IIncomingCallDto, IOutgoingCallDto } from 'vs/workbench/api/common/extHost.protocol';
+import * as modes from 'vs/editor/common/modes';
+import * as search from 'vs/workbench/contrib/search/common/search';
+import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { CustomCodeAction } from 'vs/workbench/api/common/extHostLanguageFeatures';
+import { ICommandsExecutor, OpenFolderAPICommand, DiffAPICommand, OpenAPICommand, RemoveFromRecentlyOpenedAPICommand, SetEditorLayoutAPICommand, OpenIssueReporter, OpenIssueReporterArgs } from './apiCommands';
+import { EditorGroupLayout } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { isFalsyOrEmpty } from 'vs/base/common/arrays';
+import { IRange } from 'vs/editor/common/core/range';
+import { IPosition } from 'vs/editor/common/core/position';
+import { TransientMetadata } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+
+//#region --- NEW world
+
+export class ApiCommandArgument<V, O = V> {
+
+	static readonly Uri = new ApiCommandArgument<URI>('uri', 'Uri of a text document', v => URI.isUri(v), v => v);
+	static readonly Position = new ApiCommandArgument<types.Position, IPosition>('position', 'A position in a text document', v => types.Position.isPosition(v), typeConverters.Position.from);
+	static readonly Range = new ApiCommandArgument<types.Range, IRange>('range', 'A range in a text document', v => types.Range.isRange(v), typeConverters.Range.from);
+
+	static readonly CallHierarchyItem = new ApiCommandArgument('item', 'A call hierarchy item', v => v instanceof types.CallHierarchyItem, typeConverters.CallHierarchyItem.to);
+
+	constructor(
+		readonly name: string,
+		readonly description: string,
+		readonly validate: (v: V) => boolean,
+		readonly convert: (v: V) => O
+	) { }
+}
+
+export class ApiCommandResult<V, O = V> {
+
+	constructor(
+		readonly description: string,
+		readonly convert: (v: V, apiArgs: any[]) => O
+	) { }
+}
+
+export class ApiCommand {
+
+	constructor(
+		readonly id: string,
+		readonly internalId: string,
+		readonly description: string,
+		readonly args: ApiCommandArgument<any, any>[],
+		readonly result: ApiCommandResult<any, any>
+	) { }
+
+	register(commands: ExtHostCommands): IDisposable {
+
+		return commands.registerCommand(false, this.id, async (...apiArgs) => {
+
+			const internalArgs = this.args.map((arg, i) => {
+				if (!arg.validate(apiArgs[i])) {
+					throw new Error(`Invalid argument '${arg.name}' when running '${this.id}', receieved: ${apiArgs[i]}`);
+				}
+				return arg.convert(apiArgs[i]);
+			});
+
+			const internalResult = await commands.executeCommand(this.internalId, ...internalArgs);
+			return this.result.convert(internalResult, apiArgs);
+		}, undefined, this._getCommandHandlerDesc());
+	}
+
+	private _getCommandHandlerDesc(): ICommandHandlerDescription {
+		return {
+			description: this.description,
+			args: this.args,
+			returns: this.result.description
+		};
+	}
+}
+
+
+const newCommands: ApiCommand[] = [
+	// -- document highlights
+	new ApiCommand(
+		'vscode.executeDocumentHighlights', '_executeDocumentHighlights', 'Execute document highlight provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.DocumentHighlight[], types.DocumentHighlight[] | undefined>('A promise that resolves to an array of SymbolInformation and DocumentSymbol instances.', tryMapWith(typeConverters.DocumentHighlight.to))
+	),
+	// -- document symbols
+	new ApiCommand(
+		'vscode.executeDocumentSymbolProvider', '_executeDocumentSymbolProvider', 'Execute document symbol provider.',
+		[ApiCommandArgument.Uri],
+		new ApiCommandResult<modes.DocumentSymbol[], vscode.SymbolInformation[] | undefined>('A promise that resolves to an array of DocumentHighlight-instances.', (value, apiArgs) => {
+
+			if (isFalsyOrEmpty(value)) {
+				return undefined;
+			}
+			class MergedInfo extends types.SymbolInformation implements vscode.DocumentSymbol {
+				static to(symbol: modes.DocumentSymbol): MergedInfo {
+					const res = new MergedInfo(
+						symbol.name,
+						typeConverters.SymbolKind.to(symbol.kind),
+						symbol.containerName || '',
+						new types.Location(apiArgs[0], typeConverters.Range.to(symbol.range))
+					);
+					res.detail = symbol.detail;
+					res.range = res.location.range;
+					res.selectionRange = typeConverters.Range.to(symbol.selectionRange);
+					res.children = symbol.children ? symbol.children.map(MergedInfo.to) : [];
+					return res;
+				}
+
+				detail!: string;
+				range!: vscode.Range;
+				selectionRange!: vscode.Range;
+				children!: vscode.DocumentSymbol[];
+				containerName!: string;
+			}
+			return value.map(MergedInfo.to);
+
+		})
+	),
+	// -- formatting
+	new ApiCommand(
+		'vscode.executeFormatDocumentProvider', '_executeFormatDocumentProvider', 'Execute document format provider.',
+		[ApiCommandArgument.Uri, new ApiCommandArgument('options', 'Formatting options', _ => true, v => v)],
+		new ApiCommandResult<modes.TextEdit[], types.TextEdit[] | undefined>('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))
+	),
+	new ApiCommand(
+		'vscode.executeFormatRangeProvider', '_executeFormatRangeProvider', 'Execute range format provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Range, new ApiCommandArgument('options', 'Formatting options', _ => true, v => v)],
+		new ApiCommandResult<modes.TextEdit[], types.TextEdit[] | undefined>('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))
+	),
+	new ApiCommand(
+		'vscode.executeFormatOnTypeProvider', '_executeFormatOnTypeProvider', 'Execute format on type provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position, new ApiCommandArgument('ch', 'Trigger character', v => typeof v === 'string', v => v), new ApiCommandArgument('options', 'Formatting options', _ => true, v => v)],
+		new ApiCommandResult<modes.TextEdit[], types.TextEdit[] | undefined>('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))
+	),
+	// -- go to symbol (definition, type definition, declaration, impl, references)
+	new ApiCommand(
+		'vscode.executeDefinitionProvider', '_executeDefinitionProvider', 'Execute all definition providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<(modes.Location | modes.LocationLink)[], (types.Location | vscode.LocationLink)[] | undefined>('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)
+	),
+	new ApiCommand(
+		'vscode.executeTypeDefinitionProvider', '_executeTypeDefinitionProvider', 'Execute all type definition providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<(modes.Location | modes.LocationLink)[], (types.Location | vscode.LocationLink)[] | undefined>('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)
+	),
+	new ApiCommand(
+		'vscode.executeDeclarationProvider', '_executeDeclarationProvider', 'Execute all declaration providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<(modes.Location | modes.LocationLink)[], (types.Location | vscode.LocationLink)[] | undefined>('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)
+	),
+	new ApiCommand(
+		'vscode.executeImplementationProvider', '_executeImplementationProvider', 'Execute all implementation providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<(modes.Location | modes.LocationLink)[], (types.Location | vscode.LocationLink)[] | undefined>('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)
+	),
+	new ApiCommand(
+		'vscode.executeReferenceProvider', '_executeReferenceProvider', 'Execute all reference providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Location[], types.Location[] | undefined>('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))
+	),
+	// -- hover
+	new ApiCommand(
+		'vscode.executeHoverProvider', '_executeHoverProvider', 'Execute all hover providers.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<modes.Hover[], types.Hover[] | undefined>('A promise that resolves to an array of Hover-instances.', tryMapWith(typeConverters.Hover.to))
+	),
+	// -- selection range
+	new ApiCommand(
+		'vscode.executeSelectionRangeProvider', '_executeSelectionRangeProvider', 'Execute selection range provider.',
+		[ApiCommandArgument.Uri, new ApiCommandArgument<types.Position[], IPosition[]>('position', 'A positions in a text document', v => Array.isArray(v) && v.every(v => types.Position.isPosition(v)), v => v.map(typeConverters.Position.from))],
+		new ApiCommandResult<IRange[][], types.SelectionRange[]>('A promise that resolves to an array of ranges.', result => {
+			return result.map(ranges => {
+				let node: types.SelectionRange | undefined;
+				for (const range of ranges.reverse()) {
+					node = new types.SelectionRange(typeConverters.Range.to(range), node);
+				}
+				return node!;
+			});
+		})
+	),
+	// -- symbol search
+	new ApiCommand(
+		'vscode.executeWorkspaceSymbolProvider', '_executeWorkspaceSymbolProvider', 'Execute all workspace symbol providers.',
+		[new ApiCommandArgument('query', 'Search string', v => typeof v === 'string', v => v)],
+		new ApiCommandResult<[search.IWorkspaceSymbolProvider, search.IWorkspaceSymbol[]][], types.SymbolInformation[]>('A promise that resolves to an array of SymbolInformation-instances.', value => {
+			const result: types.SymbolInformation[] = [];
+			if (Array.isArray(value)) {
+				for (let tuple of value) {
+					result.push(...tuple[1].map(typeConverters.WorkspaceSymbol.to));
+				}
+			}
+			return result;
+		})
+	),
+	// --- call hierarchy
+	new ApiCommand(
+		'vscode.prepareCallHierarchy', '_executePrepareCallHierarchy', 'Prepare call hierarchy at a position inside a document',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position],
+		new ApiCommandResult<ICallHierarchyItemDto[], types.CallHierarchyItem[]>('A CallHierarchyItem or undefined', v => v.map(typeConverters.CallHierarchyItem.to))
+	),
+	new ApiCommand(
+		'vscode.provideIncomingCalls', '_executeProvideIncomingCalls', 'Compute incoming calls for an item',
+		[ApiCommandArgument.CallHierarchyItem],
+		new ApiCommandResult<IIncomingCallDto[], types.CallHierarchyIncomingCall[]>('A CallHierarchyItem or undefined', v => v.map(typeConverters.CallHierarchyIncomingCall.to))
+	),
+	new ApiCommand(
+		'vscode.provideOutgoingCalls', '_executeProvideOutgoingCalls', 'Compute outgoing calls for an item',
+		[ApiCommandArgument.CallHierarchyItem],
+		new ApiCommandResult<IOutgoingCallDto[], types.CallHierarchyOutgoingCall[]>('A CallHierarchyItem or undefined', v => v.map(typeConverters.CallHierarchyOutgoingCall.to))
+	),
+	// --- rename
+	new ApiCommand(
+		'vscode.executeDocumentRenameProvider', '_executeDocumentRenameProvider', 'Execute rename provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position, new ApiCommandArgument('newName', 'The new symbol name', v => typeof v === 'string', v => v)],
+		new ApiCommandResult<IWorkspaceEditDto, types.WorkspaceEdit | undefined>('A promise that resolves to a WorkspaceEdit.', value => {
+			if (!value) {
+				return undefined;
+			}
+			if (value.rejectReason) {
+				throw new Error(value.rejectReason);
+			}
+			return typeConverters.WorkspaceEdit.to(value);
+		})
+	),
+	// --- links
+	new ApiCommand(
+		'vscode.executeLinkProvider', '_executeLinkProvider', 'Execute document link provider.',
+		[ApiCommandArgument.Uri, new ApiCommandArgument('linkResolveCount', '(optional) Number of links that should be resolved, only when links are unresolved.', v => typeof v === 'number' || typeof v === 'undefined', v => v)],
+		new ApiCommandResult<modes.ILink[], vscode.DocumentLink[]>('A promise that resolves to an array of DocumentLink-instances.', value => value.map(typeConverters.DocumentLink.to))
+	)
+];
+
+//#endregion
+
+
+//#region OLD world
+
+export class ExtHostApiCommands {
+
+	static register(commands: ExtHostCommands) {
+		newCommands.forEach(command => command.register(commands));
+		return new ExtHostApiCommands(commands).registerCommands();
+	}
+
+	private _commands: ExtHostCommands;
+	private readonly _disposables = new DisposableStore();
+
+	private constructor(commands: ExtHostCommands) {
+		this._commands = commands;
+	}
+
+	registerCommands() {
+		this._register('vscode.executeSignatureHelpProvider', this._executeSignatureHelpProvider, {
+			description: 'Execute signature help provider.',
+			args: [
+				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
+				{ name: 'position', description: 'Position in a text document', constraint: types.Position },
+				{ name: 'triggerCharacter', description: '(optional) Trigger signature help when the user types the character, like `,` or `(`', constraint: (value: any) => value === undefined || typeof value === 'string' }
+			],
+			returns: 'A promise that resolves to SignatureHelp.'
+		});
+		this._register('vscode.executeCompletionItemProvider', this._executeCompletionItemProvider, {
+			description: 'Execute completion item provider.',
+			args: [
+				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
+				{ name: 'position', description: 'Position in a text document', constraint: types.Position },
+				{ name: 'triggerCharacter', description: '(optional) Trigger completion when the user types the character, like `,` or `(`', constraint: (value: any) => value === undefined || typeof value === 'string' },
+				{ name: 'itemResolveCount', description: '(optional) Number of completions to resolve (too large numbers slow down completions)', constraint: (value: any) => value === undefined || typeof value === 'number' }
+			],
+			returns: 'A promise that resolves to a CompletionList-instance.'
+		});
+		this._register('vscode.executeCodeActionProvider', this._executeCodeActionProvider, {
+			description: 'Execute code action provider.',
+			args: [
+				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
+				{ name: 'rangeOrSelection', description: 'Range in a text document. Some refactoring provider requires Selection object.', constraint: types.Range },
+				{ name: 'kind', description: '(optional) Code action kind to return code actions for', constraint: (value: any) => !value || typeof value.value === 'string' },
+				{ name: 'itemResolveCount', description: '(optional) Number of code actions to resolve (too large numbers slow down code actions)', constraint: (value: any) => value === undefined || typeof value === 'number' }
+
+			],
+			returns: 'A promise that resolves to an array of Command-instances.'
+		});
+		this._register('vscode.executeCodeLensProvider', this._executeCodeLensProvider, {
+			description: 'Execute CodeLens provider.',
+			args: [
+				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
+				{ name: 'itemResolveCount', description: '(optional) Number of lenses that should be resolved and returned. Will only return resolved lenses, will impact performance)', constraint: (value: any) => value === undefined || typeof value === 'number' }
+			],
+			returns: 'A promise that resolves to an array of CodeLens-instances.'
+		});
+
+		this._register('vscode.executeDocumentColorProvider', this._executeDocumentColorProvider, {
+			description: 'Execute document color provider.',
+			args: [
+				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
+			],
+			returns: 'A promise that resolves to an array of ColorInformation objects.'
+		});
+		this._register('vscode.executeColorPresentationProvider', this._executeColorPresentationProvider, {
+			description: 'Execute color presentation provider.',
+			args: [
+				{ name: 'color', description: 'The color to show and insert', constraint: types.Color },
+				{ name: 'context', description: 'Context object with uri and range' }
+			],
+			returns: 'A promise that resolves to an array of ColorPresentation objects.'
+		});
+
+		this._register('vscode.resolveNotebookContentProviders', this._resolveNotebookContentProviders, {
+			description: 'Resolve Notebook Content Providers',
+			args: [],
+			returns: 'A promise that resolves to an array of NotebookContentProvider static info objects.'
+		});
+
+		// -----------------------------------------------------------------
+		// The following commands are registered on both sides separately.
+		//
+		// We are trying to maintain backwards compatibility for cases where
+		// API commands are encoded as markdown links, for example.
+		// -----------------------------------------------------------------
+
+		type ICommandHandler = (...args: any[]) => any;
+		const adjustHandler = (handler: (executor: ICommandsExecutor, ...args: any[]) => any): ICommandHandler => {
+			return (...args: any[]) => {
+				return handler(this._commands, ...args);
+			};
+		};
+
+		this._register(OpenFolderAPICommand.ID, adjustHandler(OpenFolderAPICommand.execute), {
+			description: 'Open a folder or workspace in the current window or new window depending on the newWindow argument. Note that opening in the same window will shutdown the current extension host process and start a new one on the given folder/workspace unless the newWindow parameter is set to true.',
+			args: [
+				{ name: 'uri', description: '(optional) Uri of the folder or workspace file to open. If not provided, a native dialog will ask the user for the folder', constraint: (value: any) => value === undefined || URI.isUri(value) },
+				{ name: 'options', description: '(optional) Options. Object with the following properties: `forceNewWindow `: Whether to open the folder/workspace in a new window or the same. Defaults to opening in the same window. `noRecentEntry`: Whether the opened URI will appear in the \'Open Recent\' list. Defaults to true. Note, for backward compatibility, options can also be of type boolean, representing the `forceNewWindow` setting.', constraint: (value: any) => value === undefined || typeof value === 'object' || typeof value === 'boolean' }
+			]
+		});
+
+		this._register(DiffAPICommand.ID, adjustHandler(DiffAPICommand.execute), {
+			description: 'Opens the provided resources in the diff editor to compare their contents.',
+			args: [
+				{ name: 'left', description: 'Left-hand side resource of the diff editor', constraint: URI },
+				{ name: 'right', description: 'Right-hand side resource of the diff editor', constraint: URI },
+				{ name: 'title', description: '(optional) Human readable title for the diff editor', constraint: (v: any) => v === undefined || typeof v === 'string' },
+				{ name: 'options', description: '(optional) Editor options, see vscode.TextDocumentShowOptions' }
+			]
+		});
+
+		this._register(OpenAPICommand.ID, adjustHandler(OpenAPICommand.execute), {
+			description: 'Opens the provided resource in the editor. Can be a text or binary file, or a http(s) url. If you need more control over the options for opening a text file, use vscode.window.showTextDocument instead.',
+			args: [
+				{ name: 'resource', description: 'Resource to open', constraint: URI },
+				{ name: 'columnOrOptions', description: '(optional) Either the column in which to open or editor options, see vscode.TextDocumentShowOptions', constraint: (v: any) => v === undefined || typeof v === 'number' || typeof v === 'object' }
+			]
+		});
+
+		this._register(RemoveFromRecentlyOpenedAPICommand.ID, adjustHandler(RemoveFromRecentlyOpenedAPICommand.execute), {
+			description: 'Removes an entry with the given path from the recently opened list.',
+			args: [
+				{ name: 'path', description: 'Path to remove from recently opened.', constraint: (value: any) => typeof value === 'string' }
+			]
+		});
+
+		this._register(SetEditorLayoutAPICommand.ID, adjustHandler(SetEditorLayoutAPICommand.execute), {
+			description: 'Sets the editor layout. The layout is described as object with an initial (optional) orientation (0 = horizontal, 1 = vertical) and an array of editor groups within. Each editor group can have a size and another array of editor groups that will be laid out orthogonal to the orientation. If editor group sizes are provided, their sum must be 1 to be applied per row or column. Example for a 2x2 grid: `{ orientation: 0, groups: [{ groups: [{}, {}], size: 0.5 }, { groups: [{}, {}], size: 0.5 }] }`',
+			args: [
+				{ name: 'layout', description: 'The editor layout to set.', constraint: (value: EditorGroupLayout) => typeof value === 'object' && Array.isArray(value.groups) }
+			]
+		});
+
+		this._register(OpenIssueReporter.ID, adjustHandler(OpenIssueReporter.execute), {
+			description: 'Opens the issue reporter with the provided extension id as the selected source',
+			args: [
+				{ name: 'extensionId', description: 'extensionId to report an issue on', constraint: (value: unknown) => typeof value === 'string' || (typeof value === 'object' && typeof (value as OpenIssueReporterArgs).extensionId === 'string') }
+			]
+		});
+	}
+
+	// --- command impl
+
+	private _register(id: string, handler: (...args: any[]) => any, description?: ICommandHandlerDescription): void {
+		const disposable = this._commands.registerCommand(false, id, handler, this, description);
+		this._disposables.add(disposable);
+	}
+
+	private _executeSignatureHelpProvider(resource: URI, position: types.Position, triggerCharacter: string): Promise<types.SignatureHelp | undefined> {
+		const args = {
+			resource,
+			position: position && typeConverters.Position.from(position),
+			triggerCharacter
+		};
+		return this._commands.executeCommand<modes.SignatureHelp>('_executeSignatureHelpProvider', args).then(value => {
+			if (value) {
+				return typeConverters.SignatureHelp.to(value);
+			}
+			return undefined;
+		});
+	}
+
+	private _executeCompletionItemProvider(resource: URI, position: types.Position, triggerCharacter: string, maxItemsToResolve: number): Promise<types.CompletionList | undefined> {
+		const args = {
+			resource,
+			position: position && typeConverters.Position.from(position),
+			triggerCharacter,
+			maxItemsToResolve
+		};
+		return this._commands.executeCommand<modes.CompletionList>('_executeCompletionItemProvider', args).then(result => {
+			if (result) {
+				const items = result.suggestions.map(suggestion => typeConverters.CompletionItem.to(suggestion, this._commands.converter));
+				return new types.CompletionList(items, result.incomplete);
+			}
+			return undefined;
+		});
+	}
+
+	private _executeDocumentColorProvider(resource: URI): Promise<types.ColorInformation[]> {
+		const args = {
+			resource
+		};
+		return this._commands.executeCommand<IRawColorInfo[]>('_executeDocumentColorProvider', args).then(result => {
+			if (result) {
+				return result.map(ci => ({ range: typeConverters.Range.to(ci.range), color: typeConverters.Color.to(ci.color) }));
+			}
+			return [];
+		});
+	}
+
+	private _executeColorPresentationProvider(color: types.Color, context: { uri: URI, range: types.Range; }): Promise<types.ColorPresentation[]> {
+		const args = {
+			resource: context.uri,
+			color: typeConverters.Color.from(color),
+			range: typeConverters.Range.from(context.range),
+		};
+		return this._commands.executeCommand<modes.IColorPresentation[]>('_executeColorPresentationProvider', args).then(result => {
+			if (result) {
+				return result.map(typeConverters.ColorPresentation.to);
+			}
+			return [];
+		});
+	}
+
+
+	private _executeCodeActionProvider(resource: URI, rangeOrSelection: types.Range | types.Selection, kind?: string, itemResolveCount?: number): Promise<(vscode.CodeAction | vscode.Command | undefined)[] | undefined> {
+		const args = {
+			resource,
+			rangeOrSelection: types.Selection.isSelection(rangeOrSelection)
+				? typeConverters.Selection.from(rangeOrSelection)
+				: typeConverters.Range.from(rangeOrSelection),
+			kind,
+			itemResolveCount,
+		};
+		return this._commands.executeCommand<CustomCodeAction[]>('_executeCodeActionProvider', args)
+			.then(tryMapWith(codeAction => {
+				if (codeAction._isSynthetic) {
+					if (!codeAction.command) {
+						throw new Error('Synthetic code actions must have a command');
+					}
+					return this._commands.converter.fromInternal(codeAction.command);
+				} else {
+					const ret = new types.CodeAction(
+						codeAction.title,
+						codeAction.kind ? new types.CodeActionKind(codeAction.kind) : undefined
+					);
+					if (codeAction.edit) {
+						ret.edit = typeConverters.WorkspaceEdit.to(codeAction.edit);
+					}
+					if (codeAction.command) {
+						ret.command = this._commands.converter.fromInternal(codeAction.command);
+					}
+					ret.isPreferred = codeAction.isPreferred;
+					return ret;
+				}
+			}));
+	}
+
+	private _executeCodeLensProvider(resource: URI, itemResolveCount: number): Promise<vscode.CodeLens[] | undefined> {
+		const args = { resource, itemResolveCount };
+		return this._commands.executeCommand<modes.CodeLens[]>('_executeCodeLensProvider', args)
+			.then(tryMapWith(item => {
+				return new types.CodeLens(
+					typeConverters.Range.to(item.range),
+					item.command ? this._commands.converter.fromInternal(item.command) : undefined);
+			}));
+	}
+
+	private _resolveNotebookContentProviders(): Promise<{
+		viewType: string;
+		displayName: string;
+		filenamePattern: vscode.NotebookFilenamePattern[];
+		options: vscode.NotebookDocumentContentOptions;
+	}[] | undefined> {
+		return this._commands.executeCommand<{
+			viewType: string;
+			displayName: string;
+			options: { transientOutputs: boolean; transientMetadata: TransientMetadata };
+			filenamePattern: (string | types.RelativePattern | { include: string | types.RelativePattern, exclude: string | types.RelativePattern })[]
+		}[]>('_resolveNotebookContentProvider')
+			.then(tryMapWith(item => {
+				return {
+					viewType: item.viewType,
+					displayName: item.displayName,
+					options: { transientOutputs: item.options.transientOutputs, transientMetadata: item.options.transientMetadata },
+					filenamePattern: item.filenamePattern.map(pattern => typeConverters.NotebookExclusiveDocumentPattern.to(pattern))
+				};
+			}));
+	}
+}
+
+function tryMapWith<T, R>(f: (x: T) => R) {
+	return (value: T[]) => {
+		if (Array.isArray(value)) {
+			return value.map(f);
+		}
+		return undefined;
+	};
+}
+
+function mapLocationOrLocationLink(values: (modes.Location | modes.LocationLink)[]): (types.Location | vscode.LocationLink)[] | undefined {
+	if (!Array.isArray(values)) {
+		return undefined;
+	}
+	const result: (types.Location | vscode.LocationLink)[] = [];
+	for (const item of values) {
+		if (modes.isLocationLink(item)) {
+			result.push(typeConverters.DefinitionLink.to(item));
+		} else {
+			result.push(typeConverters.location.to(item));
+		}
+	}
+	return result;
+}

lib/vscode/src/vs/workbench/api/common/extHostApiDeprecationService.ts

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vs/platform/log/common/log';
+import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+
+export interface IExtHostApiDeprecationService {
+	readonly _serviceBrand: undefined;
+
+	report(apiId: string, extension: IExtensionDescription, migrationSuggestion: string): void;
+}
+
+export const IExtHostApiDeprecationService = createDecorator<IExtHostApiDeprecationService>('IExtHostApiDeprecationService');
+
+export class ExtHostApiDeprecationService implements IExtHostApiDeprecationService {
+
+	declare readonly _serviceBrand: undefined;
+
+	private readonly _reportedUsages = new Set<string>();
+	private readonly _telemetryShape: extHostProtocol.MainThreadTelemetryShape;
+
+	constructor(
+		@IExtHostRpcService rpc: IExtHostRpcService,
+		@ILogService private readonly _extHostLogService: ILogService,
+	) {
+		this._telemetryShape = rpc.getProxy(extHostProtocol.MainContext.MainThreadTelemetry);
+	}
+
+	public report(apiId: string, extension: IExtensionDescription, migrationSuggestion: string): void {
+		const key = this.getUsageKey(apiId, extension);
+		if (this._reportedUsages.has(key)) {
+			return;
+		}
+		this._reportedUsages.add(key);
+
+		if (extension.isUnderDevelopment) {
+			this._extHostLogService.warn(`[Deprecation Warning] '${apiId}' is deprecated. ${migrationSuggestion}`);
+		}
+
+		type DeprecationTelemetry = {
+			extensionId: string;
+			apiId: string;
+		};
+		type DeprecationTelemetryMeta = {
+			extensionId: { classification: 'SystemMetaData', purpose: 'PerformanceAndHealth' };
+			apiId: { classification: 'SystemMetaData', purpose: 'PerformanceAndHealth' };
+		};
+		this._telemetryShape.$publicLog2<DeprecationTelemetry, DeprecationTelemetryMeta>('extHostDeprecatedApiUsage', {
+			extensionId: extension.identifier.value,
+			apiId: apiId,
+		});
+	}
+
+	private getUsageKey(apiId: string, extension: IExtensionDescription): string {
+		return `${apiId}-${extension.identifier.value}`;
+	}
+}
+
+
+export const NullApiDeprecationService = Object.freeze(new class implements IExtHostApiDeprecationService {
+	declare readonly _serviceBrand: undefined;
+
+	public report(_apiId: string, _extension: IExtensionDescription, _warningMessage: string): void {
+		// noop
+	}
+}());

lib/vscode/src/vs/workbench/api/common/extHostAuthentication.ts

@@ -0,0 +1,267 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from 'vscode';
+import * as modes from 'vs/editor/common/modes';
+import { Emitter, Event } from 'vs/base/common/event';
+import { IMainContext, MainContext, MainThreadAuthenticationShape, ExtHostAuthenticationShape } from 'vs/workbench/api/common/extHost.protocol';
+import { Disposable } from 'vs/workbench/api/common/extHostTypes';
+import { IExtensionDescription, ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+interface GetSessionsRequest {
+	scopes: string;
+	result: Promise<vscode.AuthenticationSession | undefined>;
+}
+
+export class ExtHostAuthentication implements ExtHostAuthenticationShape {
+	private _proxy: MainThreadAuthenticationShape;
+	private _authenticationProviders: Map<string, vscode.AuthenticationProvider> = new Map<string, vscode.AuthenticationProvider>();
+
+	private _providerIds: string[] = [];
+
+	private _providers: vscode.AuthenticationProviderInformation[] = [];
+
+	private _onDidChangeAuthenticationProviders = new Emitter<vscode.AuthenticationProvidersChangeEvent>();
+	readonly onDidChangeAuthenticationProviders: Event<vscode.AuthenticationProvidersChangeEvent> = this._onDidChangeAuthenticationProviders.event;
+
+	private _onDidChangeSessions = new Emitter<vscode.AuthenticationSessionsChangeEvent>();
+	readonly onDidChangeSessions: Event<vscode.AuthenticationSessionsChangeEvent> = this._onDidChangeSessions.event;
+
+	private _onDidChangePassword = new Emitter<void>();
+	readonly onDidChangePassword: Event<void> = this._onDidChangePassword.event;
+
+	private _inFlightRequests = new Map<string, GetSessionsRequest[]>();
+
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadAuthentication);
+	}
+
+	$setProviders(providers: vscode.AuthenticationProviderInformation[]): Promise<void> {
+		this._providers = providers;
+		return Promise.resolve();
+	}
+
+	getProviderIds(): Promise<ReadonlyArray<string>> {
+		return this._proxy.$getProviderIds();
+	}
+
+	get providerIds(): string[] {
+		return this._providerIds;
+	}
+
+	get providers(): ReadonlyArray<vscode.AuthenticationProviderInformation> {
+		return Object.freeze(this._providers.slice());
+	}
+
+	async getSession(requestingExtension: IExtensionDescription, providerId: string, scopes: string[], options: vscode.AuthenticationGetSessionOptions & { createIfNone: true }): Promise<vscode.AuthenticationSession>;
+	async getSession(requestingExtension: IExtensionDescription, providerId: string, scopes: string[], options: vscode.AuthenticationGetSessionOptions = {}): Promise<vscode.AuthenticationSession | undefined> {
+		const extensionId = ExtensionIdentifier.toKey(requestingExtension.identifier);
+		const inFlightRequests = this._inFlightRequests.get(extensionId) || [];
+		const sortedScopes = scopes.sort().join(' ');
+		let inFlightRequest: GetSessionsRequest | undefined = inFlightRequests.find(request => request.scopes === sortedScopes);
+
+		if (inFlightRequest) {
+			return inFlightRequest.result;
+		} else {
+			const session = this._getSession(requestingExtension, extensionId, providerId, scopes, options);
+			inFlightRequest = {
+				scopes: sortedScopes,
+				result: session
+			};
+
+			inFlightRequests.push(inFlightRequest);
+			this._inFlightRequests.set(extensionId, inFlightRequests);
+
+			try {
+				await session;
+			} finally {
+				const requestIndex = inFlightRequests.findIndex(request => request.scopes === sortedScopes);
+				if (requestIndex > -1) {
+					inFlightRequests.splice(requestIndex);
+					this._inFlightRequests.set(extensionId, inFlightRequests);
+				}
+			}
+
+			return session;
+		}
+	}
+
+	private async _getSession(requestingExtension: IExtensionDescription, extensionId: string, providerId: string, scopes: string[], options: vscode.AuthenticationGetSessionOptions = {}): Promise<vscode.AuthenticationSession | undefined> {
+		await this._proxy.$ensureProvider(providerId);
+		const provider = this._authenticationProviders.get(providerId);
+		const extensionName = requestingExtension.displayName || requestingExtension.name;
+
+		if (!provider) {
+			return this._proxy.$getSession(providerId, scopes, extensionId, extensionName, options);
+		}
+
+		const orderedScopes = scopes.sort().join(' ');
+		const sessions = (await provider.getSessions()).filter(session => session.scopes.slice().sort().join(' ') === orderedScopes);
+
+		let session: vscode.AuthenticationSession | undefined = undefined;
+		if (sessions.length) {
+			if (!provider.supportsMultipleAccounts) {
+				session = sessions[0];
+				const allowed = await this._proxy.$getSessionsPrompt(providerId, session.account.label, provider.label, extensionId, extensionName);
+				if (!allowed) {
+					throw new Error('User did not consent to login.');
+				}
+			} else {
+				// On renderer side, confirm consent, ask user to choose between accounts if multiple sessions are valid
+				const selected = await this._proxy.$selectSession(providerId, provider.label, extensionId, extensionName, sessions, scopes, !!options.clearSessionPreference);
+				session = sessions.find(session => session.id === selected.id);
+			}
+
+		} else {
+			if (options.createIfNone) {
+				const isAllowed = await this._proxy.$loginPrompt(provider.label, extensionName);
+				if (!isAllowed) {
+					throw new Error('User did not consent to login.');
+				}
+
+				session = await provider.login(scopes);
+				await this._proxy.$setTrustedExtensionAndAccountPreference(providerId, session.account.label, extensionId, extensionName, session.id);
+			} else {
+				await this._proxy.$requestNewSession(providerId, scopes, extensionId, extensionName);
+			}
+		}
+
+
+		return session;
+	}
+
+	async logout(providerId: string, sessionId: string): Promise<void> {
+		const provider = this._authenticationProviders.get(providerId);
+		if (!provider) {
+			return this._proxy.$logout(providerId, sessionId);
+		}
+
+		return provider.logout(sessionId);
+	}
+
+	registerAuthenticationProvider(provider: vscode.AuthenticationProvider): vscode.Disposable {
+		if (this._authenticationProviders.get(provider.id)) {
+			throw new Error(`An authentication provider with id '${provider.id}' is already registered.`);
+		}
+
+		this._authenticationProviders.set(provider.id, provider);
+		if (!this._providerIds.includes(provider.id)) {
+			this._providerIds.push(provider.id);
+		}
+
+		if (!this._providers.find(p => p.id === provider.id)) {
+			this._providers.push({
+				id: provider.id,
+				label: provider.label
+			});
+		}
+
+		const listener = provider.onDidChangeSessions(e => {
+			this._proxy.$sendDidChangeSessions(provider.id, e);
+		});
+
+		this._proxy.$registerAuthenticationProvider(provider.id, provider.label, provider.supportsMultipleAccounts);
+
+		return new Disposable(() => {
+			listener.dispose();
+			this._authenticationProviders.delete(provider.id);
+			const index = this._providerIds.findIndex(id => id === provider.id);
+			if (index > -1) {
+				this._providerIds.splice(index);
+			}
+
+			const i = this._providers.findIndex(p => p.id === provider.id);
+			if (i > -1) {
+				this._providers.splice(i);
+			}
+
+			this._proxy.$unregisterAuthenticationProvider(provider.id);
+		});
+	}
+
+	$login(providerId: string, scopes: string[]): Promise<modes.AuthenticationSession> {
+		const authProvider = this._authenticationProviders.get(providerId);
+		if (authProvider) {
+			return Promise.resolve(authProvider.login(scopes));
+		}
+
+		throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
+	}
+
+	$logout(providerId: string, sessionId: string): Promise<void> {
+		const authProvider = this._authenticationProviders.get(providerId);
+		if (authProvider) {
+			return Promise.resolve(authProvider.logout(sessionId));
+		}
+
+		throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
+	}
+
+	$getSessions(providerId: string): Promise<ReadonlyArray<modes.AuthenticationSession>> {
+		const authProvider = this._authenticationProviders.get(providerId);
+		if (authProvider) {
+			return Promise.resolve(authProvider.getSessions());
+		}
+
+		throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
+	}
+
+	async $getSessionAccessToken(providerId: string, sessionId: string): Promise<string> {
+		const authProvider = this._authenticationProviders.get(providerId);
+		if (authProvider) {
+			const sessions = await authProvider.getSessions();
+			const session = sessions.find(session => session.id === sessionId);
+			if (session) {
+				return session.accessToken;
+			}
+
+			throw new Error(`Unable to find session with id: ${sessionId}`);
+		}
+
+		throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
+	}
+
+	$onDidChangeAuthenticationSessions(id: string, label: string, event: modes.AuthenticationSessionsChangeEvent) {
+		this._onDidChangeSessions.fire({ provider: { id, label }, ...event });
+		return Promise.resolve();
+	}
+
+	$onDidChangeAuthenticationProviders(added: modes.AuthenticationProviderInformation[], removed: modes.AuthenticationProviderInformation[]) {
+		added.forEach(provider => {
+			if (!this._providers.some(p => p.id === provider.id)) {
+				this._providers.push(provider);
+			}
+		});
+
+		removed.forEach(p => {
+			const index = this._providers.findIndex(provider => provider.id === p.id);
+			if (index > -1) {
+				this._providers.splice(index);
+			}
+		});
+
+		this._onDidChangeAuthenticationProviders.fire({ added, removed });
+		return Promise.resolve();
+	}
+
+	async $onDidChangePassword(): Promise<void> {
+		this._onDidChangePassword.fire();
+	}
+
+	getPassword(requestingExtension: IExtensionDescription, key: string): Promise<string | undefined> {
+		const extensionId = ExtensionIdentifier.toKey(requestingExtension.identifier);
+		return this._proxy.$getPassword(extensionId, key);
+	}
+
+	setPassword(requestingExtension: IExtensionDescription, key: string, value: string): Promise<void> {
+		const extensionId = ExtensionIdentifier.toKey(requestingExtension.identifier);
+		return this._proxy.$setPassword(extensionId, key, value);
+	}
+
+	deletePassword(requestingExtension: IExtensionDescription, key: string): Promise<void> {
+		const extensionId = ExtensionIdentifier.toKey(requestingExtension.identifier);
+		return this._proxy.$deletePassword(extensionId, key);
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostBulkEdits.ts

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainContext, MainThreadBulkEditsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { ExtHostNotebookController } from 'vs/workbench/api/common/extHostNotebook';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { WorkspaceEdit } from 'vs/workbench/api/common/extHostTypeConverters';
+import type * as vscode from 'vscode';
+
+export class ExtHostBulkEdits {
+
+	private readonly _proxy: MainThreadBulkEditsShape;
+
+	constructor(
+		@IExtHostRpcService extHostRpc: IExtHostRpcService,
+		private readonly _extHostDocumentsAndEditors: ExtHostDocumentsAndEditors,
+		private readonly _extHostNotebooks: ExtHostNotebookController,
+	) {
+		this._proxy = extHostRpc.getProxy(MainContext.MainThreadBulkEdits);
+	}
+
+	applyWorkspaceEdit(edit: vscode.WorkspaceEdit): Promise<boolean> {
+		const dto = WorkspaceEdit.from(edit, this._extHostDocumentsAndEditors, this._extHostNotebooks);
+		return this._proxy.$tryApplyWorkspaceEdit(dto);
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostClipboard.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IMainContext, MainContext, MainThreadClipboardShape } from 'vs/workbench/api/common/extHost.protocol';
+import type * as vscode from 'vscode';
+
+export class ExtHostClipboard implements vscode.Clipboard {
+
+	private readonly _proxy: MainThreadClipboardShape;
+
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadClipboard);
+	}
+
+	readText(): Promise<string> {
+		return this._proxy.$readText();
+	}
+
+	writeText(value: string): Promise<void> {
+		return this._proxy.$writeText(value);
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostCodeInsets.ts

@@ -0,0 +1,143 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter } from 'vs/base/common/event';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { ExtHostTextEditor } from 'vs/workbench/api/common/extHostTextEditor';
+import { ExtHostEditors } from 'vs/workbench/api/common/extHostTextEditors';
+import type * as vscode from 'vscode';
+import { ExtHostEditorInsetsShape, MainThreadEditorInsetsShape } from './extHost.protocol';
+import { asWebviewUri, WebviewInitData } from 'vs/workbench/api/common/shared/webview';
+import { generateUuid } from 'vs/base/common/uuid';
+
+export class ExtHostEditorInsets implements ExtHostEditorInsetsShape {
+
+	private _handlePool = 0;
+	private _disposables = new DisposableStore();
+	private _insets = new Map<number, { editor: vscode.TextEditor, inset: vscode.WebviewEditorInset, onDidReceiveMessage: Emitter<any> }>();
+
+	constructor(
+		private readonly _proxy: MainThreadEditorInsetsShape,
+		private readonly _editors: ExtHostEditors,
+		private readonly _initData: WebviewInitData
+	) {
+
+		// dispose editor inset whenever the hosting editor goes away
+		this._disposables.add(_editors.onDidChangeVisibleTextEditors(() => {
+			const visibleEditor = _editors.getVisibleTextEditors();
+			for (const value of this._insets.values()) {
+				if (visibleEditor.indexOf(value.editor) < 0) {
+					value.inset.dispose(); // will remove from `this._insets`
+				}
+			}
+		}));
+	}
+
+	dispose(): void {
+		this._insets.forEach(value => value.inset.dispose());
+		this._disposables.dispose();
+	}
+
+	createWebviewEditorInset(editor: vscode.TextEditor, line: number, height: number, options: vscode.WebviewOptions | undefined, extension: IExtensionDescription): vscode.WebviewEditorInset {
+
+		let apiEditor: ExtHostTextEditor | undefined;
+		for (const candidate of this._editors.getVisibleTextEditors()) {
+			if (candidate === editor) {
+				apiEditor = <ExtHostTextEditor>candidate;
+				break;
+			}
+		}
+		if (!apiEditor) {
+			throw new Error('not a visible editor');
+		}
+
+		const that = this;
+		const handle = this._handlePool++;
+		const onDidReceiveMessage = new Emitter<any>();
+		const onDidDispose = new Emitter<void>();
+
+		const webview = new class implements vscode.Webview {
+
+			private readonly _uuid = generateUuid();
+			private _html: string = '';
+			private _options: vscode.WebviewOptions = Object.create(null);
+
+			asWebviewUri(resource: vscode.Uri): vscode.Uri {
+				return asWebviewUri(that._initData, this._uuid, resource);
+			}
+
+			get cspSource(): string {
+				return that._initData.webviewCspSource;
+			}
+
+			set options(value: vscode.WebviewOptions) {
+				this._options = value;
+				that._proxy.$setOptions(handle, value);
+			}
+
+			get options(): vscode.WebviewOptions {
+				return this._options;
+			}
+
+			set html(value: string) {
+				this._html = value;
+				that._proxy.$setHtml(handle, value);
+			}
+
+			get html(): string {
+				return this._html;
+			}
+
+			get onDidReceiveMessage(): vscode.Event<any> {
+				return onDidReceiveMessage.event;
+			}
+
+			postMessage(message: any): Thenable<boolean> {
+				return that._proxy.$postMessage(handle, message);
+			}
+		};
+
+		const inset = new class implements vscode.WebviewEditorInset {
+
+			readonly editor: vscode.TextEditor = editor;
+			readonly line: number = line;
+			readonly height: number = height;
+			readonly webview: vscode.Webview = webview;
+			readonly onDidDispose: vscode.Event<void> = onDidDispose.event;
+
+			dispose(): void {
+				if (that._insets.has(handle)) {
+					that._insets.delete(handle);
+					that._proxy.$disposeEditorInset(handle);
+					onDidDispose.fire();
+
+					// final cleanup
+					onDidDispose.dispose();
+					onDidReceiveMessage.dispose();
+				}
+			}
+		};
+
+		this._proxy.$createEditorInset(handle, apiEditor.id, apiEditor.document.uri, line + 1, height, options || {}, extension.identifier, extension.extensionLocation);
+		this._insets.set(handle, { editor, inset, onDidReceiveMessage });
+
+		return inset;
+	}
+
+	$onDidDispose(handle: number): void {
+		const value = this._insets.get(handle);
+		if (value) {
+			value.inset.dispose();
+		}
+	}
+
+	$onDidReceiveMessage(handle: number, message: any): void {
+		const value = this._insets.get(handle);
+		if (value) {
+			value.onDidReceiveMessage.fire(message);
+		}
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostCommands.ts

@@ -0,0 +1,297 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { validateConstraint } from 'vs/base/common/types';
+import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
+import * as extHostTypes from 'vs/workbench/api/common/extHostTypes';
+import * as extHostTypeConverter from 'vs/workbench/api/common/extHostTypeConverters';
+import { cloneAndChange } from 'vs/base/common/objects';
+import { MainContext, MainThreadCommandsShape, ExtHostCommandsShape, ObjectIdentifier, ICommandDto } from './extHost.protocol';
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import * as modes from 'vs/editor/common/modes';
+import type * as vscode from 'vscode';
+import { ILogService } from 'vs/platform/log/common/log';
+import { revive } from 'vs/base/common/marshalling';
+import { Range } from 'vs/editor/common/core/range';
+import { Position } from 'vs/editor/common/core/position';
+import { URI } from 'vs/base/common/uri';
+import { DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+
+interface CommandHandler {
+	callback: Function;
+	thisArg: any;
+	description?: ICommandHandlerDescription;
+}
+
+export interface ArgumentProcessor {
+	processArgument(arg: any): any;
+}
+
+export class ExtHostCommands implements ExtHostCommandsShape {
+
+	readonly _serviceBrand: undefined;
+
+	private readonly _commands = new Map<string, CommandHandler>();
+	private readonly _proxy: MainThreadCommandsShape;
+	private readonly _converter: CommandsConverter;
+	private readonly _logService: ILogService;
+	private readonly _argumentProcessors: ArgumentProcessor[];
+
+	constructor(
+		@IExtHostRpcService extHostRpc: IExtHostRpcService,
+		@ILogService logService: ILogService
+	) {
+		this._proxy = extHostRpc.getProxy(MainContext.MainThreadCommands);
+		this._logService = logService;
+		this._converter = new CommandsConverter(this, logService);
+		this._argumentProcessors = [
+			{
+				processArgument(a) {
+					// URI, Regex
+					return revive(a);
+				}
+			},
+			{
+				processArgument(arg) {
+					return cloneAndChange(arg, function (obj) {
+						// Reverse of https://github.com/microsoft/vscode/blob/1f28c5fc681f4c01226460b6d1c7e91b8acb4a5b/src/vs/workbench/api/node/extHostCommands.ts#L112-L127
+						if (Range.isIRange(obj)) {
+							return extHostTypeConverter.Range.to(obj);
+						}
+						if (Position.isIPosition(obj)) {
+							return extHostTypeConverter.Position.to(obj);
+						}
+						if (Range.isIRange((obj as modes.Location).range) && URI.isUri((obj as modes.Location).uri)) {
+							return extHostTypeConverter.location.to(obj);
+						}
+						if (!Array.isArray(obj)) {
+							return obj;
+						}
+					});
+				}
+			}
+		];
+	}
+
+	get converter(): CommandsConverter {
+		return this._converter;
+	}
+
+	registerArgumentProcessor(processor: ArgumentProcessor): void {
+		this._argumentProcessors.push(processor);
+	}
+
+	registerCommand(global: boolean, id: string, callback: <T>(...args: any[]) => T | Thenable<T>, thisArg?: any, description?: ICommandHandlerDescription): extHostTypes.Disposable {
+		this._logService.trace('ExtHostCommands#registerCommand', id);
+
+		if (!id.trim().length) {
+			throw new Error('invalid id');
+		}
+
+		if (this._commands.has(id)) {
+			throw new Error(`command '${id}' already exists`);
+		}
+
+		this._commands.set(id, { callback, thisArg, description });
+		if (global) {
+			this._proxy.$registerCommand(id);
+		}
+
+		return new extHostTypes.Disposable(() => {
+			if (this._commands.delete(id)) {
+				if (global) {
+					this._proxy.$unregisterCommand(id);
+				}
+			}
+		});
+	}
+
+	executeCommand<T>(id: string, ...args: any[]): Promise<T> {
+		this._logService.trace('ExtHostCommands#executeCommand', id);
+		return this._doExecuteCommand(id, args, true);
+	}
+
+	private async _doExecuteCommand<T>(id: string, args: any[], retry: boolean): Promise<T> {
+
+		if (this._commands.has(id)) {
+			// we stay inside the extension host and support
+			// to pass any kind of parameters around
+			return this._executeContributedCommand<T>(id, args);
+
+		} else {
+			// automagically convert some argument types
+			const toArgs = cloneAndChange(args, function (value) {
+				if (value instanceof extHostTypes.Position) {
+					return extHostTypeConverter.Position.from(value);
+				}
+				if (value instanceof extHostTypes.Range) {
+					return extHostTypeConverter.Range.from(value);
+				}
+				if (value instanceof extHostTypes.Location) {
+					return extHostTypeConverter.location.from(value);
+				}
+				if (!Array.isArray(value)) {
+					return value;
+				}
+			});
+
+			try {
+				const result = await this._proxy.$executeCommand<T>(id, toArgs, retry);
+				return revive<any>(result);
+			} catch (e) {
+				// Rerun the command when it wasn't known, had arguments, and when retry
+				// is enabled. We do this because the command might be registered inside
+				// the extension host now and can therfore accept the arguments as-is.
+				if (e instanceof Error && e.message === '$executeCommand:retry') {
+					return this._doExecuteCommand(id, args, false);
+				} else {
+					throw e;
+				}
+			}
+		}
+	}
+
+	private _executeContributedCommand<T>(id: string, args: any[]): Promise<T> {
+		const command = this._commands.get(id);
+		if (!command) {
+			throw new Error('Unknown command');
+		}
+		let { callback, thisArg, description } = command;
+		if (description) {
+			for (let i = 0; i < description.args.length; i++) {
+				try {
+					validateConstraint(args[i], description.args[i].constraint);
+				} catch (err) {
+					return Promise.reject(new Error(`Running the contributed command: '${id}' failed. Illegal argument '${description.args[i].name}' - ${description.args[i].description}`));
+				}
+			}
+		}
+
+		try {
+			const result = callback.apply(thisArg, args);
+			return Promise.resolve(result);
+		} catch (err) {
+			this._logService.error(err, id);
+			return Promise.reject(new Error(`Running the contributed command: '${id}' failed.`));
+		}
+	}
+
+	$executeContributedCommand<T>(id: string, ...args: any[]): Promise<T> {
+		this._logService.trace('ExtHostCommands#$executeContributedCommand', id);
+
+		if (!this._commands.has(id)) {
+			return Promise.reject(new Error(`Contributed command '${id}' does not exist.`));
+		} else {
+			args = args.map(arg => this._argumentProcessors.reduce((r, p) => p.processArgument(r), arg));
+			return this._executeContributedCommand(id, args);
+		}
+	}
+
+	getCommands(filterUnderscoreCommands: boolean = false): Promise<string[]> {
+		this._logService.trace('ExtHostCommands#getCommands', filterUnderscoreCommands);
+
+		return this._proxy.$getCommands().then(result => {
+			if (filterUnderscoreCommands) {
+				result = result.filter(command => command[0] !== '_');
+			}
+			return result;
+		});
+	}
+
+	$getContributedCommandHandlerDescriptions(): Promise<{ [id: string]: string | ICommandHandlerDescription }> {
+		const result: { [id: string]: string | ICommandHandlerDescription } = Object.create(null);
+		for (let [id, command] of this._commands) {
+			let { description } = command;
+			if (description) {
+				result[id] = description;
+			}
+		}
+		return Promise.resolve(result);
+	}
+}
+
+
+export class CommandsConverter {
+
+	private readonly _delegatingCommandId: string;
+	private readonly _cache = new Map<number, vscode.Command>();
+	private _cachIdPool = 0;
+
+	// --- conversion between internal and api commands
+	constructor(
+		private readonly _commands: ExtHostCommands,
+		private readonly _logService: ILogService
+	) {
+		this._delegatingCommandId = `_vscode_delegate_cmd_${Date.now().toString(36)}`;
+		this._commands.registerCommand(true, this._delegatingCommandId, this._executeConvertedCommand, this);
+	}
+
+	toInternal(command: vscode.Command, disposables: DisposableStore): ICommandDto;
+	toInternal(command: vscode.Command | undefined, disposables: DisposableStore): ICommandDto | undefined;
+	toInternal(command: vscode.Command | undefined, disposables: DisposableStore): ICommandDto | undefined {
+
+		if (!command) {
+			return undefined;
+		}
+
+		const result: ICommandDto = {
+			$ident: undefined,
+			id: command.command,
+			title: command.title,
+			tooltip: command.tooltip
+		};
+
+		if (command.command && isNonEmptyArray(command.arguments)) {
+			// we have a contributed command with arguments. that
+			// means we don't want to send the arguments around
+
+			const id = ++this._cachIdPool;
+			this._cache.set(id, command);
+			disposables.add(toDisposable(() => {
+				this._cache.delete(id);
+				this._logService.trace('CommandsConverter#DISPOSE', id);
+			}));
+			result.$ident = id;
+
+			result.id = this._delegatingCommandId;
+			result.arguments = [id];
+
+			this._logService.trace('CommandsConverter#CREATE', command.command, id);
+		}
+
+		return result;
+	}
+
+	fromInternal(command: modes.Command): vscode.Command | undefined {
+
+		const id = ObjectIdentifier.of(command);
+		if (typeof id === 'number') {
+			return this._cache.get(id);
+
+		} else {
+			return {
+				command: command.id,
+				title: command.title,
+				arguments: command.arguments
+			};
+		}
+	}
+
+	private _executeConvertedCommand<R>(...args: any[]): Promise<R> {
+		const actualCmd = this._cache.get(args[0]);
+		this._logService.trace('CommandsConverter#EXECUTE', args[0], actualCmd ? actualCmd.command : 'MISSING');
+
+		if (!actualCmd) {
+			return Promise.reject('actual command NOT FOUND');
+		}
+		return this._commands.executeCommand(actualCmd.command, ...(actualCmd.arguments || []));
+	}
+
+}
+
+export interface IExtHostCommands extends ExtHostCommands { }
+export const IExtHostCommands = createDecorator<IExtHostCommands>('IExtHostCommands');

lib/vscode/src/vs/workbench/api/common/extHostComments.ts

@@ -0,0 +1,592 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { asPromise } from 'vs/base/common/async';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { debounce } from 'vs/base/common/decorators';
+import { Emitter } from 'vs/base/common/event';
+import { DisposableStore, IDisposable, MutableDisposable } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IRange } from 'vs/editor/common/core/range';
+import * as modes from 'vs/editor/common/modes';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import * as extHostTypeConverter from 'vs/workbench/api/common/extHostTypeConverters';
+import * as types from 'vs/workbench/api/common/extHostTypes';
+import type * as vscode from 'vscode';
+import { ExtHostCommentsShape, IMainContext, MainContext, MainThreadCommentsShape, CommentThreadChanges } from './extHost.protocol';
+import { ExtHostCommands } from './extHostCommands';
+
+type ProviderHandle = number;
+
+export class ExtHostComments implements ExtHostCommentsShape, IDisposable {
+
+	private static handlePool = 0;
+
+	private _proxy: MainThreadCommentsShape;
+
+	private _commentControllers: Map<ProviderHandle, ExtHostCommentController> = new Map<ProviderHandle, ExtHostCommentController>();
+
+	private _commentControllersByExtension: Map<string, ExtHostCommentController[]> = new Map<string, ExtHostCommentController[]>();
+
+
+	constructor(
+		mainContext: IMainContext,
+		commands: ExtHostCommands,
+		private readonly _documents: ExtHostDocuments,
+	) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadComments);
+
+		commands.registerArgumentProcessor({
+			processArgument: arg => {
+				if (arg && arg.$mid === 6) {
+					const commentController = this._commentControllers.get(arg.handle);
+
+					if (!commentController) {
+						return arg;
+					}
+
+					return commentController;
+				} else if (arg && arg.$mid === 7) {
+					const commentController = this._commentControllers.get(arg.commentControlHandle);
+
+					if (!commentController) {
+						return arg;
+					}
+
+					const commentThread = commentController.getCommentThread(arg.commentThreadHandle);
+
+					if (!commentThread) {
+						return arg;
+					}
+
+					return commentThread;
+				} else if (arg && arg.$mid === 8) {
+					const commentController = this._commentControllers.get(arg.thread.commentControlHandle);
+
+					if (!commentController) {
+						return arg;
+					}
+
+					const commentThread = commentController.getCommentThread(arg.thread.commentThreadHandle);
+
+					if (!commentThread) {
+						return arg;
+					}
+
+					return {
+						thread: commentThread,
+						text: arg.text
+					};
+				} else if (arg && arg.$mid === 9) {
+					const commentController = this._commentControllers.get(arg.thread.commentControlHandle);
+
+					if (!commentController) {
+						return arg;
+					}
+
+					const commentThread = commentController.getCommentThread(arg.thread.commentThreadHandle);
+
+					if (!commentThread) {
+						return arg;
+					}
+
+					let commentUniqueId = arg.commentUniqueId;
+
+					let comment = commentThread.getCommentByUniqueId(commentUniqueId);
+
+					if (!comment) {
+						return arg;
+					}
+
+					return comment;
+
+				} else if (arg && arg.$mid === 10) {
+					const commentController = this._commentControllers.get(arg.thread.commentControlHandle);
+
+					if (!commentController) {
+						return arg;
+					}
+
+					const commentThread = commentController.getCommentThread(arg.thread.commentThreadHandle);
+
+					if (!commentThread) {
+						return arg;
+					}
+
+					let body = arg.text;
+					let commentUniqueId = arg.commentUniqueId;
+
+					let comment = commentThread.getCommentByUniqueId(commentUniqueId);
+
+					if (!comment) {
+						return arg;
+					}
+
+					comment.body = body;
+					return comment;
+				}
+
+				return arg;
+			}
+		});
+	}
+
+	createCommentController(extension: IExtensionDescription, id: string, label: string): vscode.CommentController {
+		const handle = ExtHostComments.handlePool++;
+		const commentController = new ExtHostCommentController(extension, handle, this._proxy, id, label);
+		this._commentControllers.set(commentController.handle, commentController);
+
+		const commentControllers = this._commentControllersByExtension.get(ExtensionIdentifier.toKey(extension.identifier)) || [];
+		commentControllers.push(commentController);
+		this._commentControllersByExtension.set(ExtensionIdentifier.toKey(extension.identifier), commentControllers);
+
+		return commentController;
+	}
+
+	$createCommentThreadTemplate(commentControllerHandle: number, uriComponents: UriComponents, range: IRange): void {
+		const commentController = this._commentControllers.get(commentControllerHandle);
+
+		if (!commentController) {
+			return;
+		}
+
+		commentController.$createCommentThreadTemplate(uriComponents, range);
+	}
+
+	async $updateCommentThreadTemplate(commentControllerHandle: number, threadHandle: number, range: IRange) {
+		const commentController = this._commentControllers.get(commentControllerHandle);
+
+		if (!commentController) {
+			return;
+		}
+
+		commentController.$updateCommentThreadTemplate(threadHandle, range);
+	}
+
+	$deleteCommentThread(commentControllerHandle: number, commentThreadHandle: number) {
+		const commentController = this._commentControllers.get(commentControllerHandle);
+
+		if (commentController) {
+			commentController.$deleteCommentThread(commentThreadHandle);
+		}
+	}
+
+	$provideCommentingRanges(commentControllerHandle: number, uriComponents: UriComponents, token: CancellationToken): Promise<IRange[] | undefined> {
+		const commentController = this._commentControllers.get(commentControllerHandle);
+
+		if (!commentController || !commentController.commentingRangeProvider) {
+			return Promise.resolve(undefined);
+		}
+
+		const document = this._documents.getDocument(URI.revive(uriComponents));
+		return asPromise(() => {
+			return commentController.commentingRangeProvider!.provideCommentingRanges(document, token);
+		}).then(ranges => ranges ? ranges.map(x => extHostTypeConverter.Range.from(x)) : undefined);
+	}
+
+	$toggleReaction(commentControllerHandle: number, threadHandle: number, uri: UriComponents, comment: modes.Comment, reaction: modes.CommentReaction): Promise<void> {
+		const commentController = this._commentControllers.get(commentControllerHandle);
+
+		if (!commentController || !commentController.reactionHandler) {
+			return Promise.resolve(undefined);
+		}
+
+		return asPromise(() => {
+			const commentThread = commentController.getCommentThread(threadHandle);
+			if (commentThread) {
+				const vscodeComment = commentThread.getCommentByUniqueId(comment.uniqueIdInThread);
+
+				if (commentController !== undefined && vscodeComment) {
+					if (commentController.reactionHandler) {
+						return commentController.reactionHandler(vscodeComment, convertFromReaction(reaction));
+					}
+				}
+			}
+
+			return Promise.resolve(undefined);
+		});
+	}
+	dispose() {
+
+	}
+}
+type CommentThreadModification = Partial<{
+	range: vscode.Range,
+	label: string | undefined,
+	contextValue: string | undefined,
+	comments: vscode.Comment[],
+	collapsibleState: vscode.CommentThreadCollapsibleState
+	canReply: boolean;
+}>;
+
+export class ExtHostCommentThread implements vscode.CommentThread {
+	private static _handlePool: number = 0;
+	readonly handle = ExtHostCommentThread._handlePool++;
+	public commentHandle: number = 0;
+
+	private modifications: CommentThreadModification = Object.create(null);
+
+	set threadId(id: string) {
+		this._id = id;
+	}
+
+	get threadId(): string {
+		return this._id!;
+	}
+
+	get id(): string {
+		return this._id!;
+	}
+
+	get resource(): vscode.Uri {
+		return this._uri;
+	}
+
+	get uri(): vscode.Uri {
+		return this._uri;
+	}
+
+	private readonly _onDidUpdateCommentThread = new Emitter<void>();
+	readonly onDidUpdateCommentThread = this._onDidUpdateCommentThread.event;
+
+	set range(range: vscode.Range) {
+		if (!range.isEqual(this._range)) {
+			this._range = range;
+			this.modifications.range = range;
+			this._onDidUpdateCommentThread.fire();
+		}
+	}
+
+	get range(): vscode.Range {
+		return this._range;
+	}
+
+	private _canReply: boolean = true;
+
+	set canReply(state: boolean) {
+		if (this._canReply !== state) {
+			this._canReply = state;
+			this.modifications.canReply = state;
+			this._onDidUpdateCommentThread.fire();
+		}
+	}
+	get canReply() {
+		return this._canReply;
+	}
+
+	private _label: string | undefined;
+
+	get label(): string | undefined {
+		return this._label;
+	}
+
+	set label(label: string | undefined) {
+		this._label = label;
+		this.modifications.label = label;
+		this._onDidUpdateCommentThread.fire();
+	}
+
+	private _contextValue: string | undefined;
+
+	get contextValue(): string | undefined {
+		return this._contextValue;
+	}
+
+	set contextValue(context: string | undefined) {
+		this._contextValue = context;
+		this.modifications.contextValue = context;
+		this._onDidUpdateCommentThread.fire();
+	}
+
+	get comments(): vscode.Comment[] {
+		return this._comments;
+	}
+
+	set comments(newComments: vscode.Comment[]) {
+		this._comments = newComments;
+		this.modifications.comments = newComments;
+		this._onDidUpdateCommentThread.fire();
+	}
+
+	private _collapseState?: vscode.CommentThreadCollapsibleState;
+
+	get collapsibleState(): vscode.CommentThreadCollapsibleState {
+		return this._collapseState!;
+	}
+
+	set collapsibleState(newState: vscode.CommentThreadCollapsibleState) {
+		this._collapseState = newState;
+		this.modifications.collapsibleState = newState;
+		this._onDidUpdateCommentThread.fire();
+	}
+
+	private _localDisposables: types.Disposable[];
+
+	private _isDiposed: boolean;
+
+	public get isDisposed(): boolean {
+		return this._isDiposed;
+	}
+
+	private _commentsMap: Map<vscode.Comment, number> = new Map<vscode.Comment, number>();
+
+	private _acceptInputDisposables = new MutableDisposable<DisposableStore>();
+
+	constructor(
+		private _proxy: MainThreadCommentsShape,
+		private _commentController: ExtHostCommentController,
+		private _id: string | undefined,
+		private _uri: vscode.Uri,
+		private _range: vscode.Range,
+		private _comments: vscode.Comment[],
+		extensionId: ExtensionIdentifier
+	) {
+		this._acceptInputDisposables.value = new DisposableStore();
+
+		if (this._id === undefined) {
+			this._id = `${_commentController.id}.${this.handle}`;
+		}
+
+		this._proxy.$createCommentThread(
+			this._commentController.handle,
+			this.handle,
+			this._id,
+			this._uri,
+			extHostTypeConverter.Range.from(this._range),
+			extensionId
+		);
+
+		this._localDisposables = [];
+		this._isDiposed = false;
+
+		this._localDisposables.push(this.onDidUpdateCommentThread(() => {
+			this.eventuallyUpdateCommentThread();
+		}));
+
+		// set up comments after ctor to batch update events.
+		this.comments = _comments;
+	}
+
+
+	@debounce(100)
+	eventuallyUpdateCommentThread(): void {
+		if (this._isDiposed) {
+			return;
+		}
+
+		if (!this._acceptInputDisposables.value) {
+			this._acceptInputDisposables.value = new DisposableStore();
+		}
+
+		const modified = (value: keyof CommentThreadModification): boolean =>
+			Object.prototype.hasOwnProperty.call(this.modifications, value);
+
+		const formattedModifications: CommentThreadChanges = {};
+		if (modified('range')) {
+			formattedModifications.range = extHostTypeConverter.Range.from(this._range);
+		}
+		if (modified('label')) {
+			formattedModifications.label = this.label;
+		}
+		if (modified('contextValue')) {
+			formattedModifications.contextValue = this.contextValue;
+		}
+		if (modified('comments')) {
+			formattedModifications.comments =
+				this._comments.map(cmt => convertToModeComment(this, this._commentController, cmt, this._commentsMap));
+		}
+		if (modified('collapsibleState')) {
+			formattedModifications.collapseState = convertToCollapsibleState(this._collapseState);
+		}
+		if (modified('canReply')) {
+			formattedModifications.canReply = this.canReply;
+		}
+		this.modifications = {};
+
+		this._proxy.$updateCommentThread(
+			this._commentController.handle,
+			this.handle,
+			this._id!,
+			this._uri,
+			formattedModifications
+		);
+	}
+
+	getCommentByUniqueId(uniqueId: number): vscode.Comment | undefined {
+		for (let key of this._commentsMap) {
+			let comment = key[0];
+			let id = key[1];
+			if (uniqueId === id) {
+				return comment;
+			}
+		}
+
+		return;
+	}
+
+	dispose() {
+		this._isDiposed = true;
+		this._acceptInputDisposables.dispose();
+		this._localDisposables.forEach(disposable => disposable.dispose());
+		this._proxy.$deleteCommentThread(
+			this._commentController.handle,
+			this.handle
+		);
+	}
+}
+
+type ReactionHandler = (comment: vscode.Comment, reaction: vscode.CommentReaction) => Promise<void>;
+
+class ExtHostCommentController implements vscode.CommentController {
+	get id(): string {
+		return this._id;
+	}
+
+	get label(): string {
+		return this._label;
+	}
+
+	public get handle(): number {
+		return this._handle;
+	}
+
+	private _threads: Map<number, ExtHostCommentThread> = new Map<number, ExtHostCommentThread>();
+	commentingRangeProvider?: vscode.CommentingRangeProvider;
+
+	private _reactionHandler?: ReactionHandler;
+
+	get reactionHandler(): ReactionHandler | undefined {
+		return this._reactionHandler;
+	}
+
+	set reactionHandler(handler: ReactionHandler | undefined) {
+		this._reactionHandler = handler;
+
+		this._proxy.$updateCommentControllerFeatures(this.handle, { reactionHandler: !!handler });
+	}
+
+	private _options: modes.CommentOptions | undefined;
+
+	get options() {
+		return this._options;
+	}
+
+	set options(options: modes.CommentOptions | undefined) {
+		this._options = options;
+
+		this._proxy.$updateCommentControllerFeatures(this.handle, { options: this._options });
+	}
+
+	constructor(
+		private _extension: IExtensionDescription,
+		private _handle: number,
+		private _proxy: MainThreadCommentsShape,
+		private _id: string,
+		private _label: string
+	) {
+		this._proxy.$registerCommentController(this.handle, _id, _label);
+	}
+
+	createCommentThread(resource: vscode.Uri, range: vscode.Range, comments: vscode.Comment[]): vscode.CommentThread;
+	createCommentThread(arg0: vscode.Uri | string, arg1: vscode.Uri | vscode.Range, arg2: vscode.Range | vscode.Comment[], arg3?: vscode.Comment[]): vscode.CommentThread {
+		if (typeof arg0 === 'string') {
+			const commentThread = new ExtHostCommentThread(this._proxy, this, arg0, arg1 as vscode.Uri, arg2 as vscode.Range, arg3 as vscode.Comment[], this._extension.identifier);
+			this._threads.set(commentThread.handle, commentThread);
+			return commentThread;
+		} else {
+			const commentThread = new ExtHostCommentThread(this._proxy, this, undefined, arg0 as vscode.Uri, arg1 as vscode.Range, arg2 as vscode.Comment[], this._extension.identifier);
+			this._threads.set(commentThread.handle, commentThread);
+			return commentThread;
+		}
+	}
+
+	$createCommentThreadTemplate(uriComponents: UriComponents, range: IRange): ExtHostCommentThread {
+		const commentThread = new ExtHostCommentThread(this._proxy, this, undefined, URI.revive(uriComponents), extHostTypeConverter.Range.to(range), [], this._extension.identifier);
+		commentThread.collapsibleState = modes.CommentThreadCollapsibleState.Expanded;
+		this._threads.set(commentThread.handle, commentThread);
+		return commentThread;
+	}
+
+	$updateCommentThreadTemplate(threadHandle: number, range: IRange): void {
+		let thread = this._threads.get(threadHandle);
+		if (thread) {
+			thread.range = extHostTypeConverter.Range.to(range);
+		}
+	}
+
+	$deleteCommentThread(threadHandle: number): void {
+		let thread = this._threads.get(threadHandle);
+
+		if (thread) {
+			thread.dispose();
+		}
+
+		this._threads.delete(threadHandle);
+	}
+
+	getCommentThread(handle: number): ExtHostCommentThread | undefined {
+		return this._threads.get(handle);
+	}
+
+	dispose(): void {
+		this._threads.forEach(value => {
+			value.dispose();
+		});
+
+		this._proxy.$unregisterCommentController(this.handle);
+	}
+}
+
+function convertToModeComment(thread: ExtHostCommentThread, commentController: ExtHostCommentController, vscodeComment: vscode.Comment, commentsMap: Map<vscode.Comment, number>): modes.Comment {
+	let commentUniqueId = commentsMap.get(vscodeComment)!;
+	if (!commentUniqueId) {
+		commentUniqueId = ++thread.commentHandle;
+		commentsMap.set(vscodeComment, commentUniqueId);
+	}
+
+	const iconPath = vscodeComment.author && vscodeComment.author.iconPath ? vscodeComment.author.iconPath.toString() : undefined;
+
+	return {
+		mode: vscodeComment.mode,
+		contextValue: vscodeComment.contextValue,
+		uniqueIdInThread: commentUniqueId,
+		body: extHostTypeConverter.MarkdownString.from(vscodeComment.body),
+		userName: vscodeComment.author.name,
+		userIconPath: iconPath,
+		label: vscodeComment.label,
+		commentReactions: vscodeComment.reactions ? vscodeComment.reactions.map(reaction => convertToReaction(reaction)) : undefined
+	};
+}
+
+function convertToReaction(reaction: vscode.CommentReaction): modes.CommentReaction {
+	return {
+		label: reaction.label,
+		iconPath: reaction.iconPath ? extHostTypeConverter.pathOrURIToURI(reaction.iconPath) : undefined,
+		count: reaction.count,
+		hasReacted: reaction.authorHasReacted,
+	};
+}
+
+function convertFromReaction(reaction: modes.CommentReaction): vscode.CommentReaction {
+	return {
+		label: reaction.label || '',
+		count: reaction.count || 0,
+		iconPath: reaction.iconPath ? URI.revive(reaction.iconPath) : '',
+		authorHasReacted: reaction.hasReacted || false
+	};
+}
+
+function convertToCollapsibleState(kind: vscode.CommentThreadCollapsibleState | undefined): modes.CommentThreadCollapsibleState {
+	if (kind !== undefined) {
+		switch (kind) {
+			case types.CommentThreadCollapsibleState.Expanded:
+				return modes.CommentThreadCollapsibleState.Expanded;
+			case types.CommentThreadCollapsibleState.Collapsed:
+				return modes.CommentThreadCollapsibleState.Collapsed;
+		}
+	}
+	return modes.CommentThreadCollapsibleState.Collapsed;
+}

lib/vscode/src/vs/workbench/api/common/extHostConfiguration.ts

@@ -0,0 +1,330 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { mixin, deepClone } from 'vs/base/common/objects';
+import { Event, Emitter } from 'vs/base/common/event';
+import type * as vscode from 'vscode';
+import { ExtHostWorkspace, IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
+import { ExtHostConfigurationShape, MainThreadConfigurationShape, IConfigurationInitData, MainContext } from './extHost.protocol';
+import { ConfigurationTarget as ExtHostConfigurationTarget } from './extHostTypes';
+import { ConfigurationTarget, IConfigurationChange, IConfigurationData, IConfigurationOverrides } from 'vs/platform/configuration/common/configuration';
+import { Configuration, ConfigurationChangeEvent } from 'vs/platform/configuration/common/configurationModels';
+import { ConfigurationScope, OVERRIDE_PROPERTY_PATTERN } from 'vs/platform/configuration/common/configurationRegistry';
+import { isObject } from 'vs/base/common/types';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { Barrier } from 'vs/base/common/async';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { ILogService } from 'vs/platform/log/common/log';
+import { Workspace } from 'vs/platform/workspace/common/workspace';
+import { URI } from 'vs/base/common/uri';
+
+function lookUp(tree: any, key: string) {
+	if (key) {
+		const parts = key.split('.');
+		let node = tree;
+		for (let i = 0; node && i < parts.length; i++) {
+			node = node[parts[i]];
+		}
+		return node;
+	}
+}
+
+type ConfigurationInspect<T> = {
+	key: string;
+
+	defaultValue?: T;
+	globalValue?: T;
+	workspaceValue?: T,
+	workspaceFolderValue?: T,
+
+	defaultLanguageValue?: T;
+	globalLanguageValue?: T;
+	workspaceLanguageValue?: T;
+	workspaceFolderLanguageValue?: T;
+
+	languageIds?: string[];
+};
+
+function isUri(thing: any): thing is vscode.Uri {
+	return thing instanceof URI;
+}
+
+function isResourceLanguage(thing: any): thing is { uri: URI, languageId: string } {
+	return thing
+		&& thing.uri instanceof URI
+		&& (thing.languageId && typeof thing.languageId === 'string');
+}
+
+function isLanguage(thing: any): thing is { languageId: string } {
+	return thing
+		&& !thing.uri
+		&& (thing.languageId && typeof thing.languageId === 'string');
+}
+
+function isWorkspaceFolder(thing: any): thing is vscode.WorkspaceFolder {
+	return thing
+		&& thing.uri instanceof URI
+		&& (!thing.name || typeof thing.name === 'string')
+		&& (!thing.index || typeof thing.index === 'number');
+}
+
+function scopeToOverrides(scope: vscode.ConfigurationScope | undefined | null): IConfigurationOverrides | undefined {
+	if (isUri(scope)) {
+		return { resource: scope };
+	}
+	if (isResourceLanguage(scope)) {
+		return { resource: scope.uri, overrideIdentifier: scope.languageId };
+	}
+	if (isLanguage(scope)) {
+		return { overrideIdentifier: scope.languageId };
+	}
+	if (isWorkspaceFolder(scope)) {
+		return { resource: scope.uri };
+	}
+	if (scope === null) {
+		return { resource: null };
+	}
+	return undefined;
+}
+
+export class ExtHostConfiguration implements ExtHostConfigurationShape {
+
+	readonly _serviceBrand: undefined;
+
+	private readonly _proxy: MainThreadConfigurationShape;
+	private readonly _logService: ILogService;
+	private readonly _extHostWorkspace: ExtHostWorkspace;
+	private readonly _barrier: Barrier;
+	private _actual: ExtHostConfigProvider | null;
+
+	constructor(
+		@IExtHostRpcService extHostRpc: IExtHostRpcService,
+		@IExtHostWorkspace extHostWorkspace: IExtHostWorkspace,
+		@ILogService logService: ILogService,
+	) {
+		this._proxy = extHostRpc.getProxy(MainContext.MainThreadConfiguration);
+		this._extHostWorkspace = extHostWorkspace;
+		this._logService = logService;
+		this._barrier = new Barrier();
+		this._actual = null;
+	}
+
+	public getConfigProvider(): Promise<ExtHostConfigProvider> {
+		return this._barrier.wait().then(_ => this._actual!);
+	}
+
+	$initializeConfiguration(data: IConfigurationInitData): void {
+		this._actual = new ExtHostConfigProvider(this._proxy, this._extHostWorkspace, data, this._logService);
+		this._barrier.open();
+	}
+
+	$acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void {
+		this.getConfigProvider().then(provider => provider.$acceptConfigurationChanged(data, change));
+	}
+}
+
+export class ExtHostConfigProvider {
+
+	private readonly _onDidChangeConfiguration = new Emitter<vscode.ConfigurationChangeEvent>();
+	private readonly _proxy: MainThreadConfigurationShape;
+	private readonly _extHostWorkspace: ExtHostWorkspace;
+	private _configurationScopes: Map<string, ConfigurationScope | undefined>;
+	private _configuration: Configuration;
+	private _logService: ILogService;
+
+	constructor(proxy: MainThreadConfigurationShape, extHostWorkspace: ExtHostWorkspace, data: IConfigurationInitData, logService: ILogService) {
+		this._proxy = proxy;
+		this._logService = logService;
+		this._extHostWorkspace = extHostWorkspace;
+		this._configuration = Configuration.parse(data);
+		this._configurationScopes = this._toMap(data.configurationScopes);
+	}
+
+	get onDidChangeConfiguration(): Event<vscode.ConfigurationChangeEvent> {
+		return this._onDidChangeConfiguration && this._onDidChangeConfiguration.event;
+	}
+
+	$acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange) {
+		const previous = { data: this._configuration.toData(), workspace: this._extHostWorkspace.workspace };
+		this._configuration = Configuration.parse(data);
+		this._configurationScopes = this._toMap(data.configurationScopes);
+		this._onDidChangeConfiguration.fire(this._toConfigurationChangeEvent(change, previous));
+	}
+
+	getConfiguration(section?: string, scope?: vscode.ConfigurationScope | null, extensionDescription?: IExtensionDescription): vscode.WorkspaceConfiguration {
+		const overrides = scopeToOverrides(scope) || {};
+		const config = this._toReadonlyValue(section
+			? lookUp(this._configuration.getValue(undefined, overrides, this._extHostWorkspace.workspace), section)
+			: this._configuration.getValue(undefined, overrides, this._extHostWorkspace.workspace));
+
+		if (section) {
+			this._validateConfigurationAccess(section, overrides, extensionDescription?.identifier);
+		}
+
+		function parseConfigurationTarget(arg: boolean | ExtHostConfigurationTarget): ConfigurationTarget | null {
+			if (arg === undefined || arg === null) {
+				return null;
+			}
+			if (typeof arg === 'boolean') {
+				return arg ? ConfigurationTarget.USER : ConfigurationTarget.WORKSPACE;
+			}
+
+			switch (arg) {
+				case ExtHostConfigurationTarget.Global: return ConfigurationTarget.USER;
+				case ExtHostConfigurationTarget.Workspace: return ConfigurationTarget.WORKSPACE;
+				case ExtHostConfigurationTarget.WorkspaceFolder: return ConfigurationTarget.WORKSPACE_FOLDER;
+			}
+		}
+
+		const result: vscode.WorkspaceConfiguration = {
+			has(key: string): boolean {
+				return typeof lookUp(config, key) !== 'undefined';
+			},
+			get: <T>(key: string, defaultValue?: T) => {
+				this._validateConfigurationAccess(section ? `${section}.${key}` : key, overrides, extensionDescription?.identifier);
+				let result = lookUp(config, key);
+				if (typeof result === 'undefined') {
+					result = defaultValue;
+				} else {
+					let clonedConfig: any | undefined = undefined;
+					const cloneOnWriteProxy = (target: any, accessor: string): any => {
+						let clonedTarget: any | undefined = undefined;
+						const cloneTarget = () => {
+							clonedConfig = clonedConfig ? clonedConfig : deepClone(config);
+							clonedTarget = clonedTarget ? clonedTarget : lookUp(clonedConfig, accessor);
+						};
+						return isObject(target) ?
+							new Proxy(target, {
+								get: (target: any, property: PropertyKey) => {
+									if (typeof property === 'string' && property.toLowerCase() === 'tojson') {
+										cloneTarget();
+										return () => clonedTarget;
+									}
+									if (clonedConfig) {
+										clonedTarget = clonedTarget ? clonedTarget : lookUp(clonedConfig, accessor);
+										return clonedTarget[property];
+									}
+									const result = target[property];
+									if (typeof property === 'string') {
+										return cloneOnWriteProxy(result, `${accessor}.${property}`);
+									}
+									return result;
+								},
+								set: (_target: any, property: PropertyKey, value: any) => {
+									cloneTarget();
+									if (clonedTarget) {
+										clonedTarget[property] = value;
+									}
+									return true;
+								},
+								deleteProperty: (_target: any, property: PropertyKey) => {
+									cloneTarget();
+									if (clonedTarget) {
+										delete clonedTarget[property];
+									}
+									return true;
+								},
+								defineProperty: (_target: any, property: PropertyKey, descriptor: any) => {
+									cloneTarget();
+									if (clonedTarget) {
+										Object.defineProperty(clonedTarget, property, descriptor);
+									}
+									return true;
+								}
+							}) : target;
+					};
+					result = cloneOnWriteProxy(result, key);
+				}
+				return result;
+			},
+			update: (key: string, value: any, extHostConfigurationTarget: ExtHostConfigurationTarget | boolean, scopeToLanguage?: boolean) => {
+				key = section ? `${section}.${key}` : key;
+				const target = parseConfigurationTarget(extHostConfigurationTarget);
+				if (value !== undefined) {
+					return this._proxy.$updateConfigurationOption(target, key, value, overrides, scopeToLanguage);
+				} else {
+					return this._proxy.$removeConfigurationOption(target, key, overrides, scopeToLanguage);
+				}
+			},
+			inspect: <T>(key: string): ConfigurationInspect<T> | undefined => {
+				key = section ? `${section}.${key}` : key;
+				const config = deepClone(this._configuration.inspect<T>(key, overrides, this._extHostWorkspace.workspace));
+				if (config) {
+					return {
+						key,
+
+						defaultValue: config.default?.value,
+						globalValue: config.user?.value,
+						workspaceValue: config.workspace?.value,
+						workspaceFolderValue: config.workspaceFolder?.value,
+
+						defaultLanguageValue: config.default?.override,
+						globalLanguageValue: config.user?.override,
+						workspaceLanguageValue: config.workspace?.override,
+						workspaceFolderLanguageValue: config.workspaceFolder?.override,
+
+						languageIds: config.overrideIdentifiers
+					};
+				}
+				return undefined;
+			}
+		};
+
+		if (typeof config === 'object') {
+			mixin(result, config, false);
+		}
+
+		return <vscode.WorkspaceConfiguration>Object.freeze(result);
+	}
+
+	private _toReadonlyValue(result: any): any {
+		const readonlyProxy = (target: any): any => {
+			return isObject(target) ?
+				new Proxy(target, {
+					get: (target: any, property: PropertyKey) => readonlyProxy(target[property]),
+					set: (_target: any, property: PropertyKey, _value: any) => { throw new Error(`TypeError: Cannot assign to read only property '${String(property)}' of object`); },
+					deleteProperty: (_target: any, property: PropertyKey) => { throw new Error(`TypeError: Cannot delete read only property '${String(property)}' of object`); },
+					defineProperty: (_target: any, property: PropertyKey) => { throw new Error(`TypeError: Cannot define property '${String(property)}' for a readonly object`); },
+					setPrototypeOf: (_target: any) => { throw new Error(`TypeError: Cannot set prototype for a readonly object`); },
+					isExtensible: () => false,
+					preventExtensions: () => true
+				}) : target;
+		};
+		return readonlyProxy(result);
+	}
+
+	private _validateConfigurationAccess(key: string, overrides?: IConfigurationOverrides, extensionId?: ExtensionIdentifier): void {
+		const scope = OVERRIDE_PROPERTY_PATTERN.test(key) ? ConfigurationScope.RESOURCE : this._configurationScopes.get(key);
+		const extensionIdText = extensionId ? `[${extensionId.value}] ` : '';
+		if (ConfigurationScope.RESOURCE === scope) {
+			if (typeof overrides?.resource === 'undefined') {
+				this._logService.warn(`${extensionIdText}Accessing a resource scoped configuration without providing a resource is not expected. To get the effective value for '${key}', provide the URI of a resource or 'null' for any resource.`);
+			}
+			return;
+		}
+		if (ConfigurationScope.WINDOW === scope) {
+			if (overrides?.resource) {
+				this._logService.warn(`${extensionIdText}Accessing a window scoped configuration for a resource is not expected. To associate '${key}' to a resource, define its scope to 'resource' in configuration contributions in 'package.json'.`);
+			}
+			return;
+		}
+	}
+
+	private _toConfigurationChangeEvent(change: IConfigurationChange, previous: { data: IConfigurationData, workspace: Workspace | undefined }): vscode.ConfigurationChangeEvent {
+		const event = new ConfigurationChangeEvent(change, previous, this._configuration, this._extHostWorkspace.workspace);
+		return Object.freeze({
+			affectsConfiguration: (section: string, scope?: vscode.ConfigurationScope) => event.affectsConfiguration(section, scopeToOverrides(scope))
+		});
+	}
+
+	private _toMap(scopes: [string, ConfigurationScope | undefined][]): Map<string, ConfigurationScope | undefined> {
+		return scopes.reduce((result, scope) => { result.set(scope[0], scope[1]); return result; }, new Map<string, ConfigurationScope | undefined>());
+	}
+
+}
+
+export const IExtHostConfiguration = createDecorator<IExtHostConfiguration>('IExtHostConfiguration');
+export interface IExtHostConfiguration extends ExtHostConfiguration { }

lib/vscode/src/vs/workbench/api/common/extHostCustomEditors.ts

@@ -0,0 +1,388 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { hash } from 'vs/base/common/hash';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
+import { joinPath } from 'vs/base/common/resources';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import * as modes from 'vs/editor/common/modes';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePaths';
+import { ExtHostWebviews, toExtensionData } from 'vs/workbench/api/common/extHostWebview';
+import { ExtHostWebviewPanels } from 'vs/workbench/api/common/extHostWebviewPanels';
+import { EditorViewColumn } from 'vs/workbench/api/common/shared/editor';
+import type * as vscode from 'vscode';
+import { Cache } from './cache';
+import * as extHostProtocol from './extHost.protocol';
+import * as extHostTypes from './extHostTypes';
+
+
+class CustomDocumentStoreEntry {
+
+	private _backupCounter = 1;
+
+	constructor(
+		public readonly document: vscode.CustomDocument,
+		private readonly _storagePath: URI | undefined,
+	) { }
+
+	private readonly _edits = new Cache<vscode.CustomDocumentEditEvent>('custom documents');
+
+	private _backup?: vscode.CustomDocumentBackup;
+
+	addEdit(item: vscode.CustomDocumentEditEvent): number {
+		return this._edits.add([item]);
+	}
+
+	async undo(editId: number, isDirty: boolean): Promise<void> {
+		await this.getEdit(editId).undo();
+		if (!isDirty) {
+			this.disposeBackup();
+		}
+	}
+
+	async redo(editId: number, isDirty: boolean): Promise<void> {
+		await this.getEdit(editId).redo();
+		if (!isDirty) {
+			this.disposeBackup();
+		}
+	}
+
+	disposeEdits(editIds: number[]): void {
+		for (const id of editIds) {
+			this._edits.delete(id);
+		}
+	}
+
+	getNewBackupUri(): URI {
+		if (!this._storagePath) {
+			throw new Error('Backup requires a valid storage path');
+		}
+		const fileName = hashPath(this.document.uri) + (this._backupCounter++);
+		return joinPath(this._storagePath, fileName);
+	}
+
+	updateBackup(backup: vscode.CustomDocumentBackup): void {
+		this._backup?.delete();
+		this._backup = backup;
+	}
+
+	disposeBackup(): void {
+		this._backup?.delete();
+		this._backup = undefined;
+	}
+
+	private getEdit(editId: number): vscode.CustomDocumentEditEvent {
+		const edit = this._edits.get(editId, 0);
+		if (!edit) {
+			throw new Error('No edit found');
+		}
+		return edit;
+	}
+}
+
+class CustomDocumentStore {
+	private readonly _documents = new Map<string, CustomDocumentStoreEntry>();
+
+	public get(viewType: string, resource: vscode.Uri): CustomDocumentStoreEntry | undefined {
+		return this._documents.get(this.key(viewType, resource));
+	}
+
+	public add(viewType: string, document: vscode.CustomDocument, storagePath: URI | undefined): CustomDocumentStoreEntry {
+		const key = this.key(viewType, document.uri);
+		if (this._documents.has(key)) {
+			throw new Error(`Document already exists for viewType:${viewType} resource:${document.uri}`);
+		}
+		const entry = new CustomDocumentStoreEntry(document, storagePath);
+		this._documents.set(key, entry);
+		return entry;
+	}
+
+	public delete(viewType: string, document: vscode.CustomDocument) {
+		const key = this.key(viewType, document.uri);
+		this._documents.delete(key);
+	}
+
+	private key(viewType: string, resource: vscode.Uri): string {
+		return `${viewType}@@@${resource}`;
+	}
+
+}
+
+const enum WebviewEditorType {
+	Text,
+	Custom
+}
+
+type ProviderEntry = {
+	readonly extension: IExtensionDescription;
+	readonly type: WebviewEditorType.Text;
+	readonly provider: vscode.CustomTextEditorProvider;
+} | {
+	readonly extension: IExtensionDescription;
+	readonly type: WebviewEditorType.Custom;
+	readonly provider: vscode.CustomReadonlyEditorProvider;
+};
+
+class EditorProviderStore {
+	private readonly _providers = new Map<string, ProviderEntry>();
+
+	public addTextProvider(viewType: string, extension: IExtensionDescription, provider: vscode.CustomTextEditorProvider): vscode.Disposable {
+		return this.add(WebviewEditorType.Text, viewType, extension, provider);
+	}
+
+	public addCustomProvider(viewType: string, extension: IExtensionDescription, provider: vscode.CustomReadonlyEditorProvider): vscode.Disposable {
+		return this.add(WebviewEditorType.Custom, viewType, extension, provider);
+	}
+
+	public get(viewType: string): ProviderEntry | undefined {
+		return this._providers.get(viewType);
+	}
+
+	private add(type: WebviewEditorType, viewType: string, extension: IExtensionDescription, provider: vscode.CustomTextEditorProvider | vscode.CustomReadonlyEditorProvider): vscode.Disposable {
+		if (this._providers.has(viewType)) {
+			throw new Error(`Provider for viewType:${viewType} already registered`);
+		}
+		this._providers.set(viewType, { type, extension, provider } as ProviderEntry);
+		return new extHostTypes.Disposable(() => this._providers.delete(viewType));
+	}
+}
+
+export class ExtHostCustomEditors implements extHostProtocol.ExtHostCustomEditorsShape {
+
+	private readonly _proxy: extHostProtocol.MainThreadCustomEditorsShape;
+
+	private readonly _editorProviders = new EditorProviderStore();
+
+	private readonly _documents = new CustomDocumentStore();
+
+	constructor(
+		mainContext: extHostProtocol.IMainContext,
+		private readonly _extHostDocuments: ExtHostDocuments,
+		private readonly _extensionStoragePaths: IExtensionStoragePaths | undefined,
+		private readonly _extHostWebview: ExtHostWebviews,
+		private readonly _extHostWebviewPanels: ExtHostWebviewPanels,
+	) {
+		this._proxy = mainContext.getProxy(extHostProtocol.MainContext.MainThreadCustomEditors);
+	}
+
+	public registerCustomEditorProvider(
+		extension: IExtensionDescription,
+		viewType: string,
+		provider: vscode.CustomReadonlyEditorProvider | vscode.CustomTextEditorProvider,
+		options: { webviewOptions?: vscode.WebviewPanelOptions, supportsMultipleEditorsPerDocument?: boolean },
+	): vscode.Disposable {
+		const disposables = new DisposableStore();
+		if ('resolveCustomTextEditor' in provider) {
+			disposables.add(this._editorProviders.addTextProvider(viewType, extension, provider));
+			this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
+				supportsMove: !!provider.moveCustomTextEditor,
+			});
+		} else {
+			disposables.add(this._editorProviders.addCustomProvider(viewType, extension, provider));
+
+			if (this.supportEditing(provider)) {
+				disposables.add(provider.onDidChangeCustomDocument(e => {
+					const entry = this.getCustomDocumentEntry(viewType, e.document.uri);
+					if (isEditEvent(e)) {
+						const editId = entry.addEdit(e);
+						this._proxy.$onDidEdit(e.document.uri, viewType, editId, e.label);
+					} else {
+						this._proxy.$onContentChange(e.document.uri, viewType);
+					}
+				}));
+			}
+
+			this._proxy.$registerCustomEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, !!options.supportsMultipleEditorsPerDocument);
+		}
+
+		return extHostTypes.Disposable.from(
+			disposables,
+			new extHostTypes.Disposable(() => {
+				this._proxy.$unregisterEditorProvider(viewType);
+			}));
+	}
+
+
+	async $createCustomDocument(resource: UriComponents, viewType: string, backupId: string | undefined, cancellation: CancellationToken) {
+		const entry = this._editorProviders.get(viewType);
+		if (!entry) {
+			throw new Error(`No provider found for '${viewType}'`);
+		}
+
+		if (entry.type !== WebviewEditorType.Custom) {
+			throw new Error(`Invalid provide type for '${viewType}'`);
+		}
+
+		const revivedResource = URI.revive(resource);
+		const document = await entry.provider.openCustomDocument(revivedResource, { backupId }, cancellation);
+
+		let storageRoot: URI | undefined;
+		if (this.supportEditing(entry.provider) && this._extensionStoragePaths) {
+			storageRoot = this._extensionStoragePaths.workspaceValue(entry.extension) ?? this._extensionStoragePaths.globalValue(entry.extension);
+		}
+		this._documents.add(viewType, document, storageRoot);
+
+		return { editable: this.supportEditing(entry.provider) };
+	}
+
+	async $disposeCustomDocument(resource: UriComponents, viewType: string): Promise<void> {
+		const entry = this._editorProviders.get(viewType);
+		if (!entry) {
+			throw new Error(`No provider found for '${viewType}'`);
+		}
+
+		if (entry.type !== WebviewEditorType.Custom) {
+			throw new Error(`Invalid provider type for '${viewType}'`);
+		}
+
+		const revivedResource = URI.revive(resource);
+		const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
+		this._documents.delete(viewType, document);
+		document.dispose();
+	}
+
+	async $resolveWebviewEditor(
+		resource: UriComponents,
+		handle: extHostProtocol.WebviewHandle,
+		viewType: string,
+		title: string,
+		position: EditorViewColumn,
+		options: modes.IWebviewOptions & modes.IWebviewPanelOptions,
+		cancellation: CancellationToken,
+	): Promise<void> {
+		const entry = this._editorProviders.get(viewType);
+		if (!entry) {
+			throw new Error(`No provider found for '${viewType}'`);
+		}
+
+		const webview = this._extHostWebview.createNewWebview(handle, options, entry.extension);
+		const panel = this._extHostWebviewPanels.createNewWebviewPanel(handle, viewType, title, position, options, webview);
+
+		const revivedResource = URI.revive(resource);
+
+		switch (entry.type) {
+			case WebviewEditorType.Custom:
+				{
+					const { document } = this.getCustomDocumentEntry(viewType, revivedResource);
+					return entry.provider.resolveCustomEditor(document, panel, cancellation);
+				}
+			case WebviewEditorType.Text:
+				{
+					const document = this._extHostDocuments.getDocument(revivedResource);
+					return entry.provider.resolveCustomTextEditor(document, panel, cancellation);
+				}
+			default:
+				{
+					throw new Error('Unknown webview provider type');
+				}
+		}
+	}
+
+	$disposeEdits(resourceComponents: UriComponents, viewType: string, editIds: number[]): void {
+		const document = this.getCustomDocumentEntry(viewType, resourceComponents);
+		document.disposeEdits(editIds);
+	}
+
+	async $onMoveCustomEditor(handle: string, newResourceComponents: UriComponents, viewType: string): Promise<void> {
+		const entry = this._editorProviders.get(viewType);
+		if (!entry) {
+			throw new Error(`No provider found for '${viewType}'`);
+		}
+
+		if (!(entry.provider as vscode.CustomTextEditorProvider).moveCustomTextEditor) {
+			throw new Error(`Provider does not implement move '${viewType}'`);
+		}
+
+		const webview = this._extHostWebviewPanels.getWebviewPanel(handle);
+		if (!webview) {
+			throw new Error(`No webview found`);
+		}
+
+		const resource = URI.revive(newResourceComponents);
+		const document = this._extHostDocuments.getDocument(resource);
+		await (entry.provider as vscode.CustomTextEditorProvider).moveCustomTextEditor!(document, webview, CancellationToken.None);
+	}
+
+	async $undo(resourceComponents: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void> {
+		const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+		return entry.undo(editId, isDirty);
+	}
+
+	async $redo(resourceComponents: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void> {
+		const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+		return entry.redo(editId, isDirty);
+	}
+
+	async $revert(resourceComponents: UriComponents, viewType: string, cancellation: CancellationToken): Promise<void> {
+		const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+		const provider = this.getCustomEditorProvider(viewType);
+		await provider.revertCustomDocument(entry.document, cancellation);
+		entry.disposeBackup();
+	}
+
+	async $onSave(resourceComponents: UriComponents, viewType: string, cancellation: CancellationToken): Promise<void> {
+		const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+		const provider = this.getCustomEditorProvider(viewType);
+		await provider.saveCustomDocument(entry.document, cancellation);
+		entry.disposeBackup();
+	}
+
+	async $onSaveAs(resourceComponents: UriComponents, viewType: string, targetResource: UriComponents, cancellation: CancellationToken): Promise<void> {
+		const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+		const provider = this.getCustomEditorProvider(viewType);
+		return provider.saveCustomDocumentAs(entry.document, URI.revive(targetResource), cancellation);
+	}
+
+	async $backup(resourceComponents: UriComponents, viewType: string, cancellation: CancellationToken): Promise<string> {
+		const entry = this.getCustomDocumentEntry(viewType, resourceComponents);
+		const provider = this.getCustomEditorProvider(viewType);
+
+		const backup = await provider.backupCustomDocument(entry.document, {
+			destination: entry.getNewBackupUri(),
+		}, cancellation);
+		entry.updateBackup(backup);
+		return backup.id;
+	}
+
+
+	private getCustomDocumentEntry(viewType: string, resource: UriComponents): CustomDocumentStoreEntry {
+		const entry = this._documents.get(viewType, URI.revive(resource));
+		if (!entry) {
+			throw new Error('No custom document found');
+		}
+		return entry;
+	}
+
+	private getCustomEditorProvider(viewType: string): vscode.CustomEditorProvider {
+		const entry = this._editorProviders.get(viewType);
+		const provider = entry?.provider;
+		if (!provider || !this.supportEditing(provider)) {
+			throw new Error('Custom document is not editable');
+		}
+		return provider;
+	}
+
+	private supportEditing(
+		provider: vscode.CustomTextEditorProvider | vscode.CustomEditorProvider | vscode.CustomReadonlyEditorProvider
+	): provider is vscode.CustomEditorProvider {
+		return !!(provider as vscode.CustomEditorProvider).onDidChangeCustomDocument;
+	}
+}
+
+
+function isEditEvent(e: vscode.CustomDocumentContentChangeEvent | vscode.CustomDocumentEditEvent): e is vscode.CustomDocumentEditEvent {
+	return typeof (e as vscode.CustomDocumentEditEvent).undo === 'function'
+		&& typeof (e as vscode.CustomDocumentEditEvent).redo === 'function';
+}
+
+function hashPath(resource: URI): string {
+	const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : resource.toString();
+	return hash(str) + '';
+}
+

lib/vscode/src/vs/workbench/api/common/extHostCustomers.ts

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { IConstructorSignature1, BrandedService } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { ProxyIdentifier } from 'vs/workbench/services/extensions/common/proxyIdentifier';
+
+export type IExtHostNamedCustomer<T extends IDisposable> = [ProxyIdentifier<T>, IExtHostCustomerCtor<T>];
+
+export type IExtHostCustomerCtor<T extends IDisposable> = IConstructorSignature1<IExtHostContext, T>;
+
+export function extHostNamedCustomer<T extends IDisposable>(id: ProxyIdentifier<T>) {
+	return function <Services extends BrandedService[]>(ctor: { new(context: IExtHostContext, ...services: Services): T }): void {
+		ExtHostCustomersRegistryImpl.INSTANCE.registerNamedCustomer(id, ctor as IExtHostCustomerCtor<T>);
+	};
+}
+
+export function extHostCustomer<T extends IDisposable, Services extends BrandedService[]>(ctor: { new(context: IExtHostContext, ...services: Services): T }): void {
+	ExtHostCustomersRegistryImpl.INSTANCE.registerCustomer(ctor as IExtHostCustomerCtor<T>);
+}
+
+export namespace ExtHostCustomersRegistry {
+
+	export function getNamedCustomers(): IExtHostNamedCustomer<IDisposable>[] {
+		return ExtHostCustomersRegistryImpl.INSTANCE.getNamedCustomers();
+	}
+
+	export function getCustomers(): IExtHostCustomerCtor<IDisposable>[] {
+		return ExtHostCustomersRegistryImpl.INSTANCE.getCustomers();
+	}
+}
+
+class ExtHostCustomersRegistryImpl {
+
+	public static readonly INSTANCE = new ExtHostCustomersRegistryImpl();
+
+	private _namedCustomers: IExtHostNamedCustomer<any>[];
+	private _customers: IExtHostCustomerCtor<any>[];
+
+	constructor() {
+		this._namedCustomers = [];
+		this._customers = [];
+	}
+
+	public registerNamedCustomer<T extends IDisposable>(id: ProxyIdentifier<T>, ctor: IExtHostCustomerCtor<T>): void {
+		const entry: IExtHostNamedCustomer<T> = [id, ctor];
+		this._namedCustomers.push(entry);
+	}
+	public getNamedCustomers(): IExtHostNamedCustomer<any>[] {
+		return this._namedCustomers;
+	}
+
+	public registerCustomer<T extends IDisposable>(ctor: IExtHostCustomerCtor<T>): void {
+		this._customers.push(ctor);
+	}
+	public getCustomers(): IExtHostCustomerCtor<any>[] {
+		return this._customers;
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDecorations.ts

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from 'vscode';
+import { URI } from 'vs/base/common/uri';
+import { MainContext, ExtHostDecorationsShape, MainThreadDecorationsShape, DecorationData, DecorationRequest, DecorationReply } from 'vs/workbench/api/common/extHost.protocol';
+import { Disposable, FileDecoration } from 'vs/workbench/api/common/extHostTypes';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { ILogService } from 'vs/platform/log/common/log';
+import { asArray, groupBy } from 'vs/base/common/arrays';
+import { compare, count } from 'vs/base/common/strings';
+import { dirname } from 'vs/base/common/path';
+
+interface ProviderData {
+	provider: vscode.FileDecorationProvider;
+	extensionId: ExtensionIdentifier;
+}
+
+export class ExtHostDecorations implements ExtHostDecorationsShape {
+
+	private static _handlePool = 0;
+	private static _maxEventSize = 250;
+
+	readonly _serviceBrand: undefined;
+	private readonly _provider = new Map<number, ProviderData>();
+	private readonly _proxy: MainThreadDecorationsShape;
+
+	constructor(
+		@IExtHostRpcService extHostRpc: IExtHostRpcService,
+		@ILogService private readonly _logService: ILogService,
+	) {
+		this._proxy = extHostRpc.getProxy(MainContext.MainThreadDecorations);
+	}
+
+	registerDecorationProvider(provider: vscode.FileDecorationProvider, extensionId: ExtensionIdentifier): vscode.Disposable {
+		const handle = ExtHostDecorations._handlePool++;
+		this._provider.set(handle, { provider, extensionId });
+		this._proxy.$registerDecorationProvider(handle, extensionId.value);
+
+		const listener = provider.onDidChange(e => {
+			if (!e) {
+				this._proxy.$onDidChange(handle, null);
+				return;
+			}
+			let array = asArray(e);
+			if (array.length <= ExtHostDecorations._maxEventSize) {
+				this._proxy.$onDidChange(handle, array);
+				return;
+			}
+
+			// too many resources per event. pick one resource per folder, starting
+			// with parent folders
+			this._logService.warn('[Decorations] CAPPING events from decorations provider', extensionId.value, array.length);
+			const mapped = array.map(uri => ({ uri, rank: count(uri.path, '/') }));
+			const groups = groupBy(mapped, (a, b) => a.rank - b.rank || compare(a.uri.path, b.uri.path));
+			let picked: URI[] = [];
+			outer: for (let uris of groups) {
+				let lastDirname: string | undefined;
+				for (let obj of uris) {
+					let myDirname = dirname(obj.uri.path);
+					if (lastDirname !== myDirname) {
+						lastDirname = myDirname;
+						if (picked.push(obj.uri) >= ExtHostDecorations._maxEventSize) {
+							break outer;
+						}
+					}
+				}
+			}
+			this._proxy.$onDidChange(handle, picked);
+		});
+
+		return new Disposable(() => {
+			listener.dispose();
+			this._proxy.$unregisterDecorationProvider(handle);
+			this._provider.delete(handle);
+		});
+	}
+
+	async $provideDecorations(handle: number, requests: DecorationRequest[], token: CancellationToken): Promise<DecorationReply> {
+
+		if (!this._provider.has(handle)) {
+			// might have been unregistered in the meantime
+			return Object.create(null);
+		}
+
+		const result: DecorationReply = Object.create(null);
+		const { provider, extensionId } = this._provider.get(handle)!;
+
+		await Promise.all(requests.map(async request => {
+			try {
+				const { uri, id } = request;
+				const data = await Promise.resolve(provider.provideFileDecoration(URI.revive(uri), token));
+				if (!data) {
+					return;
+				}
+				try {
+					FileDecoration.validate(data);
+					result[id] = <DecorationData>[data.propagate, data.tooltip, data.badge, data.color];
+				} catch (e) {
+					this._logService.warn(`INVALID decoration from extension '${extensionId.value}': ${e}`);
+				}
+			} catch (err) {
+				this._logService.error(err);
+			}
+		}));
+
+		return result;
+	}
+}
+
+export const IExtHostDecorations = createDecorator<IExtHostDecorations>('IExtHostDecorations');
+export interface IExtHostDecorations extends ExtHostDecorations { }

lib/vscode/src/vs/workbench/api/common/extHostDiagnostics.ts

@@ -0,0 +1,350 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { IMarkerData, MarkerSeverity } from 'vs/platform/markers/common/markers';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import type * as vscode from 'vscode';
+import { MainContext, MainThreadDiagnosticsShape, ExtHostDiagnosticsShape, IMainContext } from './extHost.protocol';
+import { DiagnosticSeverity } from './extHostTypes';
+import * as converter from './extHostTypeConverters';
+import { mergeSort } from 'vs/base/common/arrays';
+import { Event, Emitter } from 'vs/base/common/event';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ResourceMap } from 'vs/base/common/map';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+export class DiagnosticCollection implements vscode.DiagnosticCollection {
+
+	private _isDisposed = false;
+	private _data = new ResourceMap<vscode.Diagnostic[]>();
+
+	constructor(
+		private readonly _name: string,
+		private readonly _owner: string,
+		private readonly _maxDiagnosticsPerFile: number,
+		private readonly _proxy: MainThreadDiagnosticsShape | undefined,
+		private readonly _onDidChangeDiagnostics: Emitter<vscode.Uri[]>
+	) { }
+
+	dispose(): void {
+		if (!this._isDisposed) {
+			this._onDidChangeDiagnostics.fire([...this._data.keys()]);
+			if (this._proxy) {
+				this._proxy.$clear(this._owner);
+			}
+			this._data = undefined!;
+			this._isDisposed = true;
+		}
+	}
+
+	get name(): string {
+		this._checkDisposed();
+		return this._name;
+	}
+
+	set(uri: vscode.Uri, diagnostics: ReadonlyArray<vscode.Diagnostic>): void;
+	set(entries: ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic>]>): void;
+	set(first: vscode.Uri | ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic>]>, diagnostics?: ReadonlyArray<vscode.Diagnostic>) {
+
+		if (!first) {
+			// this set-call is a clear-call
+			this.clear();
+			return;
+		}
+
+		// the actual implementation for #set
+
+		this._checkDisposed();
+		let toSync: vscode.Uri[] = [];
+
+		if (URI.isUri(first)) {
+
+			if (!diagnostics) {
+				// remove this entry
+				this.delete(first);
+				return;
+			}
+
+			// update single row
+			this._data.set(first, diagnostics.slice());
+			toSync = [first];
+
+		} else if (Array.isArray(first)) {
+			// update many rows
+			toSync = [];
+			let lastUri: vscode.Uri | undefined;
+
+			// ensure stable-sort
+			first = mergeSort([...first], DiagnosticCollection._compareIndexedTuplesByUri);
+
+			for (const tuple of first) {
+				const [uri, diagnostics] = tuple;
+				if (!lastUri || uri.toString() !== lastUri.toString()) {
+					if (lastUri && this._data.get(lastUri)!.length === 0) {
+						this._data.delete(lastUri);
+					}
+					lastUri = uri;
+					toSync.push(uri);
+					this._data.set(uri, []);
+				}
+
+				if (!diagnostics) {
+					// [Uri, undefined] means clear this
+					const currentDiagnostics = this._data.get(uri);
+					if (currentDiagnostics) {
+						currentDiagnostics.length = 0;
+					}
+				} else {
+					const currentDiagnostics = this._data.get(uri);
+					if (currentDiagnostics) {
+						currentDiagnostics.push(...diagnostics);
+					}
+				}
+			}
+		}
+
+		// send event for extensions
+		this._onDidChangeDiagnostics.fire(toSync);
+
+		// compute change and send to main side
+		if (!this._proxy) {
+			return;
+		}
+		const entries: [URI, IMarkerData[]][] = [];
+		for (let uri of toSync) {
+			let marker: IMarkerData[] = [];
+			const diagnostics = this._data.get(uri);
+			if (diagnostics) {
+
+				// no more than N diagnostics per file
+				if (diagnostics.length > this._maxDiagnosticsPerFile) {
+					marker = [];
+					const order = [DiagnosticSeverity.Error, DiagnosticSeverity.Warning, DiagnosticSeverity.Information, DiagnosticSeverity.Hint];
+					orderLoop: for (let i = 0; i < 4; i++) {
+						for (let diagnostic of diagnostics) {
+							if (diagnostic.severity === order[i]) {
+								const len = marker.push(converter.Diagnostic.from(diagnostic));
+								if (len === this._maxDiagnosticsPerFile) {
+									break orderLoop;
+								}
+							}
+						}
+					}
+
+					// add 'signal' marker for showing omitted errors/warnings
+					marker.push({
+						severity: MarkerSeverity.Info,
+						message: localize({ key: 'limitHit', comment: ['amount of errors/warning skipped due to limits'] }, "Not showing {0} further errors and warnings.", diagnostics.length - this._maxDiagnosticsPerFile),
+						startLineNumber: marker[marker.length - 1].startLineNumber,
+						startColumn: marker[marker.length - 1].startColumn,
+						endLineNumber: marker[marker.length - 1].endLineNumber,
+						endColumn: marker[marker.length - 1].endColumn
+					});
+				} else {
+					marker = diagnostics.map(diag => converter.Diagnostic.from(diag));
+				}
+			}
+
+			entries.push([uri, marker]);
+		}
+		this._proxy.$changeMany(this._owner, entries);
+	}
+
+	delete(uri: vscode.Uri): void {
+		this._checkDisposed();
+		this._onDidChangeDiagnostics.fire([uri]);
+		this._data.delete(uri);
+		if (this._proxy) {
+			this._proxy.$changeMany(this._owner, [[uri, undefined]]);
+		}
+	}
+
+	clear(): void {
+		this._checkDisposed();
+		this._onDidChangeDiagnostics.fire([...this._data.keys()]);
+		this._data.clear();
+		if (this._proxy) {
+			this._proxy.$clear(this._owner);
+		}
+	}
+
+	forEach(callback: (uri: URI, diagnostics: ReadonlyArray<vscode.Diagnostic>, collection: DiagnosticCollection) => any, thisArg?: any): void {
+		this._checkDisposed();
+		for (let uri of this._data.keys()) {
+			callback.apply(thisArg, [uri, this.get(uri), this]);
+		}
+	}
+
+	get(uri: URI): ReadonlyArray<vscode.Diagnostic> {
+		this._checkDisposed();
+		const result = this._data.get(uri);
+		if (Array.isArray(result)) {
+			return <ReadonlyArray<vscode.Diagnostic>>Object.freeze(result.slice(0));
+		}
+		return [];
+	}
+
+	has(uri: URI): boolean {
+		this._checkDisposed();
+		return Array.isArray(this._data.get(uri));
+	}
+
+	private _checkDisposed() {
+		if (this._isDisposed) {
+			throw new Error('illegal state - object is disposed');
+		}
+	}
+
+	private static _compareIndexedTuplesByUri(a: [vscode.Uri, readonly vscode.Diagnostic[]], b: [vscode.Uri, readonly vscode.Diagnostic[]]): number {
+		if (a[0].toString() < b[0].toString()) {
+			return -1;
+		} else if (a[0].toString() > b[0].toString()) {
+			return 1;
+		} else {
+			return 0;
+		}
+	}
+}
+
+export class ExtHostDiagnostics implements ExtHostDiagnosticsShape {
+
+	private static _idPool: number = 0;
+	private static readonly _maxDiagnosticsPerFile: number = 1000;
+
+	private readonly _proxy: MainThreadDiagnosticsShape;
+	private readonly _collections = new Map<string, DiagnosticCollection>();
+	private readonly _onDidChangeDiagnostics = new Emitter<vscode.Uri[]>();
+
+	static _debouncer(last: (vscode.Uri | string)[] | undefined, current: (vscode.Uri | string)[]): (vscode.Uri | string)[] {
+		if (!last) {
+			return current;
+		} else {
+			return last.concat(current);
+		}
+	}
+
+	static _mapper(last: (vscode.Uri | string)[]): { uris: vscode.Uri[] } {
+		const uris: vscode.Uri[] = [];
+		const map = new Set<string>();
+		for (const uri of last) {
+			if (typeof uri === 'string') {
+				if (!map.has(uri)) {
+					map.add(uri);
+					uris.push(URI.parse(uri));
+				}
+			} else {
+				if (!map.has(uri.toString())) {
+					map.add(uri.toString());
+					uris.push(uri);
+				}
+			}
+		}
+		Object.freeze(uris);
+		return { uris };
+	}
+
+	readonly onDidChangeDiagnostics: Event<vscode.DiagnosticChangeEvent> = Event.map(Event.debounce(this._onDidChangeDiagnostics.event, ExtHostDiagnostics._debouncer, 50), ExtHostDiagnostics._mapper);
+
+	constructor(mainContext: IMainContext, @ILogService private readonly _logService: ILogService) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadDiagnostics);
+	}
+
+	createDiagnosticCollection(extensionId: ExtensionIdentifier, name?: string): vscode.DiagnosticCollection {
+
+		const { _collections, _proxy, _onDidChangeDiagnostics, _logService } = this;
+
+		const loggingProxy = new class implements MainThreadDiagnosticsShape {
+			$changeMany(owner: string, entries: [UriComponents, IMarkerData[] | undefined][]): void {
+				_proxy.$changeMany(owner, entries);
+				_logService.trace('[DiagnosticCollection] change many (extension, owner, uris)', extensionId.value, owner, entries.length === 0 ? 'CLEARING' : entries);
+			}
+			$clear(owner: string): void {
+				_proxy.$clear(owner);
+				_logService.trace('[DiagnosticCollection] remove all (extension, owner)', extensionId.value, owner);
+			}
+			dispose(): void {
+				_proxy.dispose();
+			}
+		};
+
+
+		let owner: string;
+		if (!name) {
+			name = '_generated_diagnostic_collection_name_#' + ExtHostDiagnostics._idPool++;
+			owner = name;
+		} else if (!_collections.has(name)) {
+			owner = name;
+		} else {
+			this._logService.warn(`DiagnosticCollection with name '${name}' does already exist.`);
+			do {
+				owner = name + ExtHostDiagnostics._idPool++;
+			} while (_collections.has(owner));
+		}
+
+		const result = new class extends DiagnosticCollection {
+			constructor() {
+				super(name!, owner, ExtHostDiagnostics._maxDiagnosticsPerFile, loggingProxy, _onDidChangeDiagnostics);
+				_collections.set(owner, this);
+			}
+			dispose() {
+				super.dispose();
+				_collections.delete(owner);
+			}
+		};
+
+		return result;
+	}
+
+	getDiagnostics(resource: vscode.Uri): ReadonlyArray<vscode.Diagnostic>;
+	getDiagnostics(): ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic>]>;
+	getDiagnostics(resource?: vscode.Uri): ReadonlyArray<vscode.Diagnostic> | ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic>]>;
+	getDiagnostics(resource?: vscode.Uri): ReadonlyArray<vscode.Diagnostic> | ReadonlyArray<[vscode.Uri, ReadonlyArray<vscode.Diagnostic>]> {
+		if (resource) {
+			return this._getDiagnostics(resource);
+		} else {
+			const index = new Map<string, number>();
+			const res: [vscode.Uri, vscode.Diagnostic[]][] = [];
+			for (const collection of this._collections.values()) {
+				collection.forEach((uri, diagnostics) => {
+					let idx = index.get(uri.toString());
+					if (typeof idx === 'undefined') {
+						idx = res.length;
+						index.set(uri.toString(), idx);
+						res.push([uri, []]);
+					}
+					res[idx][1] = res[idx][1].concat(...diagnostics);
+				});
+			}
+			return res;
+		}
+	}
+
+	private _getDiagnostics(resource: vscode.Uri): ReadonlyArray<vscode.Diagnostic> {
+		let res: vscode.Diagnostic[] = [];
+		for (let collection of this._collections.values()) {
+			if (collection.has(resource)) {
+				res = res.concat(collection.get(resource));
+			}
+		}
+		return res;
+	}
+
+	private _mirrorCollection: vscode.DiagnosticCollection | undefined;
+
+	$acceptMarkersChange(data: [UriComponents, IMarkerData[]][]): void {
+
+		if (!this._mirrorCollection) {
+			const name = '_generated_mirror';
+			const collection = new DiagnosticCollection(name, name, ExtHostDiagnostics._maxDiagnosticsPerFile, undefined, this._onDidChangeDiagnostics);
+			this._collections.set(name, collection);
+			this._mirrorCollection = collection;
+		}
+
+		for (const [uri, markers] of data) {
+			this._mirrorCollection.set(URI.revive(uri), markers.map(converter.Diagnostic.to));
+		}
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDialogs.ts

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from 'vscode';
+import { URI } from 'vs/base/common/uri';
+import { MainContext, MainThreadDiaglogsShape, IMainContext } from 'vs/workbench/api/common/extHost.protocol';
+
+export class ExtHostDialogs {
+
+	private readonly _proxy: MainThreadDiaglogsShape;
+
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadDialogs);
+	}
+
+	showOpenDialog(options?: vscode.OpenDialogOptions): Promise<URI[] | undefined> {
+		return this._proxy.$showOpenDialog(options).then(filepaths => {
+			return filepaths ? filepaths.map(p => URI.revive(p)) : undefined;
+		});
+	}
+
+	showSaveDialog(options?: vscode.SaveDialogOptions): Promise<URI | undefined> {
+		return this._proxy.$showSaveDialog(options).then(filepath => {
+			return filepath ? URI.revive(filepath) : undefined;
+		});
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDocumentContentProviders.ts

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'vs/workbench/api/common/extHostTypes';
+import type * as vscode from 'vscode';
+import { MainContext, ExtHostDocumentContentProvidersShape, MainThreadDocumentContentProvidersShape, IMainContext } from './extHost.protocol';
+import { ExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors';
+import { Schemas } from 'vs/base/common/network';
+import { ILogService } from 'vs/platform/log/common/log';
+import { CancellationToken } from 'vs/base/common/cancellation';
+
+export class ExtHostDocumentContentProvider implements ExtHostDocumentContentProvidersShape {
+
+	private static _handlePool = 0;
+
+	private readonly _documentContentProviders = new Map<number, vscode.TextDocumentContentProvider>();
+	private readonly _proxy: MainThreadDocumentContentProvidersShape;
+
+	constructor(
+		mainContext: IMainContext,
+		private readonly _documentsAndEditors: ExtHostDocumentsAndEditors,
+		private readonly _logService: ILogService,
+	) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadDocumentContentProviders);
+	}
+
+	registerTextDocumentContentProvider(scheme: string, provider: vscode.TextDocumentContentProvider): vscode.Disposable {
+		// todo@remote
+		// check with scheme from fs-providers!
+		if (Object.keys(Schemas).indexOf(scheme) >= 0) {
+			throw new Error(`scheme '${scheme}' already registered`);
+		}
+
+		const handle = ExtHostDocumentContentProvider._handlePool++;
+
+		this._documentContentProviders.set(handle, provider);
+		this._proxy.$registerTextContentProvider(handle, scheme);
+
+		let subscription: IDisposable | undefined;
+		if (typeof provider.onDidChange === 'function') {
+			subscription = provider.onDidChange(uri => {
+				if (uri.scheme !== scheme) {
+					this._logService.warn(`Provider for scheme '${scheme}' is firing event for schema '${uri.scheme}' which will be IGNORED`);
+					return;
+				}
+				if (this._documentsAndEditors.getDocument(uri)) {
+					this.$provideTextDocumentContent(handle, uri).then(value => {
+						if (!value && typeof value !== 'string') {
+							return;
+						}
+
+						const document = this._documentsAndEditors.getDocument(uri);
+						if (!document) {
+							// disposed in the meantime
+							return;
+						}
+
+						// create lines and compare
+						const lines = value.split(/\r\n|\r|\n/);
+
+						// broadcast event when content changed
+						if (!document.equalLines(lines)) {
+							return this._proxy.$onVirtualDocumentChange(uri, value);
+						}
+
+					}, onUnexpectedError);
+				}
+			});
+		}
+		return new Disposable(() => {
+			if (this._documentContentProviders.delete(handle)) {
+				this._proxy.$unregisterTextContentProvider(handle);
+			}
+			if (subscription) {
+				subscription.dispose();
+				subscription = undefined;
+			}
+		});
+	}
+
+	$provideTextDocumentContent(handle: number, uri: UriComponents): Promise<string | null | undefined> {
+		const provider = this._documentContentProviders.get(handle);
+		if (!provider) {
+			return Promise.reject(new Error(`unsupported uri-scheme: ${uri.scheme}`));
+		}
+		return Promise.resolve(provider.provideTextDocumentContent(URI.revive(uri), CancellationToken.None));
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDocumentData.ts

@@ -0,0 +1,283 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ok } from 'vs/base/common/assert';
+import { Schemas } from 'vs/base/common/network';
+import { regExpLeadsToEndlessLoop } from 'vs/base/common/strings';
+import { URI } from 'vs/base/common/uri';
+import { MirrorTextModel } from 'vs/editor/common/model/mirrorTextModel';
+import { ensureValidWordDefinition, getWordAtText } from 'vs/editor/common/model/wordHelper';
+import { MainThreadDocumentsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { EndOfLine, Position, Range } from 'vs/workbench/api/common/extHostTypes';
+import type * as vscode from 'vscode';
+import { equals } from 'vs/base/common/arrays';
+
+const _modeId2WordDefinition = new Map<string, RegExp>();
+export function setWordDefinitionFor(modeId: string, wordDefinition: RegExp | undefined): void {
+	if (!wordDefinition) {
+		_modeId2WordDefinition.delete(modeId);
+	} else {
+		_modeId2WordDefinition.set(modeId, wordDefinition);
+	}
+}
+
+export function getWordDefinitionFor(modeId: string): RegExp | undefined {
+	return _modeId2WordDefinition.get(modeId);
+}
+
+export class ExtHostDocumentData extends MirrorTextModel {
+
+	private _document?: vscode.TextDocument;
+	private _isDisposed: boolean = false;
+
+	constructor(
+		private readonly _proxy: MainThreadDocumentsShape,
+		uri: URI, lines: string[], eol: string, versionId: number,
+		private _languageId: string,
+		private _isDirty: boolean,
+		private readonly _notebook?: vscode.NotebookDocument | undefined
+	) {
+		super(uri, lines, eol, versionId);
+	}
+
+	dispose(): void {
+		// we don't really dispose documents but let
+		// extensions still read from them. some
+		// operations, live saving, will now error tho
+		ok(!this._isDisposed);
+		this._isDisposed = true;
+		this._isDirty = false;
+	}
+
+	equalLines(lines: readonly string[]): boolean {
+		return equals(this._lines, lines);
+	}
+
+	get document(): vscode.TextDocument {
+		if (!this._document) {
+			const that = this;
+			this._document = {
+				get uri() { return that._uri; },
+				get fileName() { return that._uri.fsPath; },
+				get isUntitled() { return that._uri.scheme === Schemas.untitled; },
+				get languageId() { return that._languageId; },
+				get version() { return that._versionId; },
+				get isClosed() { return that._isDisposed; },
+				get isDirty() { return that._isDirty; },
+				get notebook() { return that._notebook; },
+				save() { return that._save(); },
+				getText(range?) { return range ? that._getTextInRange(range) : that.getText(); },
+				get eol() { return that._eol === '\n' ? EndOfLine.LF : EndOfLine.CRLF; },
+				get lineCount() { return that._lines.length; },
+				lineAt(lineOrPos: number | vscode.Position) { return that._lineAt(lineOrPos); },
+				offsetAt(pos) { return that._offsetAt(pos); },
+				positionAt(offset) { return that._positionAt(offset); },
+				validateRange(ran) { return that._validateRange(ran); },
+				validatePosition(pos) { return that._validatePosition(pos); },
+				getWordRangeAtPosition(pos, regexp?) { return that._getWordRangeAtPosition(pos, regexp); },
+			};
+		}
+		return Object.freeze(this._document);
+	}
+
+	_acceptLanguageId(newLanguageId: string): void {
+		ok(!this._isDisposed);
+		this._languageId = newLanguageId;
+	}
+
+	_acceptIsDirty(isDirty: boolean): void {
+		ok(!this._isDisposed);
+		this._isDirty = isDirty;
+	}
+
+	private _save(): Promise<boolean> {
+		if (this._isDisposed) {
+			return Promise.reject(new Error('Document has been closed'));
+		}
+		return this._proxy.$trySaveDocument(this._uri);
+	}
+
+	private _getTextInRange(_range: vscode.Range): string {
+		const range = this._validateRange(_range);
+
+		if (range.isEmpty) {
+			return '';
+		}
+
+		if (range.isSingleLine) {
+			return this._lines[range.start.line].substring(range.start.character, range.end.character);
+		}
+
+		const lineEnding = this._eol,
+			startLineIndex = range.start.line,
+			endLineIndex = range.end.line,
+			resultLines: string[] = [];
+
+		resultLines.push(this._lines[startLineIndex].substring(range.start.character));
+		for (let i = startLineIndex + 1; i < endLineIndex; i++) {
+			resultLines.push(this._lines[i]);
+		}
+		resultLines.push(this._lines[endLineIndex].substring(0, range.end.character));
+
+		return resultLines.join(lineEnding);
+	}
+
+	private _lineAt(lineOrPosition: number | vscode.Position): vscode.TextLine {
+
+		let line: number | undefined;
+		if (lineOrPosition instanceof Position) {
+			line = lineOrPosition.line;
+		} else if (typeof lineOrPosition === 'number') {
+			line = lineOrPosition;
+		}
+
+		if (typeof line !== 'number' || line < 0 || line >= this._lines.length || Math.floor(line) !== line) {
+			throw new Error('Illegal value for `line`');
+		}
+
+		return new ExtHostDocumentLine(line, this._lines[line], line === this._lines.length - 1);
+	}
+
+	private _offsetAt(position: vscode.Position): number {
+		position = this._validatePosition(position);
+		this._ensureLineStarts();
+		return this._lineStarts!.getAccumulatedValue(position.line - 1) + position.character;
+	}
+
+	private _positionAt(offset: number): vscode.Position {
+		offset = Math.floor(offset);
+		offset = Math.max(0, offset);
+
+		this._ensureLineStarts();
+		const out = this._lineStarts!.getIndexOf(offset);
+
+		const lineLength = this._lines[out.index].length;
+
+		// Ensure we return a valid position
+		return new Position(out.index, Math.min(out.remainder, lineLength));
+	}
+
+	// ---- range math
+
+	private _validateRange(range: vscode.Range): vscode.Range {
+		if (!(range instanceof Range)) {
+			throw new Error('Invalid argument');
+		}
+
+		const start = this._validatePosition(range.start);
+		const end = this._validatePosition(range.end);
+
+		if (start === range.start && end === range.end) {
+			return range;
+		}
+		return new Range(start.line, start.character, end.line, end.character);
+	}
+
+	private _validatePosition(position: vscode.Position): vscode.Position {
+		if (!(position instanceof Position)) {
+			throw new Error('Invalid argument');
+		}
+
+		if (this._lines.length === 0) {
+			return position.with(0, 0);
+		}
+
+		let { line, character } = position;
+		let hasChanged = false;
+
+		if (line < 0) {
+			line = 0;
+			character = 0;
+			hasChanged = true;
+		}
+		else if (line >= this._lines.length) {
+			line = this._lines.length - 1;
+			character = this._lines[line].length;
+			hasChanged = true;
+		}
+		else {
+			const maxCharacter = this._lines[line].length;
+			if (character < 0) {
+				character = 0;
+				hasChanged = true;
+			}
+			else if (character > maxCharacter) {
+				character = maxCharacter;
+				hasChanged = true;
+			}
+		}
+
+		if (!hasChanged) {
+			return position;
+		}
+		return new Position(line, character);
+	}
+
+	private _getWordRangeAtPosition(_position: vscode.Position, regexp?: RegExp): vscode.Range | undefined {
+		const position = this._validatePosition(_position);
+
+		if (!regexp) {
+			// use default when custom-regexp isn't provided
+			regexp = getWordDefinitionFor(this._languageId);
+
+		} else if (regExpLeadsToEndlessLoop(regexp)) {
+			// use default when custom-regexp is bad
+			throw new Error(`[getWordRangeAtPosition]: ignoring custom regexp '${regexp.source}' because it matches the empty string.`);
+		}
+
+		const wordAtText = getWordAtText(
+			position.character + 1,
+			ensureValidWordDefinition(regexp),
+			this._lines[position.line],
+			0
+		);
+
+		if (wordAtText) {
+			return new Range(position.line, wordAtText.startColumn - 1, position.line, wordAtText.endColumn - 1);
+		}
+		return undefined;
+	}
+}
+
+export class ExtHostDocumentLine implements vscode.TextLine {
+
+	private readonly _line: number;
+	private readonly _text: string;
+	private readonly _isLastLine: boolean;
+
+	constructor(line: number, text: string, isLastLine: boolean) {
+		this._line = line;
+		this._text = text;
+		this._isLastLine = isLastLine;
+	}
+
+	public get lineNumber(): number {
+		return this._line;
+	}
+
+	public get text(): string {
+		return this._text;
+	}
+
+	public get range(): Range {
+		return new Range(this._line, 0, this._line, this._text.length);
+	}
+
+	public get rangeIncludingLineBreak(): Range {
+		if (this._isLastLine) {
+			return this.range;
+		}
+		return new Range(this._line, 0, this._line + 1, 0);
+	}
+
+	public get firstNonWhitespaceCharacterIndex(): number {
+		//TODO@api, rename to 'leadingWhitespaceLength'
+		return /^(\s*)/.exec(this._text)![1].length;
+	}
+
+	public get isEmptyOrWhitespace(): boolean {
+		return this.firstNonWhitespaceCharacterIndex === this._text.length;
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDocumentSaveParticipant.ts

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Event } from 'vs/base/common/event';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { illegalState } from 'vs/base/common/errors';
+import { ExtHostDocumentSaveParticipantShape, IWorkspaceEditDto, WorkspaceEditType, MainThreadBulkEditsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { TextEdit } from 'vs/workbench/api/common/extHostTypes';
+import { Range, TextDocumentSaveReason, EndOfLine } from 'vs/workbench/api/common/extHostTypeConverters';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import { SaveReason } from 'vs/workbench/common/editor';
+import type * as vscode from 'vscode';
+import { LinkedList } from 'vs/base/common/linkedList';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+
+type Listener = [Function, any, IExtensionDescription];
+
+export class ExtHostDocumentSaveParticipant implements ExtHostDocumentSaveParticipantShape {
+
+	private readonly _callbacks = new LinkedList<Listener>();
+	private readonly _badListeners = new WeakMap<Function, number>();
+
+	constructor(
+		private readonly _logService: ILogService,
+		private readonly _documents: ExtHostDocuments,
+		private readonly _mainThreadBulkEdits: MainThreadBulkEditsShape,
+		private readonly _thresholds: { timeout: number; errors: number; } = { timeout: 1500, errors: 3 }
+	) {
+		//
+	}
+
+	dispose(): void {
+		this._callbacks.clear();
+	}
+
+	getOnWillSaveTextDocumentEvent(extension: IExtensionDescription): Event<vscode.TextDocumentWillSaveEvent> {
+		return (listener, thisArg, disposables) => {
+			const remove = this._callbacks.push([listener, thisArg, extension]);
+			const result = { dispose: remove };
+			if (Array.isArray(disposables)) {
+				disposables.push(result);
+			}
+			return result;
+		};
+	}
+
+	async $participateInSave(data: UriComponents, reason: SaveReason): Promise<boolean[]> {
+		const resource = URI.revive(data);
+
+		let didTimeout = false;
+		const didTimeoutHandle = setTimeout(() => didTimeout = true, this._thresholds.timeout);
+
+		const results: boolean[] = [];
+		try {
+			for (let listener of [...this._callbacks]) { // copy to prevent concurrent modifications
+				if (didTimeout) {
+					// timeout - no more listeners
+					break;
+				}
+				const document = this._documents.getDocument(resource);
+				const success = await this._deliverEventAsyncAndBlameBadListeners(listener, <any>{ document, reason: TextDocumentSaveReason.to(reason) });
+				results.push(success);
+			}
+		} finally {
+			clearTimeout(didTimeoutHandle);
+		}
+		return results;
+	}
+
+	private _deliverEventAsyncAndBlameBadListeners([listener, thisArg, extension]: Listener, stubEvent: vscode.TextDocumentWillSaveEvent): Promise<any> {
+		const errors = this._badListeners.get(listener);
+		if (typeof errors === 'number' && errors > this._thresholds.errors) {
+			// bad listener - ignore
+			return Promise.resolve(false);
+		}
+
+		return this._deliverEventAsync(extension, listener, thisArg, stubEvent).then(() => {
+			// don't send result across the wire
+			return true;
+
+		}, err => {
+
+			this._logService.error(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' threw ERROR`);
+			this._logService.error(err);
+
+			if (!(err instanceof Error) || (<Error>err).message !== 'concurrent_edits') {
+				const errors = this._badListeners.get(listener);
+				this._badListeners.set(listener, !errors ? 1 : errors + 1);
+
+				if (typeof errors === 'number' && errors > this._thresholds.errors) {
+					this._logService.info(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' will now be IGNORED because of timeouts and/or errors`);
+				}
+			}
+			return false;
+		});
+	}
+
+	private _deliverEventAsync(extension: IExtensionDescription, listener: Function, thisArg: any, stubEvent: vscode.TextDocumentWillSaveEvent): Promise<any> {
+
+		const promises: Promise<vscode.TextEdit[]>[] = [];
+
+		const t1 = Date.now();
+		const { document, reason } = stubEvent;
+		const { version } = document;
+
+		const event = Object.freeze(<vscode.TextDocumentWillSaveEvent>{
+			document,
+			reason,
+			waitUntil(p: Promise<any | vscode.TextEdit[]>) {
+				if (Object.isFrozen(promises)) {
+					throw illegalState('waitUntil can not be called async');
+				}
+				promises.push(Promise.resolve(p));
+			}
+		});
+
+		try {
+			// fire event
+			listener.apply(thisArg, [event]);
+		} catch (err) {
+			return Promise.reject(err);
+		}
+
+		// freeze promises after event call
+		Object.freeze(promises);
+
+		return new Promise<vscode.TextEdit[][]>((resolve, reject) => {
+			// join on all listener promises, reject after timeout
+			const handle = setTimeout(() => reject(new Error('timeout')), this._thresholds.timeout);
+
+			return Promise.all(promises).then(edits => {
+				this._logService.debug(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' finished after ${(Date.now() - t1)}ms`);
+				clearTimeout(handle);
+				resolve(edits);
+			}).catch(err => {
+				clearTimeout(handle);
+				reject(err);
+			});
+
+		}).then(values => {
+			const dto: IWorkspaceEditDto = { edits: [] };
+			for (const value of values) {
+				if (Array.isArray(value) && (<vscode.TextEdit[]>value).every(e => e instanceof TextEdit)) {
+					for (const { newText, newEol, range } of value) {
+						dto.edits.push({
+							_type: WorkspaceEditType.Text,
+							resource: document.uri,
+							edit: {
+								range: range && Range.from(range),
+								text: newText,
+								eol: newEol && EndOfLine.from(newEol)
+							}
+						});
+					}
+				}
+			}
+
+			// apply edits if any and if document
+			// didn't change somehow in the meantime
+			if (dto.edits.length === 0) {
+				return undefined;
+			}
+
+			if (version === document.version) {
+				return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(dto);
+			}
+
+			return Promise.reject(new Error('concurrent_edits'));
+		});
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDocuments.ts

@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IModelChangedEvent } from 'vs/editor/common/model/mirrorTextModel';
+import { ExtHostDocumentsShape, IMainContext, MainContext, MainThreadDocumentsShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostDocumentData, setWordDefinitionFor } from 'vs/workbench/api/common/extHostDocumentData';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import * as TypeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import type * as vscode from 'vscode';
+import { assertIsDefined } from 'vs/base/common/types';
+import { deepFreeze } from 'vs/base/common/objects';
+
+export class ExtHostDocuments implements ExtHostDocumentsShape {
+
+	private readonly _onDidAddDocument = new Emitter<vscode.TextDocument>();
+	private readonly _onDidRemoveDocument = new Emitter<vscode.TextDocument>();
+	private readonly _onDidChangeDocument = new Emitter<vscode.TextDocumentChangeEvent>();
+	private readonly _onDidSaveDocument = new Emitter<vscode.TextDocument>();
+
+	readonly onDidAddDocument: Event<vscode.TextDocument> = this._onDidAddDocument.event;
+	readonly onDidRemoveDocument: Event<vscode.TextDocument> = this._onDidRemoveDocument.event;
+	readonly onDidChangeDocument: Event<vscode.TextDocumentChangeEvent> = this._onDidChangeDocument.event;
+	readonly onDidSaveDocument: Event<vscode.TextDocument> = this._onDidSaveDocument.event;
+
+	private readonly _toDispose = new DisposableStore();
+	private _proxy: MainThreadDocumentsShape;
+	private _documentsAndEditors: ExtHostDocumentsAndEditors;
+	private _documentLoader = new Map<string, Promise<ExtHostDocumentData>>();
+
+	constructor(mainContext: IMainContext, documentsAndEditors: ExtHostDocumentsAndEditors) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadDocuments);
+		this._documentsAndEditors = documentsAndEditors;
+
+		this._documentsAndEditors.onDidRemoveDocuments(documents => {
+			for (const data of documents) {
+				this._onDidRemoveDocument.fire(data.document);
+			}
+		}, undefined, this._toDispose);
+		this._documentsAndEditors.onDidAddDocuments(documents => {
+			for (const data of documents) {
+				this._onDidAddDocument.fire(data.document);
+			}
+		}, undefined, this._toDispose);
+	}
+
+	public dispose(): void {
+		this._toDispose.dispose();
+	}
+
+	public getAllDocumentData(): ExtHostDocumentData[] {
+		return [...this._documentsAndEditors.allDocuments()];
+	}
+
+	public getDocumentData(resource: vscode.Uri): ExtHostDocumentData | undefined {
+		if (!resource) {
+			return undefined;
+		}
+		const data = this._documentsAndEditors.getDocument(resource);
+		if (data) {
+			return data;
+		}
+		return undefined;
+	}
+
+	public getDocument(resource: vscode.Uri): vscode.TextDocument {
+		const data = this.getDocumentData(resource);
+		if (!data?.document) {
+			throw new Error(`Unable to retrieve document from URI '${resource}'`);
+		}
+		return data.document;
+	}
+
+	public ensureDocumentData(uri: URI): Promise<ExtHostDocumentData> {
+
+		const cached = this._documentsAndEditors.getDocument(uri);
+		if (cached) {
+			return Promise.resolve(cached);
+		}
+
+		let promise = this._documentLoader.get(uri.toString());
+		if (!promise) {
+			promise = this._proxy.$tryOpenDocument(uri).then(uriData => {
+				this._documentLoader.delete(uri.toString());
+				const canonicalUri = URI.revive(uriData);
+				return assertIsDefined(this._documentsAndEditors.getDocument(canonicalUri));
+			}, err => {
+				this._documentLoader.delete(uri.toString());
+				return Promise.reject(err);
+			});
+			this._documentLoader.set(uri.toString(), promise);
+		}
+
+		return promise;
+	}
+
+	public createDocumentData(options?: { language?: string; content?: string }): Promise<URI> {
+		return this._proxy.$tryCreateDocument(options).then(data => URI.revive(data));
+	}
+
+	public $acceptModelModeChanged(uriComponents: UriComponents, oldModeId: string, newModeId: string): void {
+		const uri = URI.revive(uriComponents);
+		const data = this._documentsAndEditors.getDocument(uri);
+		if (!data) {
+			throw new Error('unknown document');
+		}
+		// Treat a mode change as a remove + add
+
+		this._onDidRemoveDocument.fire(data.document);
+		data._acceptLanguageId(newModeId);
+		this._onDidAddDocument.fire(data.document);
+	}
+
+	public $acceptModelSaved(uriComponents: UriComponents): void {
+		const uri = URI.revive(uriComponents);
+		const data = this._documentsAndEditors.getDocument(uri);
+		if (!data) {
+			throw new Error('unknown document');
+		}
+		this.$acceptDirtyStateChanged(uriComponents, false);
+		this._onDidSaveDocument.fire(data.document);
+	}
+
+	public $acceptDirtyStateChanged(uriComponents: UriComponents, isDirty: boolean): void {
+		const uri = URI.revive(uriComponents);
+		const data = this._documentsAndEditors.getDocument(uri);
+		if (!data) {
+			throw new Error('unknown document');
+		}
+		data._acceptIsDirty(isDirty);
+		this._onDidChangeDocument.fire({
+			document: data.document,
+			contentChanges: []
+		});
+	}
+
+	public $acceptModelChanged(uriComponents: UriComponents, events: IModelChangedEvent, isDirty: boolean): void {
+		const uri = URI.revive(uriComponents);
+		const data = this._documentsAndEditors.getDocument(uri);
+		if (!data) {
+			throw new Error('unknown document');
+		}
+		data._acceptIsDirty(isDirty);
+		data.onEvents(events);
+		this._onDidChangeDocument.fire(deepFreeze({
+			document: data.document,
+			contentChanges: events.changes.map((change) => {
+				return {
+					range: TypeConverters.Range.to(change.range),
+					rangeOffset: change.rangeOffset,
+					rangeLength: change.rangeLength,
+					text: change.text
+				};
+			})
+		}));
+	}
+
+	public setWordDefinitionFor(modeId: string, wordDefinition: RegExp | undefined): void {
+		setWordDefinitionFor(modeId, wordDefinition);
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostDocumentsAndEditors.ts

@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'vs/base/common/assert';
+import * as vscode from 'vscode';
+import { Emitter, Event } from 'vs/base/common/event';
+import { dispose } from 'vs/base/common/lifecycle';
+import { URI } from 'vs/base/common/uri';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ExtHostDocumentsAndEditorsShape, IDocumentsAndEditorsDelta, IModelAddedData, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostDocumentData } from 'vs/workbench/api/common/extHostDocumentData';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { ExtHostTextEditor } from 'vs/workbench/api/common/extHostTextEditor';
+import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ResourceMap } from 'vs/base/common/map';
+import { Schemas } from 'vs/base/common/network';
+import { Iterable } from 'vs/base/common/iterator';
+
+class Reference<T> {
+	private _count = 0;
+	constructor(readonly value: T) { }
+	ref() {
+		this._count++;
+	}
+	unref() {
+		return --this._count === 0;
+	}
+}
+
+export interface IExtHostModelAddedData extends IModelAddedData {
+	notebook?: vscode.NotebookDocument;
+}
+
+export interface IExtHostDocumentsAndEditorsDelta extends IDocumentsAndEditorsDelta {
+	addedDocuments?: IExtHostModelAddedData[];
+}
+
+export class ExtHostDocumentsAndEditors implements ExtHostDocumentsAndEditorsShape {
+
+	readonly _serviceBrand: undefined;
+
+	private _activeEditorId: string | null = null;
+
+	private readonly _editors = new Map<string, ExtHostTextEditor>();
+	private readonly _documents = new ResourceMap<Reference<ExtHostDocumentData>>();
+
+	private readonly _onDidAddDocuments = new Emitter<ExtHostDocumentData[]>();
+	private readonly _onDidRemoveDocuments = new Emitter<ExtHostDocumentData[]>();
+	private readonly _onDidChangeVisibleTextEditors = new Emitter<ExtHostTextEditor[]>();
+	private readonly _onDidChangeActiveTextEditor = new Emitter<ExtHostTextEditor | undefined>();
+
+	readonly onDidAddDocuments: Event<ExtHostDocumentData[]> = this._onDidAddDocuments.event;
+	readonly onDidRemoveDocuments: Event<ExtHostDocumentData[]> = this._onDidRemoveDocuments.event;
+	readonly onDidChangeVisibleTextEditors: Event<ExtHostTextEditor[]> = this._onDidChangeVisibleTextEditors.event;
+	readonly onDidChangeActiveTextEditor: Event<ExtHostTextEditor | undefined> = this._onDidChangeActiveTextEditor.event;
+
+	constructor(
+		@IExtHostRpcService private readonly _extHostRpc: IExtHostRpcService,
+		@ILogService private readonly _logService: ILogService
+	) { }
+
+	$acceptDocumentsAndEditorsDelta(delta: IDocumentsAndEditorsDelta): void {
+		this.acceptDocumentsAndEditorsDelta(delta);
+	}
+
+	acceptDocumentsAndEditorsDelta(delta: IExtHostDocumentsAndEditorsDelta): void {
+
+		const removedDocuments: ExtHostDocumentData[] = [];
+		const addedDocuments: ExtHostDocumentData[] = [];
+		const removedEditors: ExtHostTextEditor[] = [];
+
+		if (delta.removedDocuments) {
+			for (const uriComponent of delta.removedDocuments) {
+				const uri = URI.revive(uriComponent);
+				const data = this._documents.get(uri);
+				if (data?.unref()) {
+					this._documents.delete(uri);
+					removedDocuments.push(data.value);
+				}
+			}
+		}
+
+		if (delta.addedDocuments) {
+			for (const data of delta.addedDocuments) {
+				const resource = URI.revive(data.uri);
+				let ref = this._documents.get(resource);
+
+				// double check -> only notebook cell documents should be
+				// referenced/opened more than once...
+				if (ref) {
+					if (resource.scheme !== Schemas.vscodeNotebookCell) {
+						throw new Error(`document '${resource} already exists!'`);
+					}
+				}
+				if (!ref) {
+					ref = new Reference(new ExtHostDocumentData(
+						this._extHostRpc.getProxy(MainContext.MainThreadDocuments),
+						resource,
+						data.lines,
+						data.EOL,
+						data.versionId,
+						data.modeId,
+						data.isDirty,
+						data.notebook
+					));
+					this._documents.set(resource, ref);
+					addedDocuments.push(ref.value);
+				}
+
+				ref.ref();
+			}
+		}
+
+		if (delta.removedEditors) {
+			for (const id of delta.removedEditors) {
+				const editor = this._editors.get(id);
+				this._editors.delete(id);
+				if (editor) {
+					removedEditors.push(editor);
+				}
+			}
+		}
+
+		if (delta.addedEditors) {
+			for (const data of delta.addedEditors) {
+				const resource = URI.revive(data.documentUri);
+				assert.ok(this._documents.has(resource), `document '${resource}' does not exist`);
+				assert.ok(!this._editors.has(data.id), `editor '${data.id}' already exists!`);
+
+				const documentData = this._documents.get(resource)!.value;
+				const editor = new ExtHostTextEditor(
+					data.id,
+					this._extHostRpc.getProxy(MainContext.MainThreadTextEditors),
+					this._logService,
+					documentData,
+					data.selections.map(typeConverters.Selection.to),
+					data.options,
+					data.visibleRanges.map(range => typeConverters.Range.to(range)),
+					typeof data.editorPosition === 'number' ? typeConverters.ViewColumn.to(data.editorPosition) : undefined
+				);
+				this._editors.set(data.id, editor);
+			}
+		}
+
+		if (delta.newActiveEditor !== undefined) {
+			assert.ok(delta.newActiveEditor === null || this._editors.has(delta.newActiveEditor), `active editor '${delta.newActiveEditor}' does not exist`);
+			this._activeEditorId = delta.newActiveEditor;
+		}
+
+		dispose(removedDocuments);
+		dispose(removedEditors);
+
+		// now that the internal state is complete, fire events
+		if (delta.removedDocuments) {
+			this._onDidRemoveDocuments.fire(removedDocuments);
+		}
+		if (delta.addedDocuments) {
+			this._onDidAddDocuments.fire(addedDocuments);
+		}
+
+		if (delta.removedEditors || delta.addedEditors) {
+			this._onDidChangeVisibleTextEditors.fire(this.allEditors());
+		}
+		if (delta.newActiveEditor !== undefined) {
+			this._onDidChangeActiveTextEditor.fire(this.activeEditor());
+		}
+	}
+
+	getDocument(uri: URI): ExtHostDocumentData | undefined {
+		return this._documents.get(uri)?.value;
+	}
+
+	allDocuments(): Iterable<ExtHostDocumentData> {
+		return Iterable.map(this._documents.values(), ref => ref.value);
+	}
+
+	getEditor(id: string): ExtHostTextEditor | undefined {
+		return this._editors.get(id);
+	}
+
+	activeEditor(): ExtHostTextEditor | undefined {
+		if (!this._activeEditorId) {
+			return undefined;
+		} else {
+			return this._editors.get(this._activeEditorId);
+		}
+	}
+
+	allEditors(): ExtHostTextEditor[] {
+		return [...this._editors.values()];
+	}
+}
+
+export interface IExtHostDocumentsAndEditors extends ExtHostDocumentsAndEditors { }
+export const IExtHostDocumentsAndEditors = createDecorator<IExtHostDocumentsAndEditors>('IExtHostDocumentsAndEditors');

lib/vscode/src/vs/workbench/api/common/extHostExtensionActivator.ts

@@ -0,0 +1,388 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import type * as vscode from 'vscode';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { ExtensionActivationError, MissingDependencyError } from 'vs/workbench/services/extensions/common/extensions';
+import { ILogService } from 'vs/platform/log/common/log';
+
+const NO_OP_VOID_PROMISE = Promise.resolve<void>(undefined);
+
+/**
+ * Represents the source code (module) of an extension.
+ */
+export interface IExtensionModule {
+	activate?(ctx: vscode.ExtensionContext): Promise<IExtensionAPI>;
+	deactivate?(): void;
+}
+
+/**
+ * Represents the API of an extension (return value of `activate`).
+ */
+export interface IExtensionAPI {
+	// _extensionAPIBrand: any;
+}
+
+export type ExtensionActivationTimesFragment = {
+	startup?: { classification: 'SystemMetaData', purpose: 'PerformanceAndHealth', isMeasurement: true };
+	codeLoadingTime?: { classification: 'SystemMetaData', purpose: 'PerformanceAndHealth', isMeasurement: true };
+	activateCallTime?: { classification: 'SystemMetaData', purpose: 'PerformanceAndHealth', isMeasurement: true };
+	activateResolvedTime?: { classification: 'SystemMetaData', purpose: 'PerformanceAndHealth', isMeasurement: true };
+};
+
+export class ExtensionActivationTimes {
+
+	public static readonly NONE = new ExtensionActivationTimes(false, -1, -1, -1);
+
+	public readonly startup: boolean;
+	public readonly codeLoadingTime: number;
+	public readonly activateCallTime: number;
+	public readonly activateResolvedTime: number;
+
+	constructor(startup: boolean, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number) {
+		this.startup = startup;
+		this.codeLoadingTime = codeLoadingTime;
+		this.activateCallTime = activateCallTime;
+		this.activateResolvedTime = activateResolvedTime;
+	}
+}
+
+export class ExtensionActivationTimesBuilder {
+
+	private readonly _startup: boolean;
+	private _codeLoadingStart: number;
+	private _codeLoadingStop: number;
+	private _activateCallStart: number;
+	private _activateCallStop: number;
+	private _activateResolveStart: number;
+	private _activateResolveStop: number;
+
+	constructor(startup: boolean) {
+		this._startup = startup;
+		this._codeLoadingStart = -1;
+		this._codeLoadingStop = -1;
+		this._activateCallStart = -1;
+		this._activateCallStop = -1;
+		this._activateResolveStart = -1;
+		this._activateResolveStop = -1;
+	}
+
+	private _delta(start: number, stop: number): number {
+		if (start === -1 || stop === -1) {
+			return -1;
+		}
+		return stop - start;
+	}
+
+	public build(): ExtensionActivationTimes {
+		return new ExtensionActivationTimes(
+			this._startup,
+			this._delta(this._codeLoadingStart, this._codeLoadingStop),
+			this._delta(this._activateCallStart, this._activateCallStop),
+			this._delta(this._activateResolveStart, this._activateResolveStop)
+		);
+	}
+
+	public codeLoadingStart(): void {
+		this._codeLoadingStart = Date.now();
+	}
+
+	public codeLoadingStop(): void {
+		this._codeLoadingStop = Date.now();
+	}
+
+	public activateCallStart(): void {
+		this._activateCallStart = Date.now();
+	}
+
+	public activateCallStop(): void {
+		this._activateCallStop = Date.now();
+	}
+
+	public activateResolveStart(): void {
+		this._activateResolveStart = Date.now();
+	}
+
+	public activateResolveStop(): void {
+		this._activateResolveStop = Date.now();
+	}
+}
+
+export class ActivatedExtension {
+
+	public readonly activationFailed: boolean;
+	public readonly activationFailedError: Error | null;
+	public readonly activationTimes: ExtensionActivationTimes;
+	public readonly module: IExtensionModule;
+	public readonly exports: IExtensionAPI | undefined;
+	public readonly subscriptions: IDisposable[];
+
+	constructor(
+		activationFailed: boolean,
+		activationFailedError: Error | null,
+		activationTimes: ExtensionActivationTimes,
+		module: IExtensionModule,
+		exports: IExtensionAPI | undefined,
+		subscriptions: IDisposable[]
+	) {
+		this.activationFailed = activationFailed;
+		this.activationFailedError = activationFailedError;
+		this.activationTimes = activationTimes;
+		this.module = module;
+		this.exports = exports;
+		this.subscriptions = subscriptions;
+	}
+}
+
+export class EmptyExtension extends ActivatedExtension {
+	constructor(activationTimes: ExtensionActivationTimes) {
+		super(false, null, activationTimes, { activate: undefined, deactivate: undefined }, undefined, []);
+	}
+}
+
+export class HostExtension extends ActivatedExtension {
+	constructor() {
+		super(false, null, ExtensionActivationTimes.NONE, { activate: undefined, deactivate: undefined }, undefined, []);
+	}
+}
+
+export class FailedExtension extends ActivatedExtension {
+	constructor(activationError: Error) {
+		super(true, activationError, ExtensionActivationTimes.NONE, { activate: undefined, deactivate: undefined }, undefined, []);
+	}
+}
+
+export interface IExtensionsActivatorHost {
+	onExtensionActivationError(extensionId: ExtensionIdentifier, error: ExtensionActivationError): void;
+	actualActivateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<ActivatedExtension>;
+}
+
+export interface ExtensionActivationReason {
+	readonly startup: boolean;
+	readonly extensionId: ExtensionIdentifier;
+	readonly activationEvent: string;
+}
+
+type ActivationIdAndReason = { id: ExtensionIdentifier, reason: ExtensionActivationReason };
+
+export class ExtensionsActivator {
+
+	private readonly _registry: ExtensionDescriptionRegistry;
+	private readonly _resolvedExtensionsSet: Set<string>;
+	private readonly _hostExtensionsMap: Map<string, ExtensionIdentifier>;
+	private readonly _host: IExtensionsActivatorHost;
+	private readonly _activatingExtensions: Map<string, Promise<void>>;
+	private readonly _activatedExtensions: Map<string, ActivatedExtension>;
+	/**
+	 * A map of already activated events to speed things up if the same activation event is triggered multiple times.
+	 */
+	private readonly _alreadyActivatedEvents: { [activationEvent: string]: boolean; };
+
+	constructor(
+		registry: ExtensionDescriptionRegistry,
+		resolvedExtensions: ExtensionIdentifier[],
+		hostExtensions: ExtensionIdentifier[],
+		host: IExtensionsActivatorHost,
+		@ILogService private readonly _logService: ILogService
+	) {
+		this._registry = registry;
+		this._resolvedExtensionsSet = new Set<string>();
+		resolvedExtensions.forEach((extensionId) => this._resolvedExtensionsSet.add(ExtensionIdentifier.toKey(extensionId)));
+		this._hostExtensionsMap = new Map<string, ExtensionIdentifier>();
+		hostExtensions.forEach((extensionId) => this._hostExtensionsMap.set(ExtensionIdentifier.toKey(extensionId), extensionId));
+		this._host = host;
+		this._activatingExtensions = new Map<string, Promise<void>>();
+		this._activatedExtensions = new Map<string, ActivatedExtension>();
+		this._alreadyActivatedEvents = Object.create(null);
+	}
+
+	public isActivated(extensionId: ExtensionIdentifier): boolean {
+		const extensionKey = ExtensionIdentifier.toKey(extensionId);
+
+		return this._activatedExtensions.has(extensionKey);
+	}
+
+	public getActivatedExtension(extensionId: ExtensionIdentifier): ActivatedExtension {
+		const extensionKey = ExtensionIdentifier.toKey(extensionId);
+
+		const activatedExtension = this._activatedExtensions.get(extensionKey);
+		if (!activatedExtension) {
+			throw new Error('Extension `' + extensionId.value + '` is not known or not activated');
+		}
+		return activatedExtension;
+	}
+
+	public activateByEvent(activationEvent: string, startup: boolean): Promise<void> {
+		if (this._alreadyActivatedEvents[activationEvent]) {
+			return NO_OP_VOID_PROMISE;
+		}
+		const activateExtensions = this._registry.getExtensionDescriptionsForActivationEvent(activationEvent);
+		return this._activateExtensions(activateExtensions.map(e => ({
+			id: e.identifier,
+			reason: { startup, extensionId: e.identifier, activationEvent }
+		}))).then(() => {
+			this._alreadyActivatedEvents[activationEvent] = true;
+		});
+	}
+
+	public activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
+		const desc = this._registry.getExtensionDescription(extensionId);
+		if (!desc) {
+			throw new Error('Extension `' + extensionId + '` is not known');
+		}
+
+		return this._activateExtensions([{
+			id: desc.identifier,
+			reason
+		}]);
+	}
+
+	/**
+	 * Handle semantics related to dependencies for `currentExtension`.
+	 * semantics: `redExtensions` must wait for `greenExtensions`.
+	 */
+	private _handleActivateRequest(currentActivation: ActivationIdAndReason, greenExtensions: { [id: string]: ActivationIdAndReason; }, redExtensions: ActivationIdAndReason[]): void {
+		if (this._hostExtensionsMap.has(ExtensionIdentifier.toKey(currentActivation.id))) {
+			greenExtensions[ExtensionIdentifier.toKey(currentActivation.id)] = currentActivation;
+			return;
+		}
+
+		const currentExtension = this._registry.getExtensionDescription(currentActivation.id);
+		if (!currentExtension) {
+			// Error condition 0: unknown extension
+			this._host.onExtensionActivationError(currentActivation.id, new MissingDependencyError(currentActivation.id.value));
+			const error = new Error(`Unknown dependency '${currentActivation.id.value}'`);
+			this._activatedExtensions.set(ExtensionIdentifier.toKey(currentActivation.id), new FailedExtension(error));
+			return;
+		}
+
+		const depIds = (typeof currentExtension.extensionDependencies === 'undefined' ? [] : currentExtension.extensionDependencies);
+		let currentExtensionGetsGreenLight = true;
+
+		for (let j = 0, lenJ = depIds.length; j < lenJ; j++) {
+			const depId = depIds[j];
+
+			if (this._resolvedExtensionsSet.has(ExtensionIdentifier.toKey(depId))) {
+				// This dependency is already resolved
+				continue;
+			}
+
+			const dep = this._activatedExtensions.get(ExtensionIdentifier.toKey(depId));
+			if (dep && !dep.activationFailed) {
+				// the dependency is already activated OK
+				continue;
+			}
+
+			if (dep && dep.activationFailed) {
+				// Error condition 2: a dependency has already failed activation
+				this._host.onExtensionActivationError(currentExtension.identifier, nls.localize('failedDep1', "Cannot activate extension '{0}' because it depends on extension '{1}', which failed to activate.", currentExtension.displayName || currentExtension.identifier.value, depId));
+				const error = new Error(`Dependency ${depId} failed to activate`);
+				(<any>error).detail = dep.activationFailedError;
+				this._activatedExtensions.set(ExtensionIdentifier.toKey(currentExtension.identifier), new FailedExtension(error));
+				return;
+			}
+
+			if (this._hostExtensionsMap.has(ExtensionIdentifier.toKey(depId))) {
+				// must first wait for the dependency to activate
+				currentExtensionGetsGreenLight = false;
+				greenExtensions[ExtensionIdentifier.toKey(depId)] = {
+					id: this._hostExtensionsMap.get(ExtensionIdentifier.toKey(depId))!,
+					reason: currentActivation.reason
+				};
+				continue;
+			}
+
+			const depDesc = this._registry.getExtensionDescription(depId);
+			if (depDesc) {
+				// must first wait for the dependency to activate
+				currentExtensionGetsGreenLight = false;
+				greenExtensions[ExtensionIdentifier.toKey(depId)] = {
+					id: depDesc.identifier,
+					reason: currentActivation.reason
+				};
+				continue;
+			}
+
+			// Error condition 1: unknown dependency
+			this._host.onExtensionActivationError(currentExtension.identifier, new MissingDependencyError(depId));
+			const error = new Error(`Unknown dependency '${depId}'`);
+			this._activatedExtensions.set(ExtensionIdentifier.toKey(currentExtension.identifier), new FailedExtension(error));
+			return;
+		}
+
+		if (currentExtensionGetsGreenLight) {
+			greenExtensions[ExtensionIdentifier.toKey(currentExtension.identifier)] = currentActivation;
+		} else {
+			redExtensions.push(currentActivation);
+		}
+	}
+
+	private _activateExtensions(extensions: ActivationIdAndReason[]): Promise<void> {
+		if (extensions.length === 0) {
+			return Promise.resolve(undefined);
+		}
+
+		extensions = extensions.filter((p) => !this._activatedExtensions.has(ExtensionIdentifier.toKey(p.id)));
+		if (extensions.length === 0) {
+			return Promise.resolve(undefined);
+		}
+
+		const greenMap: { [id: string]: ActivationIdAndReason; } = Object.create(null),
+			red: ActivationIdAndReason[] = [];
+
+		for (let i = 0, len = extensions.length; i < len; i++) {
+			this._handleActivateRequest(extensions[i], greenMap, red);
+		}
+
+		// Make sure no red is also green
+		for (let i = 0, len = red.length; i < len; i++) {
+			const redExtensionKey = ExtensionIdentifier.toKey(red[i].id);
+			if (greenMap[redExtensionKey]) {
+				delete greenMap[redExtensionKey];
+			}
+		}
+
+		const green = Object.keys(greenMap).map(id => greenMap[id]);
+
+		if (red.length === 0) {
+			// Finally reached only leafs!
+			return Promise.all(green.map((p) => this._activateExtension(p.id, p.reason))).then(_ => undefined);
+		}
+
+		return this._activateExtensions(green).then(_ => {
+			return this._activateExtensions(red);
+		});
+	}
+
+	private _activateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
+		const extensionKey = ExtensionIdentifier.toKey(extensionId);
+
+		if (this._activatedExtensions.has(extensionKey)) {
+			return Promise.resolve(undefined);
+		}
+
+		const currentlyActivatingExtension = this._activatingExtensions.get(extensionKey);
+		if (currentlyActivatingExtension) {
+			return currentlyActivatingExtension;
+		}
+
+		const newlyActivatingExtension = this._host.actualActivateExtension(extensionId, reason).then(undefined, (err) => {
+			this._host.onExtensionActivationError(extensionId, nls.localize('activationError', "Activating extension '{0}' failed: {1}.", extensionId.value, err.message));
+			this._logService.error(`Activating extension ${extensionId.value} failed due to an error:`);
+			this._logService.error(err);
+			// Treat the extension as being empty
+			return new FailedExtension(err);
+		}).then((x: ActivatedExtension) => {
+			this._activatedExtensions.set(extensionKey, x);
+			this._activatingExtensions.delete(extensionKey);
+		});
+
+		this._activatingExtensions.set(extensionKey, newlyActivatingExtension);
+		return newlyActivatingExtension;
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostExtensionService.ts

@@ -0,0 +1,804 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import * as path from 'vs/base/common/path';
+import { originalFSPath, joinPath } from 'vs/base/common/resources';
+import { Barrier, timeout } from 'vs/base/common/async';
+import { dispose, toDisposable, DisposableStore, Disposable } from 'vs/base/common/lifecycle';
+import { TernarySearchTree } from 'vs/base/common/map';
+import { URI } from 'vs/base/common/uri';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtHostExtensionServiceShape, IInitData, MainContext, MainThreadExtensionServiceShape, MainThreadTelemetryShape, MainThreadWorkspaceShape, IResolveAuthorityResult } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostConfiguration, IExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
+import { ActivatedExtension, EmptyExtension, ExtensionActivationReason, ExtensionActivationTimes, ExtensionActivationTimesBuilder, ExtensionsActivator, IExtensionAPI, IExtensionModule, HostExtension, ExtensionActivationTimesFragment } from 'vs/workbench/api/common/extHostExtensionActivator';
+import { ExtHostStorage, IExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { ExtHostWorkspace, IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
+import { ExtensionActivationError, checkProposedApiEnabled, ActivationKind } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+import * as errors from 'vs/base/common/errors';
+import type * as vscode from 'vscode';
+import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { Schemas } from 'vs/base/common/network';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { ExtensionGlobalMemento, ExtensionMemento } from 'vs/workbench/api/common/extHostMemento';
+import { RemoteAuthorityResolverError, ExtensionMode, ExtensionRuntime } from 'vs/workbench/api/common/extHostTypes';
+import { ResolvedAuthority, ResolvedOptions, RemoteAuthorityResolverErrorCode, IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { IInstantiationService, createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
+import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePaths';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { IExtHostTunnelService } from 'vs/workbench/api/common/extHostTunnelService';
+import { IExtHostTerminalService } from 'vs/workbench/api/common/extHostTerminalService';
+import { Emitter, Event } from 'vs/base/common/event';
+import { IExtensionActivationHost, checkActivateWorkspaceContainsExtension } from 'vs/workbench/api/common/shared/workspaceContains';
+
+interface ITestRunner {
+	/** Old test runner API, as exported from `vscode/lib/testrunner` */
+	run(testsRoot: string, clb: (error: Error, failures?: number) => void): void;
+}
+
+interface INewTestRunner {
+	/** New test runner API, as explained in the extension test doc */
+	run(): Promise<void>;
+}
+
+export const IHostUtils = createDecorator<IHostUtils>('IHostUtils');
+
+export interface IHostUtils {
+	readonly _serviceBrand: undefined;
+	exit(code?: number): void;
+	exists(path: string): Promise<boolean>;
+	realpath(path: string): Promise<string>;
+}
+
+type TelemetryActivationEventFragment = {
+	id: { classification: 'PublicNonPersonalData', purpose: 'FeatureInsight' };
+	name: { classification: 'PublicNonPersonalData', purpose: 'FeatureInsight' };
+	extensionVersion: { classification: 'PublicNonPersonalData', purpose: 'FeatureInsight' };
+	publisherDisplayName: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+	activationEvents: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+	isBuiltin: { classification: 'SystemMetaData', purpose: 'FeatureInsight', isMeasurement: true };
+	reason: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+	reasonId: { classification: 'PublicNonPersonalData', purpose: 'FeatureInsight' };
+};
+
+export abstract class AbstractExtHostExtensionService extends Disposable implements ExtHostExtensionServiceShape {
+
+	readonly _serviceBrand: undefined;
+
+	abstract readonly extensionRuntime: ExtensionRuntime;
+
+	private readonly _onDidChangeRemoteConnectionData = this._register(new Emitter<void>());
+	public readonly onDidChangeRemoteConnectionData = this._onDidChangeRemoteConnectionData.event;
+
+	protected readonly _hostUtils: IHostUtils;
+	protected readonly _initData: IInitData;
+	protected readonly _extHostContext: IExtHostRpcService;
+	protected readonly _instaService: IInstantiationService;
+	protected readonly _extHostWorkspace: ExtHostWorkspace;
+	protected readonly _extHostConfiguration: ExtHostConfiguration;
+	protected readonly _logService: ILogService;
+	protected readonly _extHostTunnelService: IExtHostTunnelService;
+	protected readonly _extHostTerminalService: IExtHostTerminalService;
+
+	protected readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
+	protected readonly _mainThreadTelemetryProxy: MainThreadTelemetryShape;
+	protected readonly _mainThreadExtensionsProxy: MainThreadExtensionServiceShape;
+
+	private readonly _almostReadyToRunExtensions: Barrier;
+	private readonly _readyToStartExtensionHost: Barrier;
+	private readonly _readyToRunExtensions: Barrier;
+	protected readonly _registry: ExtensionDescriptionRegistry;
+	private readonly _storage: ExtHostStorage;
+	private readonly _storagePath: IExtensionStoragePaths;
+	private readonly _activator: ExtensionsActivator;
+	private _extensionPathIndex: Promise<TernarySearchTree<string, IExtensionDescription>> | null;
+
+	private readonly _resolvers: { [authorityPrefix: string]: vscode.RemoteAuthorityResolver; };
+
+	private _started: boolean;
+	private _remoteConnectionData: IRemoteConnectionData | null;
+
+	private readonly _disposables: DisposableStore;
+
+	constructor(
+		@IInstantiationService instaService: IInstantiationService,
+		@IHostUtils hostUtils: IHostUtils,
+		@IExtHostRpcService extHostContext: IExtHostRpcService,
+		@IExtHostWorkspace extHostWorkspace: IExtHostWorkspace,
+		@IExtHostConfiguration extHostConfiguration: IExtHostConfiguration,
+		@ILogService logService: ILogService,
+		@IExtHostInitDataService initData: IExtHostInitDataService,
+		@IExtensionStoragePaths storagePath: IExtensionStoragePaths,
+		@IExtHostTunnelService extHostTunnelService: IExtHostTunnelService,
+		@IExtHostTerminalService extHostTerminalService: IExtHostTerminalService
+	) {
+		super();
+		this._hostUtils = hostUtils;
+		this._extHostContext = extHostContext;
+		this._initData = initData;
+
+		this._extHostWorkspace = extHostWorkspace;
+		this._extHostConfiguration = extHostConfiguration;
+		this._logService = logService;
+		this._extHostTunnelService = extHostTunnelService;
+		this._extHostTerminalService = extHostTerminalService;
+		this._disposables = new DisposableStore();
+
+		this._mainThreadWorkspaceProxy = this._extHostContext.getProxy(MainContext.MainThreadWorkspace);
+		this._mainThreadTelemetryProxy = this._extHostContext.getProxy(MainContext.MainThreadTelemetry);
+		this._mainThreadExtensionsProxy = this._extHostContext.getProxy(MainContext.MainThreadExtensionService);
+
+		this._almostReadyToRunExtensions = new Barrier();
+		this._readyToStartExtensionHost = new Barrier();
+		this._readyToRunExtensions = new Barrier();
+		this._registry = new ExtensionDescriptionRegistry(this._initData.extensions);
+		this._storage = new ExtHostStorage(this._extHostContext);
+		this._storagePath = storagePath;
+
+		this._instaService = instaService.createChild(new ServiceCollection(
+			[IExtHostStorage, this._storage]
+		));
+
+		const hostExtensions = new Set<string>();
+		this._initData.hostExtensions.forEach((extensionId) => hostExtensions.add(ExtensionIdentifier.toKey(extensionId)));
+
+		this._activator = new ExtensionsActivator(
+			this._registry,
+			this._initData.resolvedExtensions,
+			this._initData.hostExtensions,
+			{
+				onExtensionActivationError: (extensionId: ExtensionIdentifier, error: ExtensionActivationError): void => {
+					this._mainThreadExtensionsProxy.$onExtensionActivationError(extensionId, error);
+				},
+
+				actualActivateExtension: async (extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<ActivatedExtension> => {
+					if (hostExtensions.has(ExtensionIdentifier.toKey(extensionId))) {
+						await this._mainThreadExtensionsProxy.$activateExtension(extensionId, reason);
+						return new HostExtension();
+					}
+					const extensionDescription = this._registry.getExtensionDescription(extensionId)!;
+					return this._activateExtension(extensionDescription, reason);
+				}
+			},
+			this._logService
+		);
+		this._extensionPathIndex = null;
+		this._resolvers = Object.create(null);
+		this._started = false;
+		this._remoteConnectionData = this._initData.remote.connectionData;
+	}
+
+	public getRemoteConnectionData(): IRemoteConnectionData | null {
+		return this._remoteConnectionData;
+	}
+
+	public async initialize(): Promise<void> {
+		try {
+
+			await this._beforeAlmostReadyToRunExtensions();
+			this._almostReadyToRunExtensions.open();
+
+			await this._extHostWorkspace.waitForInitializeCall();
+			this._readyToStartExtensionHost.open();
+
+			if (this._initData.autoStart) {
+				this._startExtensionHost();
+			}
+		} catch (err) {
+			errors.onUnexpectedError(err);
+		}
+	}
+
+	public async deactivateAll(): Promise<void> {
+		let allPromises: Promise<void>[] = [];
+		try {
+			const allExtensions = this._registry.getAllExtensionDescriptions();
+			const allExtensionsIds = allExtensions.map(ext => ext.identifier);
+			const activatedExtensions = allExtensionsIds.filter(id => this.isActivated(id));
+
+			allPromises = activatedExtensions.map((extensionId) => {
+				return this._deactivate(extensionId);
+			});
+		} catch (err) {
+			// TODO: write to log once we have one
+		}
+		await Promise.all(allPromises);
+	}
+
+	public isActivated(extensionId: ExtensionIdentifier): boolean {
+		if (this._readyToRunExtensions.isOpen()) {
+			return this._activator.isActivated(extensionId);
+		}
+		return false;
+	}
+
+	private _activateByEvent(activationEvent: string, startup: boolean): Promise<void> {
+		return this._activator.activateByEvent(activationEvent, startup);
+	}
+
+	private _activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
+		return this._activator.activateById(extensionId, reason);
+	}
+
+	public activateByIdWithErrors(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void> {
+		return this._activateById(extensionId, reason).then(() => {
+			const extension = this._activator.getActivatedExtension(extensionId);
+			if (extension.activationFailed) {
+				// activation failed => bubble up the error as the promise result
+				return Promise.reject(extension.activationFailedError);
+			}
+			return undefined;
+		});
+	}
+
+	public getExtensionRegistry(): Promise<ExtensionDescriptionRegistry> {
+		return this._readyToRunExtensions.wait().then(_ => this._registry);
+	}
+
+	public getExtensionExports(extensionId: ExtensionIdentifier): IExtensionAPI | null | undefined {
+		if (this._readyToRunExtensions.isOpen()) {
+			return this._activator.getActivatedExtension(extensionId).exports;
+		} else {
+			return null;
+		}
+	}
+
+	// create trie to enable fast 'filename -> extension id' look up
+	public getExtensionPathIndex(): Promise<TernarySearchTree<string, IExtensionDescription>> {
+		if (!this._extensionPathIndex) {
+			const tree = TernarySearchTree.forPaths<IExtensionDescription>();
+			const extensions = this._registry.getAllExtensionDescriptions().map(ext => {
+				if (!this._getEntryPoint(ext)) {
+					return undefined;
+				}
+				return this._hostUtils.realpath(ext.extensionLocation.fsPath).then(value => tree.set(URI.file(value).fsPath, ext));
+			});
+			this._extensionPathIndex = Promise.all(extensions).then(() => tree);
+		}
+		return this._extensionPathIndex;
+	}
+
+	private _deactivate(extensionId: ExtensionIdentifier): Promise<void> {
+		let result = Promise.resolve(undefined);
+
+		if (!this._readyToRunExtensions.isOpen()) {
+			return result;
+		}
+
+		if (!this._activator.isActivated(extensionId)) {
+			return result;
+		}
+
+		const extension = this._activator.getActivatedExtension(extensionId);
+		if (!extension) {
+			return result;
+		}
+
+		// call deactivate if available
+		try {
+			if (typeof extension.module.deactivate === 'function') {
+				result = Promise.resolve(extension.module.deactivate()).then(undefined, (err) => {
+					// TODO: Do something with err if this is not the shutdown case
+					return Promise.resolve(undefined);
+				});
+			}
+		} catch (err) {
+			// TODO: Do something with err if this is not the shutdown case
+		}
+
+		// clean up subscriptions
+		try {
+			dispose(extension.subscriptions);
+		} catch (err) {
+			// TODO: Do something with err if this is not the shutdown case
+		}
+
+		return result;
+	}
+
+	// --- impl
+
+	private async _activateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension> {
+		if (!this._initData.remote.isRemote) {
+			// local extension host process
+			await this._mainThreadExtensionsProxy.$onWillActivateExtension(extensionDescription.identifier);
+		} else {
+			// remote extension host process
+			// do not wait for renderer confirmation
+			this._mainThreadExtensionsProxy.$onWillActivateExtension(extensionDescription.identifier);
+		}
+		return this._doActivateExtension(extensionDescription, reason).then((activatedExtension) => {
+			const activationTimes = activatedExtension.activationTimes;
+			this._mainThreadExtensionsProxy.$onDidActivateExtension(extensionDescription.identifier, activationTimes.codeLoadingTime, activationTimes.activateCallTime, activationTimes.activateResolvedTime, reason);
+			this._logExtensionActivationTimes(extensionDescription, reason, 'success', activationTimes);
+			return activatedExtension;
+		}, (err) => {
+			this._logExtensionActivationTimes(extensionDescription, reason, 'failure');
+			throw err;
+		});
+	}
+
+	private _logExtensionActivationTimes(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason, outcome: string, activationTimes?: ExtensionActivationTimes) {
+		const event = getTelemetryActivationEvent(extensionDescription, reason);
+		type ExtensionActivationTimesClassification = {
+			outcome: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+		} & TelemetryActivationEventFragment & ExtensionActivationTimesFragment;
+
+		type ExtensionActivationTimesEvent = {
+			outcome: string
+		} & ActivationTimesEvent & TelemetryActivationEvent;
+
+		type ActivationTimesEvent = {
+			startup?: boolean;
+			codeLoadingTime?: number;
+			activateCallTime?: number;
+			activateResolvedTime?: number;
+		};
+
+		this._mainThreadTelemetryProxy.$publicLog2<ExtensionActivationTimesEvent, ExtensionActivationTimesClassification>('extensionActivationTimes', {
+			...event,
+			...(activationTimes || {}),
+			outcome
+		});
+	}
+
+	private _doActivateExtension(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): Promise<ActivatedExtension> {
+		const event = getTelemetryActivationEvent(extensionDescription, reason);
+		type ActivatePluginClassification = {} & TelemetryActivationEventFragment;
+		this._mainThreadTelemetryProxy.$publicLog2<TelemetryActivationEvent, ActivatePluginClassification>('activatePlugin', event);
+		const entryPoint = this._getEntryPoint(extensionDescription);
+		if (!entryPoint) {
+			// Treat the extension as being empty => NOT AN ERROR CASE
+			return Promise.resolve(new EmptyExtension(ExtensionActivationTimes.NONE));
+		}
+
+		this._logService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value} ${JSON.stringify(reason)}`);
+		this._logService.flush();
+
+		const activationTimesBuilder = new ExtensionActivationTimesBuilder(reason.startup);
+		return Promise.all([
+			this._loadCommonJSModule<IExtensionModule>(joinPath(extensionDescription.extensionLocation, entryPoint), activationTimesBuilder),
+			this._loadExtensionContext(extensionDescription)
+		]).then(values => {
+			return AbstractExtHostExtensionService._callActivate(this._logService, extensionDescription.identifier, values[0], values[1], activationTimesBuilder);
+		});
+	}
+
+	private _loadExtensionContext(extensionDescription: IExtensionDescription): Promise<vscode.ExtensionContext> {
+
+		const globalState = new ExtensionGlobalMemento(extensionDescription, this._storage);
+		const workspaceState = new ExtensionMemento(extensionDescription.identifier.value, false, this._storage);
+		const extensionMode = extensionDescription.isUnderDevelopment
+			? (this._initData.environment.extensionTestsLocationURI ? ExtensionMode.Test : ExtensionMode.Development)
+			: ExtensionMode.Production;
+
+		this._logService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
+
+		return Promise.all([
+			globalState.whenReady,
+			workspaceState.whenReady,
+			this._storagePath.whenReady
+		]).then(() => {
+			const that = this;
+			return Object.freeze<vscode.ExtensionContext>({
+				globalState,
+				workspaceState,
+				subscriptions: [],
+				get extensionUri() { return extensionDescription.extensionLocation; },
+				get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
+				asAbsolutePath(relativePath: string) { return path.join(extensionDescription.extensionLocation.fsPath, relativePath); },
+				get storagePath() { return that._storagePath.workspaceValue(extensionDescription)?.fsPath; },
+				get globalStoragePath() { return that._storagePath.globalValue(extensionDescription).fsPath; },
+				get logPath() { return path.join(that._initData.logsLocation.fsPath, extensionDescription.identifier.value); },
+				get logUri() { return URI.joinPath(that._initData.logsLocation, extensionDescription.identifier.value); },
+				get storageUri() { return that._storagePath.workspaceValue(extensionDescription); },
+				get globalStorageUri() { return that._storagePath.globalValue(extensionDescription); },
+				get extensionMode() { return extensionMode; },
+				get extensionRuntime() {
+					checkProposedApiEnabled(extensionDescription);
+					return that.extensionRuntime;
+				},
+				get environmentVariableCollection() { return that._extHostTerminalService.getEnvironmentVariableCollection(extensionDescription); }
+			});
+		});
+	}
+
+	private static _callActivate(logService: ILogService, extensionId: ExtensionIdentifier, extensionModule: IExtensionModule, context: vscode.ExtensionContext, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<ActivatedExtension> {
+		// Make sure the extension's surface is not undefined
+		extensionModule = extensionModule || {
+			activate: undefined,
+			deactivate: undefined
+		};
+
+		return this._callActivateOptional(logService, extensionId, extensionModule, context, activationTimesBuilder).then((extensionExports) => {
+			return new ActivatedExtension(false, null, activationTimesBuilder.build(), extensionModule, extensionExports, context.subscriptions);
+		});
+	}
+
+	private static _callActivateOptional(logService: ILogService, extensionId: ExtensionIdentifier, extensionModule: IExtensionModule, context: vscode.ExtensionContext, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<IExtensionAPI> {
+		if (typeof extensionModule.activate === 'function') {
+			try {
+				activationTimesBuilder.activateCallStart();
+				logService.trace(`ExtensionService#_callActivateOptional ${extensionId.value}`);
+				const scope = typeof global === 'object' ? global : self; // `global` is nodejs while `self` is for workers
+				const activateResult: Promise<IExtensionAPI> = extensionModule.activate.apply(scope, [context]);
+				activationTimesBuilder.activateCallStop();
+
+				activationTimesBuilder.activateResolveStart();
+				return Promise.resolve(activateResult).then((value) => {
+					activationTimesBuilder.activateResolveStop();
+					return value;
+				});
+			} catch (err) {
+				return Promise.reject(err);
+			}
+		} else {
+			// No activate found => the module is the extension's exports
+			return Promise.resolve<IExtensionAPI>(extensionModule);
+		}
+	}
+
+	// -- eager activation
+
+	private _activateOneStartupFinished(desc: IExtensionDescription, activationEvent: string): void {
+		this._activateById(desc.identifier, {
+			startup: false,
+			extensionId: desc.identifier,
+			activationEvent: activationEvent
+		}).then(undefined, (err) => {
+			this._logService.error(err);
+		});
+	}
+
+	private _activateAllStartupFinished(): void {
+		for (const desc of this._registry.getAllExtensionDescriptions()) {
+			if (desc.activationEvents) {
+				for (const activationEvent of desc.activationEvents) {
+					if (activationEvent === 'onStartupFinished') {
+						this._activateOneStartupFinished(desc, activationEvent);
+					}
+				}
+			}
+		}
+	}
+
+	// Handle "eager" activation extensions
+	private _handleEagerExtensions(): Promise<void> {
+		const starActivation = this._activateByEvent('*', true).then(undefined, (err) => {
+			this._logService.error(err);
+		});
+
+		this._disposables.add(this._extHostWorkspace.onDidChangeWorkspace((e) => this._handleWorkspaceContainsEagerExtensions(e.added)));
+		const folders = this._extHostWorkspace.workspace ? this._extHostWorkspace.workspace.folders : [];
+		const workspaceContainsActivation = this._handleWorkspaceContainsEagerExtensions(folders);
+		const eagerExtensionsActivation = Promise.all([starActivation, workspaceContainsActivation]).then(() => { });
+
+		Promise.race([eagerExtensionsActivation, timeout(10000)]).then(() => {
+			this._activateAllStartupFinished();
+		});
+
+		return eagerExtensionsActivation;
+	}
+
+	private _handleWorkspaceContainsEagerExtensions(folders: ReadonlyArray<vscode.WorkspaceFolder>): Promise<void> {
+		if (folders.length === 0) {
+			return Promise.resolve(undefined);
+		}
+
+		return Promise.all(
+			this._registry.getAllExtensionDescriptions().map((desc) => {
+				return this._handleWorkspaceContainsEagerExtension(folders, desc);
+			})
+		).then(() => { });
+	}
+
+	private async _handleWorkspaceContainsEagerExtension(folders: ReadonlyArray<vscode.WorkspaceFolder>, desc: IExtensionDescription): Promise<void> {
+		if (this.isActivated(desc.identifier)) {
+			return;
+		}
+
+		const localWithRemote = !this._initData.remote.isRemote && !!this._initData.remote.authority;
+		const host: IExtensionActivationHost = {
+			folders: folders.map(folder => folder.uri),
+			forceUsingSearch: localWithRemote,
+			exists: (uri) => this._hostUtils.exists(uri.fsPath),
+			checkExists: (folders, includes, token) => this._mainThreadWorkspaceProxy.$checkExists(folders, includes, token)
+		};
+
+		const result = await checkActivateWorkspaceContainsExtension(host, desc);
+		if (!result) {
+			return;
+		}
+
+		return (
+			this._activateById(desc.identifier, { startup: true, extensionId: desc.identifier, activationEvent: result.activationEvent })
+				.then(undefined, err => this._logService.error(err))
+		);
+	}
+
+	private _handleExtensionTests(): Promise<void> {
+		return this._doHandleExtensionTests().then(undefined, error => {
+			console.error(error); // ensure any error message makes it onto the console
+
+			return Promise.reject(error);
+		});
+	}
+
+	private async _doHandleExtensionTests(): Promise<void> {
+		const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
+		if (!(extensionDevelopmentLocationURI && extensionTestsLocationURI && extensionTestsLocationURI.scheme === Schemas.file)) {
+			return Promise.resolve(undefined);
+		}
+
+		const extensionTestsPath = originalFSPath(extensionTestsLocationURI);
+
+		// Require the test runner via node require from the provided path
+		let testRunner: ITestRunner | INewTestRunner | undefined;
+		let requireError: Error | undefined;
+		try {
+			testRunner = await this._loadCommonJSModule(URI.file(extensionTestsPath), new ExtensionActivationTimesBuilder(false));
+		} catch (error) {
+			requireError = error;
+		}
+
+		// Execute the runner if it follows the old `run` spec
+		if (testRunner && typeof testRunner.run === 'function') {
+			return new Promise<void>((c, e) => {
+				const oldTestRunnerCallback = (error: Error, failures: number | undefined) => {
+					if (error) {
+						e(error.toString());
+					} else {
+						c(undefined);
+					}
+
+					// after tests have run, we shutdown the host
+					this._testRunnerExit(error || (typeof failures === 'number' && failures > 0) ? 1 /* ERROR */ : 0 /* OK */);
+				};
+
+				const runResult = testRunner!.run(extensionTestsPath, oldTestRunnerCallback);
+
+				// Using the new API `run(): Promise<void>`
+				if (runResult && runResult.then) {
+					runResult
+						.then(() => {
+							c();
+							this._testRunnerExit(0);
+						})
+						.catch((err: Error) => {
+							e(err.toString());
+							this._testRunnerExit(1);
+						});
+				}
+			});
+		}
+
+		// Otherwise make sure to shutdown anyway even in case of an error
+		else {
+			this._testRunnerExit(1 /* ERROR */);
+		}
+
+		return Promise.reject(new Error(requireError ? requireError.toString() : nls.localize('extensionTestError', "Path {0} does not point to a valid extension test runner.", extensionTestsPath)));
+	}
+
+	private _testRunnerExit(code: number): void {
+		// wait at most 5000ms for the renderer to confirm our exit request and for the renderer socket to drain
+		// (this is to ensure all outstanding messages reach the renderer)
+		const exitPromise = this._mainThreadExtensionsProxy.$onExtensionHostExit(code);
+		const drainPromise = this._extHostContext.drain();
+		Promise.race([Promise.all([exitPromise, drainPromise]), timeout(5000)]).then(() => {
+			this._hostUtils.exit(code);
+		});
+	}
+
+	private _startExtensionHost(): Promise<void> {
+		if (this._started) {
+			throw new Error(`Extension host is already started!`);
+		}
+		this._started = true;
+
+		return this._readyToStartExtensionHost.wait()
+			.then(() => this._readyToRunExtensions.open())
+			.then(() => this._handleEagerExtensions())
+			.then(() => this._handleExtensionTests())
+			.then(() => {
+				this._logService.info(`eager extensions activated`);
+			});
+	}
+
+	// -- called by extensions
+
+	public registerRemoteAuthorityResolver(authorityPrefix: string, resolver: vscode.RemoteAuthorityResolver): vscode.Disposable {
+		this._resolvers[authorityPrefix] = resolver;
+		return toDisposable(() => {
+			delete this._resolvers[authorityPrefix];
+		});
+	}
+
+	// -- called by main thread
+
+	public async $resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<IResolveAuthorityResult> {
+		const authorityPlusIndex = remoteAuthority.indexOf('+');
+		if (authorityPlusIndex === -1) {
+			throw new Error(`Not an authority that can be resolved!`);
+		}
+		const authorityPrefix = remoteAuthority.substr(0, authorityPlusIndex);
+
+		await this._almostReadyToRunExtensions.wait();
+		await this._activateByEvent(`onResolveRemoteAuthority:${authorityPrefix}`, false);
+
+		const resolver = this._resolvers[authorityPrefix];
+		if (!resolver) {
+			return {
+				type: 'error',
+				error: {
+					code: RemoteAuthorityResolverErrorCode.NoResolverFound,
+					message: `No remote extension installed to resolve ${authorityPrefix}.`,
+					detail: undefined
+				}
+			};
+		}
+
+		try {
+			const result = await resolver.resolve(remoteAuthority, { resolveAttempt });
+			this._disposables.add(await this._extHostTunnelService.setTunnelExtensionFunctions(resolver));
+
+			// Split merged API result into separate authority/options
+			const authority: ResolvedAuthority = {
+				authority: remoteAuthority,
+				host: result.host,
+				port: result.port,
+				connectionToken: result.connectionToken
+			};
+			const options: ResolvedOptions = {
+				extensionHostEnv: result.extensionHostEnv
+			};
+
+			return {
+				type: 'ok',
+				value: {
+					authority,
+					options,
+					tunnelInformation: { environmentTunnels: result.environmentTunnels }
+				}
+			};
+		} catch (err) {
+			if (err instanceof RemoteAuthorityResolverError) {
+				return {
+					type: 'error',
+					error: {
+						code: err._code,
+						message: err._message,
+						detail: err._detail
+					}
+				};
+			}
+			throw err;
+		}
+	}
+
+	public $startExtensionHost(enabledExtensionIds: ExtensionIdentifier[]): Promise<void> {
+		this._registry.keepOnly(enabledExtensionIds);
+		return this._startExtensionHost();
+	}
+
+	public $activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void> {
+		if (activationKind === ActivationKind.Immediate) {
+			return this._activateByEvent(activationEvent, false);
+		}
+
+		return (
+			this._readyToRunExtensions.wait()
+				.then(_ => this._activateByEvent(activationEvent, false))
+		);
+	}
+
+	public async $activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean> {
+		await this._readyToRunExtensions.wait();
+		if (!this._registry.getExtensionDescription(extensionId)) {
+			// unknown extension => ignore
+			return false;
+		}
+		await this._activateById(extensionId, reason);
+		return true;
+	}
+
+	public async $deltaExtensions(toAdd: IExtensionDescription[], toRemove: ExtensionIdentifier[]): Promise<void> {
+		toAdd.forEach((extension) => (<any>extension).extensionLocation = URI.revive(extension.extensionLocation));
+
+		const trie = await this.getExtensionPathIndex();
+
+		await Promise.all(toRemove.map(async (extensionId) => {
+			const extensionDescription = this._registry.getExtensionDescription(extensionId);
+			if (!extensionDescription) {
+				return;
+			}
+			const realpathValue = await this._hostUtils.realpath(extensionDescription.extensionLocation.fsPath);
+			trie.delete(URI.file(realpathValue).fsPath);
+		}));
+
+		await Promise.all(toAdd.map(async (extensionDescription) => {
+			const realpathValue = await this._hostUtils.realpath(extensionDescription.extensionLocation.fsPath);
+			trie.set(URI.file(realpathValue).fsPath, extensionDescription);
+		}));
+
+		this._registry.deltaExtensions(toAdd, toRemove);
+		return Promise.resolve(undefined);
+	}
+
+	public async $test_latency(n: number): Promise<number> {
+		return n;
+	}
+
+	public async $test_up(b: VSBuffer): Promise<number> {
+		return b.byteLength;
+	}
+
+	public async $test_down(size: number): Promise<VSBuffer> {
+		let buff = VSBuffer.alloc(size);
+		let value = Math.random() % 256;
+		for (let i = 0; i < size; i++) {
+			buff.writeUInt8(value, i);
+		}
+		return buff;
+	}
+
+	public async $updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void> {
+		this._remoteConnectionData = connectionData;
+		this._onDidChangeRemoteConnectionData.fire();
+	}
+
+	protected abstract _beforeAlmostReadyToRunExtensions(): Promise<void>;
+	protected abstract _getEntryPoint(extensionDescription: IExtensionDescription): string | undefined;
+	protected abstract _loadCommonJSModule<T>(module: URI, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T>;
+	public abstract $setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void>;
+}
+
+
+type TelemetryActivationEvent = {
+	id: string;
+	name: string;
+	extensionVersion: string;
+	publisherDisplayName: string;
+	activationEvents: string | null;
+	isBuiltin: boolean;
+	reason: string;
+	reasonId: string;
+};
+
+function getTelemetryActivationEvent(extensionDescription: IExtensionDescription, reason: ExtensionActivationReason): TelemetryActivationEvent {
+	const event = {
+		id: extensionDescription.identifier.value,
+		name: extensionDescription.name,
+		extensionVersion: extensionDescription.version,
+		publisherDisplayName: extensionDescription.publisher,
+		activationEvents: extensionDescription.activationEvents ? extensionDescription.activationEvents.join(',') : null,
+		isBuiltin: extensionDescription.isBuiltin,
+		reason: reason.activationEvent,
+		reasonId: reason.extensionId.value,
+	};
+
+	return event;
+}
+
+
+export const IExtHostExtensionService = createDecorator<IExtHostExtensionService>('IExtHostExtensionService');
+
+export interface IExtHostExtensionService extends AbstractExtHostExtensionService {
+	readonly _serviceBrand: undefined;
+	initialize(): Promise<void>;
+	isActivated(extensionId: ExtensionIdentifier): boolean;
+	activateByIdWithErrors(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
+	deactivateAll(): Promise<void>;
+	getExtensionExports(extensionId: ExtensionIdentifier): IExtensionAPI | null | undefined;
+	getExtensionRegistry(): Promise<ExtensionDescriptionRegistry>;
+	getExtensionPathIndex(): Promise<TernarySearchTree<string, IExtensionDescription>>;
+	registerRemoteAuthorityResolver(authorityPrefix: string, resolver: vscode.RemoteAuthorityResolver): vscode.Disposable;
+
+	onDidChangeRemoteConnectionData: Event<void>;
+	getRemoteConnectionData(): IRemoteConnectionData | null;
+}

lib/vscode/src/vs/workbench/api/common/extHostFileSystem.ts

@@ -0,0 +1,306 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { MainContext, IMainContext, ExtHostFileSystemShape, MainThreadFileSystemShape, IFileChangeDto } from './extHost.protocol';
+import type * as vscode from 'vscode';
+import * as files from 'vs/platform/files/common/files';
+import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { FileChangeType } from 'vs/workbench/api/common/extHostTypes';
+import * as typeConverter from 'vs/workbench/api/common/extHostTypeConverters';
+import { ExtHostLanguageFeatures } from 'vs/workbench/api/common/extHostLanguageFeatures';
+import { State, StateMachine, LinkComputer, Edge } from 'vs/editor/common/modes/linkComputer';
+import { commonPrefixLength } from 'vs/base/common/strings';
+import { CharCode } from 'vs/base/common/charCode';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+class FsLinkProvider {
+
+	private _schemes: string[] = [];
+	private _stateMachine?: StateMachine;
+
+	add(scheme: string): void {
+		this._stateMachine = undefined;
+		this._schemes.push(scheme);
+	}
+
+	delete(scheme: string): void {
+		const idx = this._schemes.indexOf(scheme);
+		if (idx >= 0) {
+			this._schemes.splice(idx, 1);
+			this._stateMachine = undefined;
+		}
+	}
+
+	private _initStateMachine(): void {
+		if (!this._stateMachine) {
+
+			// sort and compute common prefix with previous scheme
+			// then build state transitions based on the data
+			const schemes = this._schemes.sort();
+			const edges: Edge[] = [];
+			let prevScheme: string | undefined;
+			let prevState: State;
+			let lastState = State.LastKnownState;
+			let nextState = State.LastKnownState;
+			for (const scheme of schemes) {
+
+				// skip the common prefix of the prev scheme
+				// and continue with its last state
+				let pos = !prevScheme ? 0 : commonPrefixLength(prevScheme, scheme);
+				if (pos === 0) {
+					prevState = State.Start;
+				} else {
+					prevState = nextState;
+				}
+
+				for (; pos < scheme.length; pos++) {
+					// keep creating new (next) states until the
+					// end (and the BeforeColon-state) is reached
+					if (pos + 1 === scheme.length) {
+						// Save the last state here, because we need to continue for the next scheme
+						lastState = nextState;
+						nextState = State.BeforeColon;
+					} else {
+						nextState += 1;
+					}
+					edges.push([prevState, scheme.toUpperCase().charCodeAt(pos), nextState]);
+					edges.push([prevState, scheme.toLowerCase().charCodeAt(pos), nextState]);
+					prevState = nextState;
+				}
+
+				prevScheme = scheme;
+				// Restore the last state
+				nextState = lastState;
+			}
+
+			// all link must match this pattern `<scheme>:/<more>`
+			edges.push([State.BeforeColon, CharCode.Colon, State.AfterColon]);
+			edges.push([State.AfterColon, CharCode.Slash, State.End]);
+
+			this._stateMachine = new StateMachine(edges);
+		}
+	}
+
+	provideDocumentLinks(document: vscode.TextDocument): vscode.ProviderResult<vscode.DocumentLink[]> {
+		this._initStateMachine();
+
+		const result: vscode.DocumentLink[] = [];
+		const links = LinkComputer.computeLinks({
+			getLineContent(lineNumber: number): string {
+				return document.lineAt(lineNumber - 1).text;
+			},
+			getLineCount(): number {
+				return document.lineCount;
+			}
+		}, this._stateMachine);
+
+		for (const link of links) {
+			const docLink = typeConverter.DocumentLink.to(link);
+			if (docLink.target) {
+				result.push(docLink);
+			}
+		}
+		return result;
+	}
+}
+
+export class ExtHostFileSystem implements ExtHostFileSystemShape {
+
+	private readonly _proxy: MainThreadFileSystemShape;
+	private readonly _linkProvider = new FsLinkProvider();
+	private readonly _fsProvider = new Map<number, vscode.FileSystemProvider>();
+	private readonly _registeredSchemes = new Set<string>();
+	private readonly _watches = new Map<number, IDisposable>();
+
+	private _linkProviderRegistration?: IDisposable;
+	private _handlePool: number = 0;
+
+	constructor(mainContext: IMainContext, private _extHostLanguageFeatures: ExtHostLanguageFeatures) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadFileSystem);
+	}
+
+	dispose(): void {
+		this._linkProviderRegistration?.dispose();
+	}
+
+	private _registerLinkProviderIfNotYetRegistered(): void {
+		if (!this._linkProviderRegistration) {
+			this._linkProviderRegistration = this._extHostLanguageFeatures.registerDocumentLinkProvider(undefined, '*', this._linkProvider);
+		}
+	}
+
+	registerFileSystemProvider(extension: ExtensionIdentifier, scheme: string, provider: vscode.FileSystemProvider, options: { isCaseSensitive?: boolean, isReadonly?: boolean } = {}) {
+
+		if (this._registeredSchemes.has(scheme)) {
+			throw new Error(`a provider for the scheme '${scheme}' is already registered`);
+		}
+
+		//
+		this._registerLinkProviderIfNotYetRegistered();
+
+		const handle = this._handlePool++;
+		this._linkProvider.add(scheme);
+		this._registeredSchemes.add(scheme);
+		this._fsProvider.set(handle, provider);
+
+		let capabilities = files.FileSystemProviderCapabilities.FileReadWrite;
+		if (options.isCaseSensitive) {
+			capabilities += files.FileSystemProviderCapabilities.PathCaseSensitive;
+		}
+		if (options.isReadonly) {
+			capabilities += files.FileSystemProviderCapabilities.Readonly;
+		}
+		if (typeof provider.copy === 'function') {
+			capabilities += files.FileSystemProviderCapabilities.FileFolderCopy;
+		}
+		if (typeof provider.open === 'function' && typeof provider.close === 'function'
+			&& typeof provider.read === 'function' && typeof provider.write === 'function'
+		) {
+			capabilities += files.FileSystemProviderCapabilities.FileOpenReadWriteClose;
+		}
+
+		this._proxy.$registerFileSystemProvider(handle, scheme, capabilities).catch(err => {
+			console.error(`FAILED to register filesystem provider of ${extension.value}-extension for the scheme ${scheme}`);
+			console.error(err);
+		});
+
+		const subscription = provider.onDidChangeFile(event => {
+			const mapped: IFileChangeDto[] = [];
+			for (const e of event) {
+				let { uri: resource, type } = e;
+				if (resource.scheme !== scheme) {
+					// dropping events for wrong scheme
+					continue;
+				}
+				let newType: files.FileChangeType | undefined;
+				switch (type) {
+					case FileChangeType.Changed:
+						newType = files.FileChangeType.UPDATED;
+						break;
+					case FileChangeType.Created:
+						newType = files.FileChangeType.ADDED;
+						break;
+					case FileChangeType.Deleted:
+						newType = files.FileChangeType.DELETED;
+						break;
+					default:
+						throw new Error('Unknown FileChangeType');
+				}
+				mapped.push({ resource, type: newType });
+			}
+			this._proxy.$onFileSystemChange(handle, mapped);
+		});
+
+		return toDisposable(() => {
+			subscription.dispose();
+			this._linkProvider.delete(scheme);
+			this._registeredSchemes.delete(scheme);
+			this._fsProvider.delete(handle);
+			this._proxy.$unregisterProvider(handle);
+		});
+	}
+
+	private static _asIStat(stat: vscode.FileStat): files.IStat {
+		const { type, ctime, mtime, size } = stat;
+		return { type, ctime, mtime, size };
+	}
+
+	$stat(handle: number, resource: UriComponents): Promise<files.IStat> {
+		return Promise.resolve(this._getFsProvider(handle).stat(URI.revive(resource))).then(ExtHostFileSystem._asIStat);
+	}
+
+	$readdir(handle: number, resource: UriComponents): Promise<[string, files.FileType][]> {
+		return Promise.resolve(this._getFsProvider(handle).readDirectory(URI.revive(resource)));
+	}
+
+	$readFile(handle: number, resource: UriComponents): Promise<VSBuffer> {
+		return Promise.resolve(this._getFsProvider(handle).readFile(URI.revive(resource))).then(data => VSBuffer.wrap(data));
+	}
+
+	$writeFile(handle: number, resource: UriComponents, content: VSBuffer, opts: files.FileWriteOptions): Promise<void> {
+		return Promise.resolve(this._getFsProvider(handle).writeFile(URI.revive(resource), content.buffer, opts));
+	}
+
+	$delete(handle: number, resource: UriComponents, opts: files.FileDeleteOptions): Promise<void> {
+		return Promise.resolve(this._getFsProvider(handle).delete(URI.revive(resource), opts));
+	}
+
+	$rename(handle: number, oldUri: UriComponents, newUri: UriComponents, opts: files.FileOverwriteOptions): Promise<void> {
+		return Promise.resolve(this._getFsProvider(handle).rename(URI.revive(oldUri), URI.revive(newUri), opts));
+	}
+
+	$copy(handle: number, oldUri: UriComponents, newUri: UriComponents, opts: files.FileOverwriteOptions): Promise<void> {
+		const provider = this._getFsProvider(handle);
+		if (!provider.copy) {
+			throw new Error('FileSystemProvider does not implement "copy"');
+		}
+		return Promise.resolve(provider.copy(URI.revive(oldUri), URI.revive(newUri), opts));
+	}
+
+	$mkdir(handle: number, resource: UriComponents): Promise<void> {
+		return Promise.resolve(this._getFsProvider(handle).createDirectory(URI.revive(resource)));
+	}
+
+	$watch(handle: number, session: number, resource: UriComponents, opts: files.IWatchOptions): void {
+		const subscription = this._getFsProvider(handle).watch(URI.revive(resource), opts);
+		this._watches.set(session, subscription);
+	}
+
+	$unwatch(_handle: number, session: number): void {
+		const subscription = this._watches.get(session);
+		if (subscription) {
+			subscription.dispose();
+			this._watches.delete(session);
+		}
+	}
+
+	$open(handle: number, resource: UriComponents, opts: files.FileOpenOptions): Promise<number> {
+		const provider = this._getFsProvider(handle);
+		if (!provider.open) {
+			throw new Error('FileSystemProvider does not implement "open"');
+		}
+		return Promise.resolve(provider.open(URI.revive(resource), opts));
+	}
+
+	$close(handle: number, fd: number): Promise<void> {
+		const provider = this._getFsProvider(handle);
+		if (!provider.close) {
+			throw new Error('FileSystemProvider does not implement "close"');
+		}
+		return Promise.resolve(provider.close(fd));
+	}
+
+	$read(handle: number, fd: number, pos: number, length: number): Promise<VSBuffer> {
+		const provider = this._getFsProvider(handle);
+		if (!provider.read) {
+			throw new Error('FileSystemProvider does not implement "read"');
+		}
+		const data = VSBuffer.alloc(length);
+		return Promise.resolve(provider.read(fd, pos, data.buffer, 0, length)).then(read => {
+			return data.slice(0, read); // don't send zeros
+		});
+	}
+
+	$write(handle: number, fd: number, pos: number, data: VSBuffer): Promise<number> {
+		const provider = this._getFsProvider(handle);
+		if (!provider.write) {
+			throw new Error('FileSystemProvider does not implement "write"');
+		}
+		return Promise.resolve(provider.write(fd, pos, data.buffer, 0, data.byteLength));
+	}
+
+	private _getFsProvider(handle: number): vscode.FileSystemProvider {
+		const provider = this._fsProvider.get(handle);
+		if (!provider) {
+			const err = new Error();
+			err.name = 'ENOPRO';
+			err.message = `no provider`;
+			throw err;
+		}
+		return provider;
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostFileSystemConsumer.ts

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainThreadFileSystemShape, MainContext } from './extHost.protocol';
+import * as vscode from 'vscode';
+import * as files from 'vs/platform/files/common/files';
+import { FileSystemError } from 'vs/workbench/api/common/extHostTypes';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+import { IExtHostFileSystemInfo } from 'vs/workbench/api/common/extHostFileSystemInfo';
+
+export class ExtHostConsumerFileSystem implements vscode.FileSystem {
+
+	readonly _serviceBrand: undefined;
+
+	private readonly _proxy: MainThreadFileSystemShape;
+
+	constructor(
+		@IExtHostRpcService extHostRpc: IExtHostRpcService,
+		@IExtHostFileSystemInfo private readonly _fileSystemInfo: IExtHostFileSystemInfo,
+	) {
+		this._proxy = extHostRpc.getProxy(MainContext.MainThreadFileSystem);
+	}
+
+	stat(uri: vscode.Uri): Promise<vscode.FileStat> {
+		return this._proxy.$stat(uri).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]> {
+		return this._proxy.$readdir(uri).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	createDirectory(uri: vscode.Uri): Promise<void> {
+		return this._proxy.$mkdir(uri).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	async readFile(uri: vscode.Uri): Promise<Uint8Array> {
+		return this._proxy.$readFile(uri).then(buff => buff.buffer).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	writeFile(uri: vscode.Uri, content: Uint8Array): Promise<void> {
+		return this._proxy.$writeFile(uri, VSBuffer.wrap(content)).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	delete(uri: vscode.Uri, options?: { recursive?: boolean; useTrash?: boolean; }): Promise<void> {
+		return this._proxy.$delete(uri, { ...{ recursive: false, useTrash: false }, ...options }).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	rename(oldUri: vscode.Uri, newUri: vscode.Uri, options?: { overwrite?: boolean; }): Promise<void> {
+		return this._proxy.$rename(oldUri, newUri, { ...{ overwrite: false }, ...options }).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	copy(source: vscode.Uri, destination: vscode.Uri, options?: { overwrite?: boolean; }): Promise<void> {
+		return this._proxy.$copy(source, destination, { ...{ overwrite: false }, ...options }).catch(ExtHostConsumerFileSystem._handleError);
+	}
+	isWritableFileSystem(scheme: string): boolean | undefined {
+		const capabilities = this._fileSystemInfo.getCapabilities(scheme);
+		if (typeof capabilities === 'number') {
+			return !(capabilities & files.FileSystemProviderCapabilities.Readonly);
+		}
+		return undefined;
+	}
+
+	private static _handleError(err: any): never {
+		// generic error
+		if (!(err instanceof Error)) {
+			throw new FileSystemError(String(err));
+		}
+
+		// no provider (unknown scheme) error
+		if (err.name === 'ENOPRO') {
+			throw FileSystemError.Unavailable(err.message);
+		}
+
+		// file system error
+		switch (err.name) {
+			case files.FileSystemProviderErrorCode.FileExists: throw FileSystemError.FileExists(err.message);
+			case files.FileSystemProviderErrorCode.FileNotFound: throw FileSystemError.FileNotFound(err.message);
+			case files.FileSystemProviderErrorCode.FileNotADirectory: throw FileSystemError.FileNotADirectory(err.message);
+			case files.FileSystemProviderErrorCode.FileIsADirectory: throw FileSystemError.FileIsADirectory(err.message);
+			case files.FileSystemProviderErrorCode.NoPermissions: throw FileSystemError.NoPermissions(err.message);
+			case files.FileSystemProviderErrorCode.Unavailable: throw FileSystemError.Unavailable(err.message);
+
+			default: throw new FileSystemError(err.message, err.name as files.FileSystemProviderErrorCode);
+		}
+	}
+}
+
+export interface IExtHostConsumerFileSystem extends ExtHostConsumerFileSystem { }
+export const IExtHostConsumerFileSystem = createDecorator<IExtHostConsumerFileSystem>('IExtHostConsumerFileSystem');

lib/vscode/src/vs/workbench/api/common/extHostFileSystemEventService.ts

@@ -0,0 +1,228 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AsyncEmitter, Emitter, Event, IWaitUntil } from 'vs/base/common/event';
+import { IRelativePattern, parse } from 'vs/base/common/glob';
+import { URI } from 'vs/base/common/uri';
+import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import type * as vscode from 'vscode';
+import { ExtHostFileSystemEventServiceShape, FileSystemEvents, IMainContext, MainContext, SourceTargetPair, IWorkspaceEditDto, MainThreadBulkEditsShape } from './extHost.protocol';
+import * as typeConverter from './extHostTypeConverters';
+import { Disposable, WorkspaceEdit } from './extHostTypes';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { FileOperation } from 'vs/platform/files/common/files';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ILogService } from 'vs/platform/log/common/log';
+
+class FileSystemWatcher implements vscode.FileSystemWatcher {
+
+	private readonly _onDidCreate = new Emitter<vscode.Uri>();
+	private readonly _onDidChange = new Emitter<vscode.Uri>();
+	private readonly _onDidDelete = new Emitter<vscode.Uri>();
+	private _disposable: Disposable;
+	private _config: number;
+
+	get ignoreCreateEvents(): boolean {
+		return Boolean(this._config & 0b001);
+	}
+
+	get ignoreChangeEvents(): boolean {
+		return Boolean(this._config & 0b010);
+	}
+
+	get ignoreDeleteEvents(): boolean {
+		return Boolean(this._config & 0b100);
+	}
+
+	constructor(dispatcher: Event<FileSystemEvents>, globPattern: string | IRelativePattern, ignoreCreateEvents?: boolean, ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean) {
+
+		this._config = 0;
+		if (ignoreCreateEvents) {
+			this._config += 0b001;
+		}
+		if (ignoreChangeEvents) {
+			this._config += 0b010;
+		}
+		if (ignoreDeleteEvents) {
+			this._config += 0b100;
+		}
+
+		const parsedPattern = parse(globPattern);
+
+		const subscription = dispatcher(events => {
+			if (!ignoreCreateEvents) {
+				for (let created of events.created) {
+					const uri = URI.revive(created);
+					if (parsedPattern(uri.fsPath)) {
+						this._onDidCreate.fire(uri);
+					}
+				}
+			}
+			if (!ignoreChangeEvents) {
+				for (let changed of events.changed) {
+					const uri = URI.revive(changed);
+					if (parsedPattern(uri.fsPath)) {
+						this._onDidChange.fire(uri);
+					}
+				}
+			}
+			if (!ignoreDeleteEvents) {
+				for (let deleted of events.deleted) {
+					const uri = URI.revive(deleted);
+					if (parsedPattern(uri.fsPath)) {
+						this._onDidDelete.fire(uri);
+					}
+				}
+			}
+		});
+
+		this._disposable = Disposable.from(this._onDidCreate, this._onDidChange, this._onDidDelete, subscription);
+	}
+
+	dispose() {
+		this._disposable.dispose();
+	}
+
+	get onDidCreate(): Event<vscode.Uri> {
+		return this._onDidCreate.event;
+	}
+
+	get onDidChange(): Event<vscode.Uri> {
+		return this._onDidChange.event;
+	}
+
+	get onDidDelete(): Event<vscode.Uri> {
+		return this._onDidDelete.event;
+	}
+}
+
+interface IExtensionListener<E> {
+	extension: IExtensionDescription;
+	(e: E): any;
+}
+
+export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServiceShape {
+
+	private readonly _onFileSystemEvent = new Emitter<FileSystemEvents>();
+
+	private readonly _onDidRenameFile = new Emitter<vscode.FileRenameEvent>();
+	private readonly _onDidCreateFile = new Emitter<vscode.FileCreateEvent>();
+	private readonly _onDidDeleteFile = new Emitter<vscode.FileDeleteEvent>();
+	private readonly _onWillRenameFile = new AsyncEmitter<vscode.FileWillRenameEvent>();
+	private readonly _onWillCreateFile = new AsyncEmitter<vscode.FileWillCreateEvent>();
+	private readonly _onWillDeleteFile = new AsyncEmitter<vscode.FileWillDeleteEvent>();
+
+	readonly onDidRenameFile: Event<vscode.FileRenameEvent> = this._onDidRenameFile.event;
+	readonly onDidCreateFile: Event<vscode.FileCreateEvent> = this._onDidCreateFile.event;
+	readonly onDidDeleteFile: Event<vscode.FileDeleteEvent> = this._onDidDeleteFile.event;
+
+
+	constructor(
+		mainContext: IMainContext,
+		private readonly _logService: ILogService,
+		private readonly _extHostDocumentsAndEditors: ExtHostDocumentsAndEditors,
+		private readonly _mainThreadBulkEdits: MainThreadBulkEditsShape = mainContext.getProxy(MainContext.MainThreadBulkEdits)
+	) {
+		//
+	}
+
+	//--- file events
+
+	createFileSystemWatcher(globPattern: string | IRelativePattern, ignoreCreateEvents?: boolean, ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean): vscode.FileSystemWatcher {
+		return new FileSystemWatcher(this._onFileSystemEvent.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
+	}
+
+	$onFileEvent(events: FileSystemEvents) {
+		this._onFileSystemEvent.fire(events);
+	}
+
+
+	//--- file operations
+
+	$onDidRunFileOperation(operation: FileOperation, files: SourceTargetPair[]): void {
+		switch (operation) {
+			case FileOperation.MOVE:
+				this._onDidRenameFile.fire(Object.freeze({ files: files.map(f => ({ oldUri: URI.revive(f.source!), newUri: URI.revive(f.target) })) }));
+				break;
+			case FileOperation.DELETE:
+				this._onDidDeleteFile.fire(Object.freeze({ files: files.map(f => URI.revive(f.target)) }));
+				break;
+			case FileOperation.CREATE:
+				this._onDidCreateFile.fire(Object.freeze({ files: files.map(f => URI.revive(f.target)) }));
+				break;
+			default:
+			//ignore, dont send
+		}
+	}
+
+
+	getOnWillRenameFileEvent(extension: IExtensionDescription): Event<vscode.FileWillRenameEvent> {
+		return this._createWillExecuteEvent(extension, this._onWillRenameFile);
+	}
+
+	getOnWillCreateFileEvent(extension: IExtensionDescription): Event<vscode.FileWillCreateEvent> {
+		return this._createWillExecuteEvent(extension, this._onWillCreateFile);
+	}
+
+	getOnWillDeleteFileEvent(extension: IExtensionDescription): Event<vscode.FileWillDeleteEvent> {
+		return this._createWillExecuteEvent(extension, this._onWillDeleteFile);
+	}
+
+	private _createWillExecuteEvent<E extends IWaitUntil>(extension: IExtensionDescription, emitter: AsyncEmitter<E>): Event<E> {
+		return (listener, thisArg, disposables) => {
+			const wrappedListener: IExtensionListener<E> = function wrapped(e: E) { listener.call(thisArg, e); };
+			wrappedListener.extension = extension;
+			return emitter.event(wrappedListener, undefined, disposables);
+		};
+	}
+
+	async $onWillRunFileOperation(operation: FileOperation, files: SourceTargetPair[], timeout: number, token: CancellationToken): Promise<any> {
+		switch (operation) {
+			case FileOperation.MOVE:
+				await this._fireWillEvent(this._onWillRenameFile, { files: files.map(f => ({ oldUri: URI.revive(f.source!), newUri: URI.revive(f.target) })) }, timeout, token);
+				break;
+			case FileOperation.DELETE:
+				await this._fireWillEvent(this._onWillDeleteFile, { files: files.map(f => URI.revive(f.target)) }, timeout, token);
+				break;
+			case FileOperation.CREATE:
+				await this._fireWillEvent(this._onWillCreateFile, { files: files.map(f => URI.revive(f.target)) }, timeout, token);
+				break;
+			default:
+			//ignore, dont send
+		}
+	}
+
+	private async _fireWillEvent<E extends IWaitUntil>(emitter: AsyncEmitter<E>, data: Omit<E, 'waitUntil'>, timeout: number, token: CancellationToken): Promise<any> {
+
+		const edits: WorkspaceEdit[] = [];
+
+		await emitter.fireAsync(data, token, async (thenable, listener) => {
+			// ignore all results except for WorkspaceEdits. Those are stored in an array.
+			const now = Date.now();
+			const result = await Promise.resolve(thenable);
+			if (result instanceof WorkspaceEdit) {
+				edits.push(result);
+			}
+
+			if (Date.now() - now > timeout) {
+				this._logService.warn('SLOW file-participant', (<IExtensionListener<E>>listener).extension?.identifier);
+			}
+		});
+
+		if (token.isCancellationRequested) {
+			return;
+		}
+
+		if (edits.length > 0) {
+			// concat all WorkspaceEdits collected via waitUntil-call and apply them in one go.
+			const dto: IWorkspaceEditDto = { edits: [] };
+			for (let edit of edits) {
+				let { edits } = typeConverter.WorkspaceEdit.from(edit, this._extHostDocumentsAndEditors);
+				dto.edits = dto.edits.concat(edits);
+			}
+			return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(dto);
+		}
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostFileSystemInfo.ts

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Schemas } from 'vs/base/common/network';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ExtHostFileSystemInfoShape } from 'vs/workbench/api/common/extHost.protocol';
+
+export class ExtHostFileSystemInfo implements ExtHostFileSystemInfoShape {
+
+	declare readonly _serviceBrand: undefined;
+
+	private readonly _systemSchemes = new Set(Object.keys(Schemas));
+	private readonly _providerInfo = new Map<string, number>();
+
+	$acceptProviderInfos(scheme: string, capabilities: number | null): void {
+		if (capabilities === null) {
+			this._providerInfo.delete(scheme);
+		} else {
+			this._providerInfo.set(scheme, capabilities);
+		}
+	}
+
+	isFreeScheme(scheme: string): boolean {
+		return !this._providerInfo.has(scheme) && !this._systemSchemes.has(scheme);
+	}
+
+	getCapabilities(scheme: string): number | undefined {
+		return this._providerInfo.get(scheme);
+	}
+}
+
+export interface IExtHostFileSystemInfo extends ExtHostFileSystemInfo { }
+export const IExtHostFileSystemInfo = createDecorator<IExtHostFileSystemInfo>('IExtHostFileSystemInfo');

lib/vscode/src/vs/workbench/api/common/extHostInitDataService.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IInitData } from './extHost.protocol';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+
+export const IExtHostInitDataService = createDecorator<IExtHostInitDataService>('IExtHostInitDataService');
+
+export interface IExtHostInitDataService extends Readonly<IInitData> {
+	readonly _serviceBrand: undefined;
+}
+

lib/vscode/src/vs/workbench/api/common/extHostLabelService.ts

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ResourceLabelFormatter } from 'vs/platform/label/common/label';
+import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { MainThreadLabelServiceShape, ExtHostLabelServiceShape, MainContext, IMainContext } from 'vs/workbench/api/common/extHost.protocol';
+
+export class ExtHostLabelService implements ExtHostLabelServiceShape {
+
+	private readonly _proxy: MainThreadLabelServiceShape;
+	private _handlePool: number = 0;
+
+	constructor(mainContext: IMainContext) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadLabelService);
+	}
+
+	$registerResourceLabelFormatter(formatter: ResourceLabelFormatter): IDisposable {
+		const handle = this._handlePool++;
+		this._proxy.$registerResourceLabelFormatter(handle, formatter);
+
+		return toDisposable(() => {
+			this._proxy.$unregisterResourceLabelFormatter(handle);
+		});
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostLanguages.ts

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainContext, MainThreadLanguagesShape, IMainContext } from './extHost.protocol';
+import type * as vscode from 'vscode';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import * as typeConvert from 'vs/workbench/api/common/extHostTypeConverters';
+import { StandardTokenType, Range, Position } from 'vs/workbench/api/common/extHostTypes';
+
+export class ExtHostLanguages {
+
+	private readonly _proxy: MainThreadLanguagesShape;
+	private readonly _documents: ExtHostDocuments;
+
+	constructor(
+		mainContext: IMainContext,
+		documents: ExtHostDocuments
+	) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadLanguages);
+		this._documents = documents;
+	}
+
+	getLanguages(): Promise<string[]> {
+		return this._proxy.$getLanguages();
+	}
+
+	async changeLanguage(uri: vscode.Uri, languageId: string): Promise<vscode.TextDocument> {
+		await this._proxy.$changeLanguage(uri, languageId);
+		const data = this._documents.getDocumentData(uri);
+		if (!data) {
+			throw new Error(`document '${uri.toString}' NOT found`);
+		}
+		return data.document;
+	}
+
+	async tokenAtPosition(document: vscode.TextDocument, position: vscode.Position): Promise<vscode.TokenInformation> {
+		const versionNow = document.version;
+		const pos = typeConvert.Position.from(position);
+		const info = await this._proxy.$tokensAtPosition(document.uri, pos);
+		const defaultRange = {
+			type: StandardTokenType.Other,
+			range: document.getWordRangeAtPosition(position) ?? new Range(position.line, position.character, position.line, position.character)
+		};
+		if (!info) {
+			// no result
+			return defaultRange;
+		}
+		const result = {
+			range: typeConvert.Range.to(info.range),
+			type: typeConvert.TokenType.to(info.type)
+		};
+		if (!result.range.contains(<Position>position)) {
+			// bogous result
+			return defaultRange;
+		}
+		if (versionNow !== document.version) {
+			// concurrent change
+			return defaultRange;
+		}
+		return result;
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostMemento.ts

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type * as vscode from 'vscode';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+
+export class ExtensionMemento implements vscode.Memento {
+
+	protected readonly _id: string;
+	private readonly _shared: boolean;
+	protected readonly _storage: ExtHostStorage;
+
+	private readonly _init: Promise<ExtensionMemento>;
+	private _value?: { [n: string]: any; };
+	private readonly _storageListener: IDisposable;
+
+	constructor(id: string, global: boolean, storage: ExtHostStorage) {
+		this._id = id;
+		this._shared = global;
+		this._storage = storage;
+
+		this._init = this._storage.getValue(this._shared, this._id, Object.create(null)).then(value => {
+			this._value = value;
+			return this;
+		});
+
+		this._storageListener = this._storage.onDidChangeStorage(e => {
+			if (e.shared === this._shared && e.key === this._id) {
+				this._value = e.value;
+			}
+		});
+	}
+
+	get whenReady(): Promise<ExtensionMemento> {
+		return this._init;
+	}
+
+	get<T>(key: string): T | undefined;
+	get<T>(key: string, defaultValue: T): T;
+	get<T>(key: string, defaultValue?: T): T {
+		let value = this._value![key];
+		if (typeof value === 'undefined') {
+			value = defaultValue;
+		}
+		return value;
+	}
+
+	update(key: string, value: any): Promise<void> {
+		this._value![key] = value;
+		return this._storage.setValue(this._shared, this._id, this._value!);
+	}
+
+	dispose(): void {
+		this._storageListener.dispose();
+	}
+}
+
+export class ExtensionGlobalMemento extends ExtensionMemento {
+
+	private readonly _extension: IExtensionDescription;
+
+	setKeysForSync(keys: string[]): void {
+		this._storage.registerExtensionStorageKeysToSync({ id: this._id, version: this._extension.version }, keys);
+	}
+
+	constructor(extensionDescription: IExtensionDescription, storage: ExtHostStorage) {
+		super(extensionDescription.identifier.value, true, storage);
+		this._extension = extensionDescription;
+	}
+
+}

lib/vscode/src/vs/workbench/api/common/extHostMessageService.ts

@@ -0,0 +1,64 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import Severity from 'vs/base/common/severity';
+import type * as vscode from 'vscode';
+import { MainContext, MainThreadMessageServiceShape, MainThreadMessageOptions, IMainContext } from './extHost.protocol';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import { ILogService } from 'vs/platform/log/common/log';
+
+function isMessageItem(item: any): item is vscode.MessageItem {
+	return item && item.title;
+}
+
+export class ExtHostMessageService {
+
+	private _proxy: MainThreadMessageServiceShape;
+
+	constructor(
+		mainContext: IMainContext,
+		@ILogService private readonly _logService: ILogService
+	) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadMessageService);
+	}
+
+
+	showMessage(extension: IExtensionDescription, severity: Severity, message: string, optionsOrFirstItem: vscode.MessageOptions | string | undefined, rest: string[]): Promise<string | undefined>;
+	showMessage(extension: IExtensionDescription, severity: Severity, message: string, optionsOrFirstItem: vscode.MessageOptions | vscode.MessageItem | undefined, rest: vscode.MessageItem[]): Promise<vscode.MessageItem | undefined>;
+	showMessage(extension: IExtensionDescription, severity: Severity, message: string, optionsOrFirstItem: vscode.MessageOptions | vscode.MessageItem | string | undefined, rest: Array<vscode.MessageItem | string>): Promise<string | vscode.MessageItem | undefined>;
+	showMessage(extension: IExtensionDescription, severity: Severity, message: string, optionsOrFirstItem: vscode.MessageOptions | string | vscode.MessageItem | undefined, rest: Array<string | vscode.MessageItem>): Promise<string | vscode.MessageItem | undefined> {
+
+		const options: MainThreadMessageOptions = { extension };
+		let items: (string | vscode.MessageItem)[];
+
+		if (typeof optionsOrFirstItem === 'string' || isMessageItem(optionsOrFirstItem)) {
+			items = [optionsOrFirstItem, ...rest];
+		} else {
+			options.modal = optionsOrFirstItem && optionsOrFirstItem.modal;
+			items = rest;
+		}
+
+		const commands: { title: string; isCloseAffordance: boolean; handle: number; }[] = [];
+
+		for (let handle = 0; handle < items.length; handle++) {
+			const command = items[handle];
+			if (typeof command === 'string') {
+				commands.push({ title: command, handle, isCloseAffordance: false });
+			} else if (typeof command === 'object') {
+				let { title, isCloseAffordance } = command;
+				commands.push({ title, isCloseAffordance: !!isCloseAffordance, handle });
+			} else {
+				this._logService.warn('Invalid message item:', command);
+			}
+		}
+
+		return this._proxy.$showMessage(severity, message, options, commands).then(handle => {
+			if (typeof handle === 'number') {
+				return items[handle];
+			}
+			return undefined;
+		});
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostNotebookConcatDocument.ts

@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as types from 'vs/workbench/api/common/extHostTypes';
+import * as vscode from 'vscode';
+import { Event, Emitter } from 'vs/base/common/event';
+import { ExtHostNotebookController } from 'vs/workbench/api/common/extHostNotebook';
+import { ExtHostDocuments } from 'vs/workbench/api/common/extHostDocuments';
+import { PrefixSumComputer } from 'vs/editor/common/viewModel/prefixSumComputer';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { score } from 'vs/editor/common/modes/languageSelector';
+import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import { ResourceMap } from 'vs/base/common/map';
+import { URI } from 'vs/base/common/uri';
+import { generateUuid } from 'vs/base/common/uuid';
+
+export class ExtHostNotebookConcatDocument implements vscode.NotebookConcatTextDocument {
+
+	private _disposables = new DisposableStore();
+	private _isClosed = false;
+
+	private _cells!: vscode.NotebookCell[];
+	private _cellUris!: ResourceMap<number>;
+	private _cellLengths!: PrefixSumComputer;
+	private _cellLines!: PrefixSumComputer;
+	private _versionId = 0;
+
+	private readonly _onDidChange = new Emitter<void>();
+	readonly onDidChange: Event<void> = this._onDidChange.event;
+
+	readonly uri = URI.from({ scheme: 'vscode-concat-doc', path: generateUuid() });
+
+	constructor(
+		extHostNotebooks: ExtHostNotebookController,
+		extHostDocuments: ExtHostDocuments,
+		private readonly _notebook: vscode.NotebookDocument,
+		private readonly _selector: vscode.DocumentSelector | undefined,
+	) {
+		this._init();
+
+		this._disposables.add(extHostDocuments.onDidChangeDocument(e => {
+			const cellIdx = this._cellUris.get(e.document.uri);
+			if (cellIdx !== undefined) {
+				this._cellLengths.changeValue(cellIdx, this._cells[cellIdx].document.getText().length + 1);
+				this._cellLines.changeValue(cellIdx, this._cells[cellIdx].document.lineCount);
+				this._versionId += 1;
+				this._onDidChange.fire(undefined);
+			}
+		}));
+		const documentChange = (document: vscode.NotebookDocument) => {
+			if (document === this._notebook) {
+				this._init();
+				this._versionId += 1;
+				this._onDidChange.fire(undefined);
+			}
+		};
+
+		this._disposables.add(extHostNotebooks.onDidChangeCellLanguage(e => documentChange(e.document)));
+		this._disposables.add(extHostNotebooks.onDidChangeNotebookCells(e => documentChange(e.document)));
+	}
+
+	dispose(): void {
+		this._disposables.dispose();
+		this._isClosed = true;
+	}
+
+	get isClosed() {
+		return this._isClosed;
+	}
+
+	private _init() {
+		this._cells = [];
+		this._cellUris = new ResourceMap();
+		const cellLengths: number[] = [];
+		const cellLineCounts: number[] = [];
+		for (const cell of this._notebook.cells) {
+			if (cell.cellKind === CellKind.Code && (!this._selector || score(this._selector, cell.uri, cell.language, true))) {
+				this._cellUris.set(cell.uri, this._cells.length);
+				this._cells.push(cell);
+				cellLengths.push(cell.document.getText().length + 1);
+				cellLineCounts.push(cell.document.lineCount);
+			}
+		}
+		this._cellLengths = new PrefixSumComputer(new Uint32Array(cellLengths));
+		this._cellLines = new PrefixSumComputer(new Uint32Array(cellLineCounts));
+	}
+
+	get version(): number {
+		return this._versionId;
+	}
+
+	getText(range?: vscode.Range): string {
+		if (!range) {
+			let result = '';
+			for (const cell of this._cells) {
+				result += cell.document.getText() + '\n';
+			}
+			// remove last newline again
+			result = result.slice(0, -1);
+			return result;
+		}
+
+		if (range.isEmpty) {
+			return '';
+		}
+
+		// get start and end locations and create substrings
+		const start = this.locationAt(range.start);
+		const end = this.locationAt(range.end);
+		const startCell = this._cells[this._cellUris.get(start.uri) ?? -1];
+		const endCell = this._cells[this._cellUris.get(end.uri) ?? -1];
+
+		if (!startCell || !endCell) {
+			return '';
+		} else if (startCell === endCell) {
+			return startCell.document.getText(new types.Range(start.range.start, end.range.end));
+		} else {
+			const a = startCell.document.getText(new types.Range(start.range.start, new types.Position(startCell.document.lineCount, 0)));
+			const b = endCell.document.getText(new types.Range(new types.Position(0, 0), end.range.end));
+			return a + '\n' + b;
+		}
+	}
+
+	offsetAt(position: vscode.Position): number {
+		const idx = this._cellLines.getIndexOf(position.line);
+		const offset1 = this._cellLengths.getAccumulatedValue(idx.index - 1);
+		const offset2 = this._cells[idx.index].document.offsetAt(position.with(idx.remainder));
+		return offset1 + offset2;
+	}
+
+	positionAt(locationOrOffset: vscode.Location | number): vscode.Position {
+		if (typeof locationOrOffset === 'number') {
+			const idx = this._cellLengths.getIndexOf(locationOrOffset);
+			const lineCount = this._cellLines.getAccumulatedValue(idx.index - 1);
+			return this._cells[idx.index].document.positionAt(idx.remainder).translate(lineCount);
+		}
+
+		const idx = this._cellUris.get(locationOrOffset.uri);
+		if (idx !== undefined) {
+			const line = this._cellLines.getAccumulatedValue(idx - 1);
+			return new types.Position(line + locationOrOffset.range.start.line, locationOrOffset.range.start.character);
+		}
+		// do better?
+		// return undefined;
+		return new types.Position(0, 0);
+	}
+
+	locationAt(positionOrRange: vscode.Range | vscode.Position): types.Location {
+		if (!types.Range.isRange(positionOrRange)) {
+			positionOrRange = new types.Range(<types.Position>positionOrRange, <types.Position>positionOrRange);
+		}
+
+		const startIdx = this._cellLines.getIndexOf(positionOrRange.start.line);
+		let endIdx = startIdx;
+		if (!positionOrRange.isEmpty) {
+			endIdx = this._cellLines.getIndexOf(positionOrRange.end.line);
+		}
+
+		const startPos = new types.Position(startIdx.remainder, positionOrRange.start.character);
+		const endPos = new types.Position(endIdx.remainder, positionOrRange.end.character);
+		const range = new types.Range(startPos, endPos);
+
+		const startCell = this._cells[startIdx.index];
+		return new types.Location(startCell.uri, <types.Range>startCell.document.validateRange(range));
+	}
+
+	contains(uri: vscode.Uri): boolean {
+		return this._cellUris.has(uri);
+	}
+
+	validateRange(range: vscode.Range): vscode.Range {
+		const start = this.validatePosition(range.start);
+		const end = this.validatePosition(range.end);
+		return range.with(start, end);
+	}
+
+	validatePosition(position: vscode.Position): vscode.Position {
+		const startIdx = this._cellLines.getIndexOf(position.line);
+
+		const cellPosition = new types.Position(startIdx.remainder, position.character);
+		const validCellPosition = this._cells[startIdx.index].document.validatePosition(cellPosition);
+
+		const line = this._cellLines.getAccumulatedValue(startIdx.index - 1);
+		return new types.Position(line + validCellPosition.line, validCellPosition.character);
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostNotebookDocument.ts

@@ -0,0 +1,529 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter, Event } from 'vs/base/common/event';
+import { hash } from 'vs/base/common/hash';
+import { Disposable, DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
+import { joinPath } from 'vs/base/common/resources';
+import { ISplice } from 'vs/base/common/sequence';
+import { URI } from 'vs/base/common/uri';
+import * as UUID from 'vs/base/common/uuid';
+import { CellKind, INotebookDocumentPropertiesChangeData, IWorkspaceCellEditDto, MainThreadBulkEditsShape, MainThreadNotebookShape, NotebookCellOutputsSplice, WorkspaceEditType } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostDocumentsAndEditors, IExtHostModelAddedData } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { CellEditType, CellOutputKind, diff, IMainCellDto, IProcessedOutput, NotebookCellMetadata, NotebookCellsChangedEventDto, NotebookCellsChangeType, NotebookCellsSplice2, notebookDocumentMetadataDefaults } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import * as vscode from 'vscode';
+import { Cache } from './cache';
+
+
+interface IObservable<T> {
+	proxy: T;
+	onDidChange: Event<void>;
+}
+
+function getObservable<T extends Object>(obj: T): IObservable<T> {
+	const onDidChange = new Emitter<void>();
+	const proxy = new Proxy(obj, {
+		set(target: T, p: PropertyKey, value: any, _receiver: any): boolean {
+			target[p as keyof T] = value;
+			onDidChange.fire();
+			return true;
+		}
+	});
+
+	return {
+		proxy,
+		onDidChange: onDidChange.event
+	};
+}
+
+class RawContentChangeEvent {
+
+	constructor(readonly start: number, readonly deletedCount: number, readonly deletedItems: ExtHostCell[], readonly items: ExtHostCell[]) { }
+
+	static asApiEvent(event: RawContentChangeEvent): vscode.NotebookCellsChangeData {
+		return Object.freeze({
+			start: event.start,
+			deletedCount: event.deletedCount,
+			deletedItems: event.deletedItems.map(data => data.cell),
+			items: event.items.map(data => data.cell)
+		});
+	}
+}
+
+export class ExtHostCell extends Disposable {
+
+	static asModelAddData(notebook: vscode.NotebookDocument, cell: IMainCellDto): IExtHostModelAddedData {
+		return {
+			EOL: cell.eol,
+			lines: cell.source,
+			modeId: cell.language,
+			uri: cell.uri,
+			isDirty: false,
+			versionId: 1,
+			notebook
+		};
+	}
+
+	private _onDidDispose = new Emitter<void>();
+	readonly onDidDispose: Event<void> = this._onDidDispose.event;
+
+	private _onDidChangeOutputs = new Emitter<ISplice<IProcessedOutput>[]>();
+	readonly onDidChangeOutputs: Event<ISplice<IProcessedOutput>[]> = this._onDidChangeOutputs.event;
+
+	private _outputs: any[];
+	private _outputMapping = new WeakMap<vscode.CellOutput, string | undefined /* output ID */>();
+
+	private _metadata: vscode.NotebookCellMetadata;
+	private _metadataChangeListener: IDisposable;
+
+	readonly handle: number;
+	readonly uri: URI;
+	readonly cellKind: CellKind;
+
+	private _cell: vscode.NotebookCell | undefined;
+
+	constructor(
+		private readonly _mainThreadBulkEdits: MainThreadBulkEditsShape,
+		private readonly _notebook: ExtHostNotebookDocument,
+		private readonly _extHostDocument: ExtHostDocumentsAndEditors,
+		private readonly _cellData: IMainCellDto,
+	) {
+		super();
+
+		this.handle = _cellData.handle;
+		this.uri = URI.revive(_cellData.uri);
+		this.cellKind = _cellData.cellKind;
+
+		this._outputs = _cellData.outputs;
+		for (const output of this._outputs) {
+			this._outputMapping.set(output, output.outputId);
+			delete output.outputId;
+		}
+
+		const observableMetadata = getObservable(_cellData.metadata ?? {});
+		this._metadata = observableMetadata.proxy;
+		this._metadataChangeListener = this._register(observableMetadata.onDidChange(() => {
+			this._updateMetadata();
+		}));
+	}
+
+	get cell(): vscode.NotebookCell {
+		if (!this._cell) {
+			const that = this;
+			const document = this._extHostDocument.getDocument(this.uri)!.document;
+			this._cell = Object.freeze({
+				get index() { return that._notebook.getCellIndex(that); },
+				notebook: that._notebook.notebookDocument,
+				uri: that.uri,
+				cellKind: this._cellData.cellKind,
+				document,
+				get language() { return document.languageId; },
+				get outputs() { return that._outputs; },
+				set outputs(value) { that._updateOutputs(value); },
+				get metadata() { return that._metadata; },
+				set metadata(value) {
+					that.setMetadata(value);
+					that._updateMetadata();
+				},
+			});
+		}
+		return this._cell;
+	}
+
+	dispose() {
+		super.dispose();
+		this._onDidDispose.fire();
+	}
+
+	setOutputs(newOutputs: vscode.CellOutput[]): void {
+		this._outputs = newOutputs;
+	}
+
+	private _updateOutputs(newOutputs: vscode.CellOutput[]) {
+		const rawDiffs = diff<vscode.CellOutput>(this._outputs || [], newOutputs || [], (a) => {
+			return this._outputMapping.has(a);
+		});
+
+		const transformedDiffs: ISplice<IProcessedOutput>[] = rawDiffs.map(diff => {
+			for (let i = diff.start; i < diff.start + diff.deleteCount; i++) {
+				this._outputMapping.delete(this._outputs[i]);
+			}
+
+			return {
+				deleteCount: diff.deleteCount,
+				start: diff.start,
+				toInsert: diff.toInsert.map((output): IProcessedOutput => {
+					if (output.outputKind === CellOutputKind.Rich) {
+						const uuid = UUID.generateUuid();
+						this._outputMapping.set(output, uuid);
+						return { ...output, outputId: uuid };
+					}
+
+					this._outputMapping.set(output, undefined);
+					return output;
+				})
+			};
+		});
+
+		this._outputs = newOutputs;
+		this._onDidChangeOutputs.fire(transformedDiffs);
+	}
+
+	setMetadata(newMetadata: vscode.NotebookCellMetadata): void {
+		// Don't apply metadata defaults here, 'undefined' means 'inherit from document metadata'
+		this._metadataChangeListener.dispose();
+		const observableMetadata = getObservable(newMetadata);
+		this._metadata = observableMetadata.proxy;
+		this._metadataChangeListener = this._register(observableMetadata.onDidChange(() => {
+			this._updateMetadata();
+		}));
+	}
+
+	private _updateMetadata(): Promise<boolean> {
+		const index = this._notebook.notebookDocument.cells.indexOf(this.cell);
+		const edit: IWorkspaceCellEditDto = {
+			_type: WorkspaceEditType.Cell,
+			metadata: undefined,
+			resource: this._notebook.uri,
+			notebookVersionId: this._notebook.notebookDocument.version,
+			edit: { editType: CellEditType.Metadata, index, metadata: this._metadata }
+		};
+
+		return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit({ edits: [edit] });
+	}
+}
+
+export interface INotebookEventEmitter {
+	emitModelChange(events: vscode.NotebookCellsChangeEvent): void;
+	emitDocumentMetadataChange(event: vscode.NotebookDocumentMetadataChangeEvent): void;
+	emitCellOutputsChange(event: vscode.NotebookCellOutputsChangeEvent): void;
+	emitCellLanguageChange(event: vscode.NotebookCellLanguageChangeEvent): void;
+	emitCellMetadataChange(event: vscode.NotebookCellMetadataChangeEvent): void;
+}
+
+function hashPath(resource: URI): string {
+	const str = resource.scheme === Schemas.file || resource.scheme === Schemas.untitled ? resource.fsPath : resource.toString();
+	return hash(str) + '';
+}
+
+export class ExtHostNotebookDocument extends Disposable {
+
+	private static _handlePool: number = 0;
+	readonly handle = ExtHostNotebookDocument._handlePool++;
+
+	private _cells: ExtHostCell[] = [];
+
+	private _cellDisposableMapping = new Map<number, DisposableStore>();
+
+	private _notebook: vscode.NotebookDocument | undefined;
+	private _metadata: Required<vscode.NotebookDocumentMetadata>;
+	private _metadataChangeListener: IDisposable;
+	private _versionId = 0;
+	private _isDirty: boolean = false;
+	private _backupCounter = 1;
+	private _backup?: vscode.NotebookDocumentBackup;
+	private _disposed = false;
+	private _languages: string[] = [];
+
+	private readonly _edits = new Cache<vscode.NotebookDocumentEditEvent>('notebook documents');
+
+	constructor(
+		private readonly _proxy: MainThreadNotebookShape,
+		private readonly _documentsAndEditors: ExtHostDocumentsAndEditors,
+		private readonly _mainThreadBulkEdits: MainThreadBulkEditsShape,
+		private readonly _emitter: INotebookEventEmitter,
+		private readonly _viewType: string,
+		private readonly _contentOptions: vscode.NotebookDocumentContentOptions,
+		metadata: Required<vscode.NotebookDocumentMetadata>,
+		public readonly uri: URI,
+		private readonly _storagePath: URI | undefined
+	) {
+		super();
+
+		const observableMetadata = getObservable(metadata);
+		this._metadata = observableMetadata.proxy;
+		this._metadataChangeListener = this._register(observableMetadata.onDidChange(() => {
+			this._tryUpdateMetadata();
+		}));
+	}
+
+	dispose() {
+		this._disposed = true;
+		super.dispose();
+		dispose(this._cellDisposableMapping.values());
+	}
+
+	private _updateMetadata(newMetadata: Required<vscode.NotebookDocumentMetadata>) {
+		this._metadataChangeListener.dispose();
+		newMetadata = {
+			...notebookDocumentMetadataDefaults,
+			...newMetadata
+		};
+		if (this._metadataChangeListener) {
+			this._metadataChangeListener.dispose();
+		}
+
+		const observableMetadata = getObservable(newMetadata);
+		this._metadata = observableMetadata.proxy;
+		this._metadataChangeListener = this._register(observableMetadata.onDidChange(() => {
+			this._tryUpdateMetadata();
+		}));
+
+		this._tryUpdateMetadata();
+	}
+
+	private _tryUpdateMetadata() {
+		const edit: IWorkspaceCellEditDto = {
+			_type: WorkspaceEditType.Cell,
+			metadata: undefined,
+			edit: { editType: CellEditType.DocumentMetadata, metadata: this._metadata },
+			resource: this.uri,
+			notebookVersionId: this.notebookDocument.version,
+		};
+
+		return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit({ edits: [edit] });
+	}
+
+	get notebookDocument(): vscode.NotebookDocument {
+		if (!this._notebook) {
+			const that = this;
+			this._notebook = Object.freeze({
+				get uri() { return that.uri; },
+				get version() { return that._versionId; },
+				get fileName() { return that.uri.fsPath; },
+				get viewType() { return that._viewType; },
+				get isDirty() { return that._isDirty; },
+				get isUntitled() { return that.uri.scheme === Schemas.untitled; },
+				get cells(): ReadonlyArray<vscode.NotebookCell> { return that._cells.map(cell => cell.cell); },
+				get languages() { return that._languages; },
+				set languages(value: string[]) { that._trySetLanguages(value); },
+				get metadata() { return that._metadata; },
+				set metadata(value: Required<vscode.NotebookDocumentMetadata>) { that._updateMetadata(value); },
+				get contentOptions() { return that._contentOptions; }
+			});
+		}
+		return this._notebook;
+	}
+
+	private _trySetLanguages(newLanguages: string[]) {
+		this._languages = newLanguages;
+		this._proxy.$updateNotebookLanguages(this._viewType, this.uri, this._languages);
+	}
+
+	getNewBackupUri(): URI {
+		if (!this._storagePath) {
+			throw new Error('Backup requires a valid storage path');
+		}
+		const fileName = hashPath(this.uri) + (this._backupCounter++);
+		return joinPath(this._storagePath, fileName);
+	}
+
+	updateBackup(backup: vscode.NotebookDocumentBackup): void {
+		this._backup?.delete();
+		this._backup = backup;
+	}
+
+	disposeBackup(): void {
+		this._backup?.delete();
+		this._backup = undefined;
+	}
+
+	acceptDocumentPropertiesChanged(data: INotebookDocumentPropertiesChangeData) {
+		const newMetadata = {
+			...notebookDocumentMetadataDefaults,
+			...data.metadata
+		};
+
+		if (this._metadataChangeListener) {
+			this._metadataChangeListener.dispose();
+		}
+
+		const observableMetadata = getObservable(newMetadata);
+		this._metadata = observableMetadata.proxy;
+		this._metadataChangeListener = this._register(observableMetadata.onDidChange(() => {
+			this._tryUpdateMetadata();
+		}));
+
+		this._emitter.emitDocumentMetadataChange({ document: this.notebookDocument });
+	}
+
+	acceptModelChanged(event: NotebookCellsChangedEventDto, isDirty: boolean): void {
+		this._versionId = event.versionId;
+		this._isDirty = isDirty;
+		event.rawEvents.forEach(e => {
+			if (e.kind === NotebookCellsChangeType.Initialize) {
+				this._spliceNotebookCells(e.changes, true);
+			} if (e.kind === NotebookCellsChangeType.ModelChange) {
+				this._spliceNotebookCells(e.changes, false);
+			} else if (e.kind === NotebookCellsChangeType.Move) {
+				this._moveCell(e.index, e.newIdx);
+			} else if (e.kind === NotebookCellsChangeType.Output) {
+				this._setCellOutputs(e.index, e.outputs);
+			} else if (e.kind === NotebookCellsChangeType.ChangeLanguage) {
+				this._changeCellLanguage(e.index, e.language);
+			} else if (e.kind === NotebookCellsChangeType.ChangeCellMetadata) {
+				this._changeCellMetadata(e.index, e.metadata);
+			}
+		});
+	}
+
+	private _spliceNotebookCells(splices: NotebookCellsSplice2[], initialization: boolean): void {
+		if (this._disposed) {
+			return;
+		}
+
+		const contentChangeEvents: RawContentChangeEvent[] = [];
+		const addedCellDocuments: IExtHostModelAddedData[] = [];
+		const removedCellDocuments: URI[] = [];
+
+		splices.reverse().forEach(splice => {
+			const cellDtos = splice[2];
+			const newCells = cellDtos.map(cell => {
+
+				const extCell = new ExtHostCell(this._mainThreadBulkEdits, this, this._documentsAndEditors, cell);
+
+				if (!initialization) {
+					addedCellDocuments.push(ExtHostCell.asModelAddData(this.notebookDocument, cell));
+				}
+
+				if (!this._cellDisposableMapping.has(extCell.handle)) {
+					const store = new DisposableStore();
+					store.add(extCell);
+					this._cellDisposableMapping.set(extCell.handle, store);
+				}
+
+				const store = this._cellDisposableMapping.get(extCell.handle)!;
+
+				store.add(extCell.onDidChangeOutputs((diffs) => {
+					this.eventuallyUpdateCellOutputs(extCell, diffs);
+				}));
+
+				return extCell;
+			});
+
+			for (let j = splice[0]; j < splice[0] + splice[1]; j++) {
+				this._cellDisposableMapping.get(this._cells[j].handle)?.dispose();
+				this._cellDisposableMapping.delete(this._cells[j].handle);
+			}
+
+			const deletedItems = this._cells.splice(splice[0], splice[1], ...newCells);
+			for (let cell of deletedItems) {
+				removedCellDocuments.push(cell.uri);
+			}
+
+			contentChangeEvents.push(new RawContentChangeEvent(splice[0], splice[1], deletedItems, newCells));
+		});
+
+		this._documentsAndEditors.acceptDocumentsAndEditorsDelta({
+			addedDocuments: addedCellDocuments,
+			removedDocuments: removedCellDocuments
+		});
+
+		if (!initialization) {
+			this._emitter.emitModelChange({
+				document: this.notebookDocument,
+				changes: contentChangeEvents.map(RawContentChangeEvent.asApiEvent)
+			});
+		}
+	}
+
+	private _moveCell(index: number, newIdx: number): void {
+		const cells = this._cells.splice(index, 1);
+		this._cells.splice(newIdx, 0, ...cells);
+		const changes: vscode.NotebookCellsChangeData[] = [{
+			start: index,
+			deletedCount: 1,
+			deletedItems: cells.map(data => data.cell),
+			items: []
+		}, {
+			start: newIdx,
+			deletedCount: 0,
+			deletedItems: [],
+			items: cells.map(data => data.cell)
+		}];
+		this._emitter.emitModelChange({
+			document: this.notebookDocument,
+			changes
+		});
+	}
+
+	private _setCellOutputs(index: number, outputs: IProcessedOutput[]): void {
+		const cell = this._cells[index];
+		cell.setOutputs(outputs);
+		this._emitter.emitCellOutputsChange({ document: this.notebookDocument, cells: [cell.cell] });
+	}
+
+	private _changeCellLanguage(index: number, language: string): void {
+		const cell = this._cells[index];
+		const event: vscode.NotebookCellLanguageChangeEvent = { document: this.notebookDocument, cell: cell.cell, language };
+		this._emitter.emitCellLanguageChange(event);
+	}
+
+	private _changeCellMetadata(index: number, newMetadata: NotebookCellMetadata | undefined): void {
+		const cell = this._cells[index];
+		cell.setMetadata(newMetadata || {});
+		const event: vscode.NotebookCellMetadataChangeEvent = { document: this.notebookDocument, cell: cell.cell };
+		this._emitter.emitCellMetadataChange(event);
+	}
+
+	async eventuallyUpdateCellOutputs(cell: ExtHostCell, diffs: ISplice<IProcessedOutput>[]) {
+		const outputDtos: NotebookCellOutputsSplice[] = diffs.map(diff => {
+			const outputs = diff.toInsert;
+			return [diff.start, diff.deleteCount, outputs];
+		});
+
+		if (!outputDtos.length) {
+			return;
+		}
+
+		await this._proxy.$spliceNotebookCellOutputs(this._viewType, this.uri, cell.handle, outputDtos);
+		this._emitter.emitCellOutputsChange({
+			document: this.notebookDocument,
+			cells: [cell.cell]
+		});
+	}
+
+	getCell(cellHandle: number): ExtHostCell | undefined {
+		return this._cells.find(cell => cell.handle === cellHandle);
+	}
+
+	getCellIndex(cell: ExtHostCell): number {
+		return this._cells.indexOf(cell);
+	}
+
+	addEdit(item: vscode.NotebookDocumentEditEvent): number {
+		return this._edits.add([item]);
+	}
+
+	async undo(editId: number, isDirty: boolean): Promise<void> {
+		await this.getEdit(editId).undo();
+		// if (!isDirty) {
+		// 	this.disposeBackup();
+		// }
+	}
+
+	async redo(editId: number, isDirty: boolean): Promise<void> {
+		await this.getEdit(editId).redo();
+		// if (!isDirty) {
+		// 	this.disposeBackup();
+		// }
+	}
+
+	private getEdit(editId: number): vscode.NotebookDocumentEditEvent {
+		const edit = this._edits.get(editId, 0);
+		if (!edit) {
+			throw new Error('No edit found');
+		}
+
+		return edit;
+	}
+
+	disposeEdits(editIds: number[]): void {
+		for (const id of editIds) {
+			this._edits.delete(id);
+		}
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostNotebookEditor.ts

@@ -0,0 +1,260 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { readonly } from 'vs/base/common/errors';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { MainThreadNotebookShape } from 'vs/workbench/api/common/extHost.protocol';
+import * as extHostTypes from 'vs/workbench/api/common/extHostTypes';
+import { addIdToOutput, CellEditType, ICellEditOperation, ICellReplaceEdit, INotebookEditData, notebookDocumentMetadataDefaults } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import * as vscode from 'vscode';
+import { ExtHostNotebookDocument } from './extHostNotebookDocument';
+
+class NotebookEditorCellEditBuilder implements vscode.NotebookEditorEdit {
+
+	private readonly _documentVersionId: number;
+
+	private _finalized: boolean = false;
+	private _collectedEdits: ICellEditOperation[] = [];
+
+	constructor(documentVersionId: number) {
+		this._documentVersionId = documentVersionId;
+	}
+
+	finalize(): INotebookEditData {
+		this._finalized = true;
+		return {
+			documentVersionId: this._documentVersionId,
+			cellEdits: this._collectedEdits
+		};
+	}
+
+	private _throwIfFinalized() {
+		if (this._finalized) {
+			throw new Error('Edit is only valid while callback runs');
+		}
+	}
+
+	replaceMetadata(value: vscode.NotebookDocumentMetadata): void {
+		this._throwIfFinalized();
+		this._collectedEdits.push({
+			editType: CellEditType.DocumentMetadata,
+			metadata: { ...notebookDocumentMetadataDefaults, ...value }
+		});
+	}
+
+	replaceCellMetadata(index: number, metadata: vscode.NotebookCellMetadata): void {
+		this._throwIfFinalized();
+		this._collectedEdits.push({
+			editType: CellEditType.Metadata,
+			index,
+			metadata
+		});
+	}
+
+	replaceCellOutput(index: number, outputs: (vscode.NotebookCellOutput | vscode.CellOutput)[]): void {
+		this._throwIfFinalized();
+		this._collectedEdits.push({
+			editType: CellEditType.Output,
+			index,
+			outputs: outputs.map(output => {
+				if (extHostTypes.NotebookCellOutput.isNotebookCellOutput(output)) {
+					return addIdToOutput(output.toJSON());
+				} else {
+					return addIdToOutput(output);
+				}
+			})
+		});
+	}
+
+	replaceCells(from: number, to: number, cells: vscode.NotebookCellData[]): void {
+		this._throwIfFinalized();
+		if (from === to && cells.length === 0) {
+			return;
+		}
+		this._collectedEdits.push({
+			editType: CellEditType.Replace,
+			index: from,
+			count: to - from,
+			cells: cells.map(data => {
+				return {
+					...data,
+					outputs: data.outputs.map(output => addIdToOutput(output)),
+				};
+			})
+		});
+	}
+}
+
+export class ExtHostNotebookEditor extends Disposable implements vscode.NotebookEditor {
+
+	//TODO@rebornix noop setter?
+	selection?: vscode.NotebookCell;
+
+	private _visibleRanges: vscode.NotebookCellRange[] = [];
+	private _viewColumn?: vscode.ViewColumn;
+	private _active: boolean = false;
+	private _visible: boolean = false;
+	private _kernel?: vscode.NotebookKernel;
+
+	private _onDidDispose = new Emitter<void>();
+	private _onDidReceiveMessage = new Emitter<any>();
+
+	readonly onDidDispose: Event<void> = this._onDidDispose.event;
+	readonly onDidReceiveMessage: vscode.Event<any> = this._onDidReceiveMessage.event;
+
+	private _hasDecorationsForKey: { [key: string]: boolean; } = Object.create(null);
+
+	constructor(
+		readonly id: string,
+		private readonly _viewType: string,
+		private readonly _proxy: MainThreadNotebookShape,
+		private readonly _webComm: vscode.NotebookCommunication,
+		readonly notebookData: ExtHostNotebookDocument,
+	) {
+		super();
+		this._register(this._webComm.onDidReceiveMessage(e => {
+			this._onDidReceiveMessage.fire(e);
+		}));
+	}
+
+	get viewColumn(): vscode.ViewColumn | undefined {
+		return this._viewColumn;
+	}
+
+	set viewColumn(_value) {
+		throw readonly('viewColumn');
+	}
+
+	get kernel() {
+		return this._kernel;
+	}
+
+	set kernel(_kernel: vscode.NotebookKernel | undefined) {
+		throw readonly('kernel');
+	}
+
+	_acceptKernel(kernel?: vscode.NotebookKernel) {
+		this._kernel = kernel;
+	}
+
+	get visible(): boolean {
+		return this._visible;
+	}
+
+	set visible(_state: boolean) {
+		throw readonly('visible');
+	}
+
+	_acceptVisibility(value: boolean) {
+		this._visible = value;
+	}
+
+	get visibleRanges() {
+		return this._visibleRanges;
+	}
+
+	set visibleRanges(_range: vscode.NotebookCellRange[]) {
+		throw readonly('visibleRanges');
+	}
+
+	_acceptVisibleRanges(value: vscode.NotebookCellRange[]): void {
+		this._visibleRanges = value;
+	}
+
+	get active(): boolean {
+		return this._active;
+	}
+
+	set active(_state: boolean) {
+		throw readonly('active');
+	}
+
+	_acceptActive(value: boolean) {
+		this._active = value;
+	}
+
+	get document(): vscode.NotebookDocument {
+		return this.notebookData.notebookDocument;
+	}
+
+	edit(callback: (editBuilder: NotebookEditorCellEditBuilder) => void): Thenable<boolean> {
+		const edit = new NotebookEditorCellEditBuilder(this.document.version);
+		callback(edit);
+		return this._applyEdit(edit.finalize());
+	}
+
+	private _applyEdit(editData: INotebookEditData): Promise<boolean> {
+
+		// return when there is nothing to do
+		if (editData.cellEdits.length === 0) {
+			return Promise.resolve(true);
+		}
+
+		const compressedEdits: ICellEditOperation[] = [];
+		let compressedEditsIndex = -1;
+
+		for (let i = 0; i < editData.cellEdits.length; i++) {
+			if (compressedEditsIndex < 0) {
+				compressedEdits.push(editData.cellEdits[i]);
+				compressedEditsIndex++;
+				continue;
+			}
+
+			const prevIndex = compressedEditsIndex;
+			const prev = compressedEdits[prevIndex];
+
+			if (prev.editType === CellEditType.Replace && editData.cellEdits[i].editType === CellEditType.Replace) {
+				const edit = editData.cellEdits[i];
+				if ((edit.editType !== CellEditType.DocumentMetadata && edit.editType !== CellEditType.Unknown) && prev.index === edit.index) {
+					prev.cells.push(...(editData.cellEdits[i] as ICellReplaceEdit).cells);
+					prev.count += (editData.cellEdits[i] as ICellReplaceEdit).count;
+					continue;
+				}
+			}
+
+			compressedEdits.push(editData.cellEdits[i]);
+			compressedEditsIndex++;
+		}
+
+		return this._proxy.$tryApplyEdits(this._viewType, this.document.uri, editData.documentVersionId, compressedEdits);
+	}
+
+	setDecorations(decorationType: vscode.NotebookEditorDecorationType, range: vscode.NotebookCellRange): void {
+		const willBeEmpty = (range.start === range.end);
+		if (willBeEmpty && !this._hasDecorationsForKey[decorationType.key]) {
+			// avoid no-op call to the renderer
+			return;
+		}
+		if (willBeEmpty) {
+			delete this._hasDecorationsForKey[decorationType.key];
+		} else {
+			this._hasDecorationsForKey[decorationType.key] = true;
+		}
+
+		return this._proxy.$trySetDecorations(
+			this.id,
+			range,
+			decorationType.key
+		);
+	}
+
+	revealRange(range: vscode.NotebookCellRange, revealType?: extHostTypes.NotebookEditorRevealType) {
+		this._proxy.$tryRevealRange(this.id, range, revealType || extHostTypes.NotebookEditorRevealType.Default);
+	}
+
+	async postMessage(message: any): Promise<boolean> {
+		return this._webComm.postMessage(message);
+	}
+
+	asWebviewUri(localResource: vscode.Uri): vscode.Uri {
+		return this._webComm.asWebviewUri(localResource);
+	}
+
+	dispose() {
+		this._onDidDispose.fire();
+		super.dispose();
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostOutput.ts

@@ -0,0 +1,172 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { MainContext, MainThreadOutputServiceShape, ExtHostOutputServiceShape } from './extHost.protocol';
+import type * as vscode from 'vscode';
+import { URI } from 'vs/base/common/uri';
+import { Event, Emitter } from 'vs/base/common/event';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
+
+export abstract class AbstractExtHostOutputChannel extends Disposable implements vscode.OutputChannel {
+
+	readonly _id: Promise<string>;
+	private readonly _name: string;
+	protected readonly _proxy: MainThreadOutputServiceShape;
+	private _disposed: boolean;
+	private _offset: number;
+
+	protected readonly _onDidAppend: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidAppend: Event<void> = this._onDidAppend.event;
+
+	constructor(name: string, log: boolean, file: URI | undefined, proxy: MainThreadOutputServiceShape) {
+		super();
+
+		this._name = name;
+		this._proxy = proxy;
+		this._id = proxy.$register(this.name, log, file);
+		this._disposed = false;
+		this._offset = 0;
+	}
+
+	get name(): string {
+		return this._name;
+	}
+
+	append(value: string): void {
+		this.validate();
+		this._offset += value ? VSBuffer.fromString(value).byteLength : 0;
+	}
+
+	update(): void {
+		this._id.then(id => this._proxy.$update(id));
+	}
+
+	appendLine(value: string): void {
+		this.validate();
+		this.append(value + '\n');
+	}
+
+	clear(): void {
+		this.validate();
+		const till = this._offset;
+		this._id.then(id => this._proxy.$clear(id, till));
+	}
+
+	show(columnOrPreserveFocus?: vscode.ViewColumn | boolean, preserveFocus?: boolean): void {
+		this.validate();
+		this._id.then(id => this._proxy.$reveal(id, !!(typeof columnOrPreserveFocus === 'boolean' ? columnOrPreserveFocus : preserveFocus)));
+	}
+
+	hide(): void {
+		this.validate();
+		this._id.then(id => this._proxy.$close(id));
+	}
+
+	protected validate(): void {
+		if (this._disposed) {
+			throw new Error('Channel has been closed');
+		}
+	}
+
+	dispose(): void {
+		super.dispose();
+
+		if (!this._disposed) {
+			this._id
+				.then(id => this._proxy.$dispose(id))
+				.then(() => this._disposed = true);
+		}
+	}
+}
+
+export class ExtHostPushOutputChannel extends AbstractExtHostOutputChannel {
+
+	constructor(name: string, proxy: MainThreadOutputServiceShape) {
+		super(name, false, undefined, proxy);
+	}
+
+	append(value: string): void {
+		super.append(value);
+		this._id.then(id => this._proxy.$append(id, value));
+		this._onDidAppend.fire();
+	}
+}
+
+class ExtHostLogFileOutputChannel extends AbstractExtHostOutputChannel {
+
+	constructor(name: string, file: URI, proxy: MainThreadOutputServiceShape) {
+		super(name, true, file, proxy);
+	}
+
+	append(value: string): void {
+		throw new Error('Not supported');
+	}
+}
+
+export class LazyOutputChannel implements vscode.OutputChannel {
+
+	constructor(
+		readonly name: string,
+		private readonly _channel: Promise<AbstractExtHostOutputChannel>
+	) { }
+
+	append(value: string): void {
+		this._channel.then(channel => channel.append(value));
+	}
+	appendLine(value: string): void {
+		this._channel.then(channel => channel.appendLine(value));
+	}
+	clear(): void {
+		this._channel.then(channel => channel.clear());
+	}
+	show(columnOrPreserveFocus?: vscode.ViewColumn | boolean, preserveFocus?: boolean): void {
+		this._channel.then(channel => channel.show(columnOrPreserveFocus, preserveFocus));
+	}
+	hide(): void {
+		this._channel.then(channel => channel.hide());
+	}
+	dispose(): void {
+		this._channel.then(channel => channel.dispose());
+	}
+}
+
+export class ExtHostOutputService implements ExtHostOutputServiceShape {
+
+	readonly _serviceBrand: undefined;
+
+	protected readonly _proxy: MainThreadOutputServiceShape;
+
+	constructor(@IExtHostRpcService extHostRpc: IExtHostRpcService) {
+		this._proxy = extHostRpc.getProxy(MainContext.MainThreadOutputService);
+	}
+
+	$setVisibleChannel(channelId: string): void {
+	}
+
+	createOutputChannel(name: string): vscode.OutputChannel {
+		name = name.trim();
+		if (!name) {
+			throw new Error('illegal argument `name`. must not be falsy');
+		}
+		return new ExtHostPushOutputChannel(name, this._proxy);
+	}
+
+	createOutputChannelFromLogFile(name: string, file: URI): vscode.OutputChannel {
+		name = name.trim();
+		if (!name) {
+			throw new Error('illegal argument `name`. must not be falsy');
+		}
+		if (!file) {
+			throw new Error('illegal argument `file`. must not be falsy');
+		}
+		return new ExtHostLogFileOutputChannel(name, file, this._proxy);
+	}
+}
+
+export interface IExtHostOutputService extends ExtHostOutputService { }
+export const IExtHostOutputService = createDecorator<IExtHostOutputService>('IExtHostOutputService');

lib/vscode/src/vs/workbench/api/common/extHostProgress.ts

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ProgressOptions } from 'vscode';
+import { MainThreadProgressShape, ExtHostProgressShape } from './extHost.protocol';
+import { ProgressLocation } from './extHostTypeConverters';
+import { Progress, IProgressStep } from 'vs/platform/progress/common/progress';
+import { localize } from 'vs/nls';
+import { CancellationTokenSource, CancellationToken } from 'vs/base/common/cancellation';
+import { throttle } from 'vs/base/common/decorators';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+
+export class ExtHostProgress implements ExtHostProgressShape {
+
+	private _proxy: MainThreadProgressShape;
+	private _handles: number = 0;
+	private _mapHandleToCancellationSource: Map<number, CancellationTokenSource> = new Map();
+
+	constructor(proxy: MainThreadProgressShape) {
+		this._proxy = proxy;
+	}
+
+	withProgress<R>(extension: IExtensionDescription, options: ProgressOptions, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Thenable<R> {
+		const handle = this._handles++;
+		const { title, location, cancellable } = options;
+		const source = localize('extensionSource', "{0} (Extension)", extension.displayName || extension.name);
+
+		this._proxy.$startProgress(handle, { location: ProgressLocation.from(location), title, source, cancellable }, extension);
+		return this._withProgress(handle, task, !!cancellable);
+	}
+
+	private _withProgress<R>(handle: number, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>, cancellable: boolean): Thenable<R> {
+		let source: CancellationTokenSource | undefined;
+		if (cancellable) {
+			source = new CancellationTokenSource();
+			this._mapHandleToCancellationSource.set(handle, source);
+		}
+
+		const progressEnd = (handle: number): void => {
+			this._proxy.$progressEnd(handle);
+			this._mapHandleToCancellationSource.delete(handle);
+			if (source) {
+				source.dispose();
+			}
+		};
+
+		let p: Thenable<R>;
+
+		try {
+			p = task(new ProgressCallback(this._proxy, handle), cancellable && source ? source.token : CancellationToken.None);
+		} catch (err) {
+			progressEnd(handle);
+			throw err;
+		}
+
+		p.then(result => progressEnd(handle), err => progressEnd(handle));
+		return p;
+	}
+
+	public $acceptProgressCanceled(handle: number): void {
+		const source = this._mapHandleToCancellationSource.get(handle);
+		if (source) {
+			source.cancel();
+			this._mapHandleToCancellationSource.delete(handle);
+		}
+	}
+}
+
+function mergeProgress(result: IProgressStep, currentValue: IProgressStep): IProgressStep {
+	result.message = currentValue.message;
+	if (typeof currentValue.increment === 'number') {
+		if (typeof result.increment === 'number') {
+			result.increment += currentValue.increment;
+		} else {
+			result.increment = currentValue.increment;
+		}
+	}
+
+	return result;
+}
+
+class ProgressCallback extends Progress<IProgressStep> {
+	constructor(private _proxy: MainThreadProgressShape, private _handle: number) {
+		super(p => this.throttledReport(p));
+	}
+
+	@throttle(100, (result: IProgressStep, currentValue: IProgressStep) => mergeProgress(result, currentValue), () => Object.create(null))
+	throttledReport(p: IProgressStep): void {
+		this._proxy.$progressReport(this._handle, p);
+	}
+}

lib/vscode/src/vs/workbench/api/common/extHostQuickOpen.ts

@@ -0,0 +1,617 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { asPromise } from 'vs/base/common/async';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { Emitter } from 'vs/base/common/event';
+import { dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { IExtHostWorkspaceProvider } from 'vs/workbench/api/common/extHostWorkspace';
+import { InputBox, InputBoxOptions, QuickInput, QuickInputButton, QuickPick, QuickPickItem, QuickPickOptions, WorkspaceFolder, WorkspaceFolderPickOptions } from 'vscode';
+import { ExtHostQuickOpenShape, IMainContext, MainContext, MainThreadQuickOpenShape, TransferQuickPickItems, TransferQuickInput, TransferQuickInputButton } from './extHost.protocol';
+import { URI } from 'vs/base/common/uri';
+import { ThemeIcon, QuickInputButtons } from 'vs/workbench/api/common/extHostTypes';
+import { isPromiseCanceledError } from 'vs/base/common/errors';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { coalesce } from 'vs/base/common/arrays';
+
+export type Item = string | QuickPickItem;
+
+export class ExtHostQuickOpen implements ExtHostQuickOpenShape {
+
+	private _proxy: MainThreadQuickOpenShape;
+	private _workspace: IExtHostWorkspaceProvider;
+	private _commands: ExtHostCommands;
+
+	private _onDidSelectItem?: (handle: number) => void;
+	private _validateInput?: (input: string) => string | undefined | null | Thenable<string | undefined | null>;
+
+	private _sessions = new Map<number, ExtHostQuickInput>();
+
+	private _instances = 0;
+
+	constructor(mainContext: IMainContext, workspace: IExtHostWorkspaceProvider, commands: ExtHostCommands) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadQuickOpen);
+		this._workspace = workspace;
+		this._commands = commands;
+	}
+
+	showQuickPick(itemsOrItemsPromise: QuickPickItem[] | Promise<QuickPickItem[]>, enableProposedApi: boolean, options: QuickPickOptions & { canPickMany: true; }, token?: CancellationToken): Promise<QuickPickItem[] | undefined>;
+	showQuickPick(itemsOrItemsPromise: string[] | Promise<string[]>, enableProposedApi: boolean, options?: QuickPickOptions, token?: CancellationToken): Promise<string | undefined>;
+	showQuickPick(itemsOrItemsPromise: QuickPickItem[] | Promise<QuickPickItem[]>, enableProposedApi: boolean, options?: QuickPickOptions, token?: CancellationToken): Promise<QuickPickItem | undefined>;
+	showQuickPick(itemsOrItemsPromise: Item[] | Promise<Item[]>, enableProposedApi: boolean, options?: QuickPickOptions, token: CancellationToken = CancellationToken.None): Promise<Item | Item[] | undefined> {
+
+		// clear state from last invocation
+		this._onDidSelectItem = undefined;
+
+		const itemsPromise = <Promise<Item[]>>Promise.resolve(itemsOrItemsPromise);
+
+		const instance = ++this._instances;
+
+		const quickPickWidget = this._proxy.$show(instance, {
+			placeHolder: options && options.placeHolder,
+			matchOnDescription: options && options.matchOnDescription,
+			matchOnDetail: options && options.matchOnDetail,
+			ignoreFocusLost: options && options.ignoreFocusOut,
+			canPickMany: options && options.canPickMany
+		}, token);
+
+		const widgetClosedMarker = {};
+		const widgetClosedPromise = quickPickWidget.then(() => widgetClosedMarker);
+
+		return Promise.race([widgetClosedPromise, itemsPromise]).then(result => {
+			if (result === widgetClosedMarker) {
+				return undefined;
+			}
+
+			return itemsPromise.then(items => {
+
+				const pickItems: TransferQuickPickItems[] = [];
+				for (let handle = 0; handle < items.length; handle++) {
+
+					const item = items[handle];
+					let label: string;
+					let description: string | undefined;
+					let detail: string | undefined;
+					let picked: boolean | undefined;
+					let alwaysShow: boolean | undefined;
+
+					if (typeof item === 'string') {
+						label = item;
+					} else {
+						label = item.label;
+						description = item.description;
+						detail = item.detail;
+						picked = item.picked;
+						alwaysShow = item.alwaysShow;
+					}
+					pickItems.push({
+						label,
+						description,
+						handle,
+						detail,
+						picked,
+						alwaysShow
+					});
+				}
+
+				// handle selection changes
+				if (options && typeof options.onDidSelectItem === 'function') {
+					this._onDidSelectItem = (handle) => {
+						options.onDidSelectItem!(items[handle]);
+					};
+				}
+
+				// show items
+				this._proxy.$setItems(instance, pickItems);
+
+				return quickPickWidget.then(handle => {
+					if (typeof handle === 'number') {
+						return items[handle];
+					} else if (Array.isArray(handle)) {
+						return handle.map(h => items[h]);
+					}
+					return undefined;
+				});
+			});
+		}).then(undefined, err => {
+			if (isPromiseCanceledError(err)) {
+				return undefined;
+			}
+
+			this._proxy.$setError(instance, err);
+
+			return Promise.reject(err);
+		});
+	}
+
+	$onItemSelected(handle: number): void {
+		if (this._onDidSelectItem) {
+			this._onDidSelectItem(handle);
+		}
+	}
+
+	// ---- input
+
+	showInput(options?: InputBoxOptions, token: CancellationToken = CancellationToken.None): Promise<string | undefined> {
+
+		// global validate fn used in callback below
+		this._validateInput = options ? options.validateInput : undefined;
+
+		return this._proxy.$input(options, typeof this._validateInput === 'function', token)
+			.then(undefined, err => {
+				if (isPromiseCanceledError(err)) {
+					return undefined;
+				}
+
+				return Promise.reject(err);
+			});
+	}
+
+	$validateInput(input: string): Promise<string | null | undefined> {
+		if (this._validateInput) {
+			return asPromise(() => this._validateInput!(input));
+		}
+		return Promise.resolve(undefined);
+	}
+
+	// ---- workspace folder picker
+
+	async showWorkspaceFolderPick(options?: WorkspaceFolderPickOptions, token = CancellationToken.None): Promise<WorkspaceFolder | undefined> {
+		const selectedFolder = await this._commands.executeCommand<WorkspaceFolder>('_workbench.pickWorkspaceFolder', [options]);
+		if (!selectedFolder) {
+			return undefined;
+		}
+		const workspaceFolders = await this._workspace.getWorkspaceFolders2();
+		if (!workspaceFolders) {
+			return undefined;
+		}
+		return workspaceFolders.find(folder => folder.uri.toString() === selectedFolder.uri.toString());
+	}
+
+	// ---- QuickInput
+
+	createQuickPick<T extends QuickPickItem>(extensionId: ExtensionIdentifier, enableProposedApi: boolean): QuickPick<T> {
+		const session: ExtHostQuickPick<T> = new ExtHostQuickPick(this._proxy, extensionId, enableProposedApi, () => this._sessions.delete(session._id));
+		this._sessions.set(session._id, session);
+		return session;
+	}
+
+	createInputBox(extensionId: ExtensionIdentifier): InputBox {
+		const session: ExtHostInputBox = new ExtHostInputBox(this._proxy, extensionId, () => this._sessions.delete(session._id));
+		this._sessions.set(session._id, session);
+		return session;
+	}
+
+	$onDidChangeValue(sessionId: number, value: string): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session._fireDidChangeValue(value);
+		}
+	}
+
+	$onDidAccept(sessionId: number): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session._fireDidAccept();
+		}
+	}
+
+	$onDidChangeActive(sessionId: number, handles: number[]): void {
+		const session = this._sessions.get(sessionId);
+		if (session instanceof ExtHostQuickPick) {
+			session._fireDidChangeActive(handles);
+		}
+	}
+
+	$onDidChangeSelection(sessionId: number, handles: number[]): void {
+		const session = this._sessions.get(sessionId);
+		if (session instanceof ExtHostQuickPick) {
+			session._fireDidChangeSelection(handles);
+		}
+	}
+
+	$onDidTriggerButton(sessionId: number, handle: number): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session._fireDidTriggerButton(handle);
+		}
+	}
+
+	$onDidHide(sessionId: number): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session._fireDidHide();
+		}
+	}
+}
+
+class ExtHostQuickInput implements QuickInput {
+
+	private static _nextId = 1;
+	_id = ExtHostQuickPick._nextId++;
+
+	private _title: string | undefined;
+	private _steps: number | undefined;
+	private _totalSteps: number | undefined;
+	private _visible = false;
+	private _expectingHide = false;
+	private _enabled = true;
+	private _busy = false;
+	private _ignoreFocusOut = true;
+	private _value = '';
+	private _placeholder: string | undefined;
+	private _buttons: QuickInputButton[] = [];
+	private _handlesToButtons = new Map<number, QuickInputButton>();
+	private readonly _onDidAcceptEmitter = new Emitter<void>();
+	private readonly _onDidChangeValueEmitter = new Emitter<string>();
+	private readonly _onDidTriggerButtonEmitter = new Emitter<QuickInputButton>();
+	private readonly _onDidHideEmitter = new Emitter<void>();
+	private _updateTimeout: any;
+	private _pendingUpdate: TransferQuickInput = { id: this._id };
+
+	private _disposed = false;
+	protected _disposables: IDisposable[] = [
+		this._onDidTriggerButtonEmitter,
+		this._onDidHideEmitter,
+		this._onDidAcceptEmitter,
+		this._onDidChangeValueEmitter
+	];
+
+	constructor(protected _proxy: MainThreadQuickOpenShape, protected _extensionId: ExtensionIdentifier, private _onDidDispose: () => void) {
+	}
+
+	get title() {
+		return this._title;
+	}
+
+	set title(title: string | undefined) {
+		this._title = title;
+		this.update({ title });
+	}
+
+	get step() {
+		return this._steps;
+	}
+
+	set step(step: number | undefined) {
+		this._steps = step;
+		this.update({ step });
+	}
+
+	get totalSteps() {
+		return this._totalSteps;
+	}
+
+	set totalSteps(totalSteps: number | undefined) {
+		this._totalSteps = totalSteps;
+		this.update({ totalSteps });
+	}
+
+	get enabled() {
+		return this._enabled;
+	}
+
+	set enabled(enabled: boolean) {
+		this._enabled = enabled;
+		this.update({ enabled });
+	}
+
+	get busy() {
+		return this._busy;
+	}
+
+	set busy(busy: boolean) {
+		this._busy = busy;
+		this.update({ busy });
+	}
+
+	get ignoreFocusOut() {
+		return this._ignoreFocusOut;
+	}
+
+	set ignoreFocusOut(ignoreFocusOut: boolean) {
+		this._ignoreFocusOut = ignoreFocusOut;
+		this.update({ ignoreFocusOut });
+	}
+
+	get value() {
+		return this._value;
+	}
+
+	set value(value: string) {
+		this._value = value;
+		this.update({ value });
+	}
+
+	get placeholder() {
+		return this._placeholder;
+	}
+
+	set placeholder(placeholder: string | undefined) {
+		this._placeholder = placeholder;
+		this.update({ placeholder });
+	}
+
+	onDidChangeValue = this._onDidChangeValueEmitter.event;
+
+	onDidAccept = this._onDidAcceptEmitter.event;
+
+	get buttons() {
+		return this._buttons;
+	}
+
+	set buttons(buttons: QuickInputButton[]) {
+		this._buttons = buttons.slice();
+		this._handlesToButtons.clear();
+		buttons.forEach((button, i) => {
+			const handle = button === QuickInputButtons.Back ? -1 : i;
+			this._handlesToButtons.set(handle, button);
+		});
+		this.update({
+			buttons: buttons.map<TransferQuickInputButton>((button, i) => ({
+				iconPath: getIconUris(button.iconPath),
+				tooltip: button.tooltip,
+				handle: button === QuickInputButtons.Back ? -1 : i,
+			}))
+		});
+	}
+
+	onDidTriggerButton = this._onDidTriggerButtonEmitter.event;
+
+	show(): void {
+		this._visible = true;
+		this._expectingHide = true;
+		this.update({ visible: true });
+	}
+
+	hide(): void {
+		this._visible = false;
+		this.update({ visible: false });
+	}
+
+	onDidHide = this._onDidHideEmitter.event;
+
+	_fireDidAccept() {
+		this._onDidAcceptEmitter.fire();
+	}
+
+	_fireDidChangeValue(value: string) {
+		this._value = value;
+		this._onDidChangeValueEmitter.fire(value);
+	}
+
+	_fireDidTriggerButton(handle: number) {
+		const button = this._handlesToButtons.get(handle);
+		if (button) {
+			this._onDidTriggerButtonEmitter.fire(button);
+		}
+	}
+
+	_fireDidHide() {
+		if (this._expectingHide) {
+			this._expectingHide = false;
+			this._onDidHideEmitter.fire();
+		}
+	}
+
+	dispose(): void {
+		if (this._disposed) {
+			return;
+		}
+		this._disposed = true;
+		this._fireDidHide();
+		this._disposables = dispose(this._disposables);
+		if (this._updateTimeout) {
+			clearTimeout(this._updateTimeout);
+			this._updateTimeout = undefined;
+		}
+		this._onDidDispose();
+		this._proxy.$dispose(this._id);
+	}
+
+	protected update(properties: Record<string, any>): void {
+		if (this._disposed) {
+			return;
+		}
+		for (const key of Object.keys(properties)) {
+			const value = properties[key];
+			this._pendingUpdate[key] = value === undefined ? null : value;
+		}
+
+		if ('visible' in this._pendingUpdate) {
+			if (this._updateTimeout) {
+				clearTimeout(this._updateTimeout);
+				this._updateTimeout = undefined;
+			}
+			this.dispatchUpdate();
+		} else if (this._visible && !this._updateTimeout) {
+			// Defer the update so that multiple changes to setters dont cause a redraw each
+			this._updateTimeout = setTimeout(() => {
+				this._updateTimeout = undefined;
+				this.dispatchUpdate();
+			}, 0);
+		}
+	}
+
+	private dispatchUpdate() {
+		this._proxy.$createOrUpdate(this._pendingUpdate);
+		this._pendingUpdate = { id: this._id };
+	}
+}
+
+function getIconUris(iconPath: QuickInputButton['iconPath']): { dark: URI, light?: URI } | { id: string } {
+	if (iconPath instanceof ThemeIcon) {
+		return { id: iconPath.id };
+	}
+	const dark = getDarkIconUri(iconPath as URI | { light: URI; dark: URI; });
+	const light = getLightIconUri(iconPath as URI | { light: URI; dark: URI; });
+	return { dark, light };
+}
+
+function getLightIconUri(iconPath: URI | { light: URI; dark: URI; }) {
+	return typeof iconPath === 'object' && 'light' in iconPath ? iconPath.light : iconPath;
+}
+
+function getDarkIconUri(iconPath: URI | { light: URI; dark: URI; }) {
+	return typeof iconPath === 'object' && 'dark' in iconPath ? iconPath.dark : iconPath;
+}
+
+class ExtHostQuickPick<T extends QuickPickItem> extends ExtHostQuickInput implements QuickPick<T> {
+
+	private _items: T[] = [];
+	private _handlesToItems = new Map<number, T>();
+	private _itemsToHandles = new Map<T, number>();
+	private _canSelectMany = false;
+	private _matchOnDescription = true;
+	private _matchOnDetail = true;
+	private _sortByLabel = true;
+	private _activeItems: T[] = [];
+	private readonly _onDidChangeActiveEmitter = new Emitter<T[]>();
+	private _selectedItems: T[] = [];
+	private readonly _onDidChangeSelectionEmitter = new Emitter<T[]>();
+
+	constructor(proxy: MainThreadQuickOpenShape, extensionId: ExtensionIdentifier, enableProposedApi: boolean, onDispose: () => void) {
+		super(proxy, extensionId, onDispose);
+		this._disposables.push(
+			this._onDidChangeActiveEmitter,
+			this._onDidChangeSelectionEmitter,
+		);
+		this.update({ type: 'quickPick' });
+	}
+
+	get items() {
+		return this._items;
+	}
+
+	set items(items: T[]) {
+		this._items = items.slice();
+		this._handlesToItems.clear();
+		this._itemsToHandles.clear();
+		items.forEach((item, i) => {
+			this._handlesToItems.set(i, item);
+			this._itemsToHandles.set(item, i);
+		});
+		this.update({
+			items: items.map((item, i) => ({
+				label: item.label,
+				description: item.description,
+				handle: i,
+				detail: item.detail,
+				picked: item.picked,
+				alwaysShow: item.alwaysShow
+			}))
+		});
+	}
+
+	get canSelectMany() {
+		return this._canSelectMany;
+	}
+
+	set canSelectMany(canSelectMany: boolean) {
+		this._canSelectMany = canSelectMany;
+		this.update({ canSelectMany });
+	}
+
+	get matchOnDescription() {
+		return this._matchOnDescription;
+	}
+
+	set matchOnDescription(matchOnDescription: boolean) {
+		this._matchOnDescription = matchOnDescription;
+		this.update({ matchOnDescription });
+	}
+
+	get matchOnDetail() {
+		return this._matchOnDetail;
+	}
+
+	set matchOnDetail(matchOnDetail: boolean) {
+		this._matchOnDetail = matchOnDetail;
+		this.update({ matchOnDetail });
+	}
+
+	get sortByLabel() {
+		return this._sortByLabel;
+	}
+
+	set sortByLabel(sortByLabel: boolean) {
+		this._sortByLabel = sortByLabel;
+		this.update({ sortByLabel });
+	}
+
+	get activeItems() {
+		return this._activeItems;
+	}
+
+	set activeItems(activeItems: T[]) {
+		this._activeItems = activeItems.filter(item => this._itemsToHandles.has(item));
+		this.update({ activeItems: this._activeItems.map(item => this._itemsToHandles.get(item)) });
+	}
+
+	onDidChangeActive = this._onDidChangeActiveEmitter.event;
+
+	get selectedItems() {
+		return this._selectedItems;
+	}
+
+	set selectedItems(selectedItems: T[]) {
+		this._selectedItems = selectedItems.filter(item => this._itemsToHandles.has(item));
+		this.update({ selectedItems: this._selectedItems.map(item => this._itemsToHandles.get(item)) });
+	}
+
+	onDidChangeSelection = this._onDidChangeSelectionEmitter.event;
+
+	_fireDidChangeActive(handles: number[]) {
+		const items = coalesce(handles.map(handle => this._handlesToItems.get(handle)));
+		this._activeItems = items;
+		this._onDidChangeActiveEmitter.fire(items);
+	}
+
+	_fireDidChangeSelection(handles: number[]) {
+		const items = coalesce(handles.map(handle => this._handlesToItems.get(handle)));
+		this._selectedItems = items;
+		this._onDidChangeSelectionEmitter.fire(items);
+	}
+}
+
+class ExtHostInputBox extends ExtHostQuickInput implements InputBox {
+
+	private _password = false;
+	private _prompt: string | undefined;
+	private _validationMessage: string | undefined;
+
+	constructor(proxy: MainThreadQuickOpenShape, extensionId: ExtensionIdentifier, onDispose: () => void) {
+		super(proxy, extensionId, onDispose);
+		this.update({ type: 'inputBox' });
+	}
+
+	get password() {
+		return this._password;
+	}
+
+	set password(password: boolean) {
+		this._password = password;
+		this.update({ password });
+	}
+
+	get prompt() {
+		return this._prompt;
+	}
+
+	set prompt(prompt: string | undefined) {
+		this._prompt = prompt;
+		this.update({ prompt });
+	}
+
+	get validationMessage() {
+		return this._validationMessage;
+	}
+
+	set validationMessage(validationMessage: string | undefined) {
+		this._validationMessage = validationMessage;
+		this.update({ validationMessage });
+	}
+}