@codingame/monaco-vscode-api 31.0.1 → 32.0.0

package/vscode/src/vs/workbench/api/common/extHostChatInputNotification.js

@@ -0,0 +1,114 @@
+
+import { MainContext, ChatInputNotificationSeverityDto } from './extHost.protocol.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
+
+class ExtHostChatInputNotification {
+    constructor(mainContext) {
+        this._items = ( new Map());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatInputNotification));
+    }
+    createInputNotification(extension, id) {
+        const internalId = asNotificationIdentifier(extension.identifier, id);
+        if (( this._items.has(internalId))) {
+            throw ( new Error(`Chat input notification '${id}' already exists`));
+        }
+        const state = {
+            id: internalId,
+            severity: ChatInputNotificationSeverityDto.Info,
+            message: "",
+            description: undefined,
+            actions: [],
+            dismissible: true,
+            autoDismissOnMessage: false
+        };
+        let disposed = false;
+        let visible = false;
+        const syncState = () => {
+            if (disposed) {
+                throw ( new Error("Chat input notification is disposed"));
+            }
+            if (!visible) {
+                return;
+            }
+            this._proxy.$setNotification({
+                ...state
+            });
+        };
+        const item = ( Object.freeze({
+            id,
+            get severity() {
+                return state.severity;
+            },
+            set severity(value) {
+                state.severity = value;
+                syncState();
+            },
+            get message() {
+                return state.message;
+            },
+            set message(value) {
+                state.message = value;
+                syncState();
+            },
+            get description() {
+                return state.description;
+            },
+            set description(value) {
+                state.description = value;
+                syncState();
+            },
+            get actions() {
+                return state.actions;
+            },
+            set actions(value) {
+                state.actions = ( value.map(a => ({
+                    label: a.label,
+                    commandId: a.commandId,
+                    commandArgs: a.commandArgs
+                })));
+                syncState();
+            },
+            get dismissible() {
+                return state.dismissible;
+            },
+            set dismissible(value) {
+                state.dismissible = value;
+                syncState();
+            },
+            get autoDismissOnMessage() {
+                return state.autoDismissOnMessage;
+            },
+            set autoDismissOnMessage(value) {
+                state.autoDismissOnMessage = value;
+                syncState();
+            },
+            show: () => {
+                visible = true;
+                syncState();
+            },
+            hide: () => {
+                if (disposed) {
+                    return;
+                }
+                visible = false;
+                this._proxy.$disposeNotification(internalId);
+            },
+            dispose: () => {
+                if (disposed) {
+                    return;
+                }
+                disposed = true;
+                visible = false;
+                this._proxy.$disposeNotification(internalId);
+                this._items.delete(internalId);
+            }
+        }));
+        this._items.set(internalId, item);
+        return item;
+    }
+}
+function asNotificationIdentifier(extension, id) {
+    return `${ExtensionIdentifier.toKey(extension)}.${id}`;
+}
+
+export { ExtHostChatInputNotification };

package/vscode/src/vs/workbench/api/common/extHostChatSessions.d.ts

@@ -43,6 +43,7 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     $forkChatSession(handle: number, sessionResourceComponents: UriComponents, request: IChatSessionRequestHistoryItemDto | undefined, token: CancellationToken): Promise<ReturnType<typeof typeConvert.ChatSessionItem.from>>;
     private convertRequestDtoToRequestTurn;
     private getChatSessionItemController;
+    private _disposeInputStatesForResource;
     private _createInputStateFromOptions;
     /**
      * Gets the input state for a session. This calls the controller's `getChatSessionInputState` handler if available,
@@ -66,5 +67,6 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     $refreshChatSessionItems(handle: number, token: CancellationToken): Promise<void>;
     $newChatSessionItem(handle: number, request: IChatNewSessionRequestDto, token: CancellationToken): Promise<ReturnType<typeof typeConvert.ChatSessionItem.from> | undefined>;
     $onDidChangeChatSessionItemState(controllerHandle: number, sessionResourceComponents: UriComponents, archived: boolean): void;
+    $resolveChatSessionItem(handle: number, sessionResourceComponents: UriComponents, token: CancellationToken): Promise<ReturnType<typeof typeConvert.ChatSessionItem.from> | undefined>;
     $provideChatSessionInputState(controllerHandle: number, sessionResourceComponents: UriComponents | undefined, token: CancellationToken): Promise<vscode.ChatSessionProviderOptionGroup[] | undefined>;
 }

package/vscode/src/vs/workbench/api/common/extHostChatSessions.js

@@ -14,18 +14,20 @@ import { SymbolKind, SymbolKinds } from '../../../editor/common/languages.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { IDiagnosticVariableEntryFilterData, PromptFileVariableKind, toPromptFileVariableEntry } from '../../contrib/chat/common/attachments/chatVariableEntries.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
-import { isUntitledChatSession } from '../../contrib/chat/common/model/chatUri.js';
+import { getChatSessionType, isUntitledChatSession } from '../../contrib/chat/common/model/chatUri.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatAgentResponseStream } from './extHostChatAgents2.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { ChatSessionItem, ChatAgentRequest, ChatRequestModeInstructions, Location, Diagnostic, ChatResponsePart } from './extHostTypeConverters.js';
 import { Disposable as Disposable$1, ChatRequestTurn, ChatReferenceDiagnostic } from './extHostTypes.js';
+import { isEqual } from '../../../base/common/resources.js';
 import { Location as Location$1 } from './extHostTypes/location.js';
 
 class ChatSessionInputStateImpl {
     #groups;
     #onChangedDelegate;
     #onDidChangeEmitter;
+    #onDidDisposeEmitter;
     #sessionResource;
     get sessionResource() {
         return this.#sessionResource;
@@ -43,6 +45,8 @@ class ChatSessionInputStateImpl {
     constructor(groups, onChangedDelegate) {
         this.#onDidChangeEmitter = ( new Emitter());
         this.onDidChange = this.#onDidChangeEmitter.event;
+        this.#onDidDisposeEmitter = ( new Emitter());
+        this.onDidDispose = this.#onDidDisposeEmitter.event;
         this.#groups = groups;
         this.#onChangedDelegate = onChangedDelegate;
     }
@@ -59,6 +63,11 @@ class ChatSessionInputStateImpl {
     _setGroups(groups) {
         this.#groups = groups;
     }
+    _dispose() {
+        this.#onDidDisposeEmitter.fire();
+        this.#onDidDisposeEmitter.dispose();
+        this.#onDidChangeEmitter.dispose();
+    }
 }
 class ChatSessionItemImpl {
     #label;
@@ -332,6 +341,12 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             },
             onDidChangeChatSessionItemState: onDidChangeChatSessionItemStateEmitter.event,
             newChatSessionItemHandler: undefined,
+            resolveChatSessionItem: provider.resolveChatSessionItem ? async (item, token) => {
+                const resolved = await provider.resolveChatSessionItem(item, token);
+                if (resolved) {
+                    collection.add(resolved);
+                }
+            } : undefined,
             dispose: () => {
                 disposables.dispose();
             },
@@ -348,7 +363,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             onDidChangeChatSessionItemStateEmitter,
             inputStates: ( new Set())
         });
-        this._proxy.$registerChatSessionItemController(controllerHandle, chatSessionType);
+        this._proxy.$registerChatSessionItemController(controllerHandle, chatSessionType, !!provider.resolveChatSessionItem);
         if (provider.onDidChangeChatSessionItems) {
             disposables.add(provider.onDidChangeChatSessionItems(() => {
                 this._logService.trace(`ExtHostChatSessions. Provider items changed for ${chatSessionType}`);
@@ -381,10 +396,12 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         let isDisposed = false;
         let newChatSessionItemHandler;
         let forkHandler;
+        let resolveChatSessionItemHandler;
         let provideChatSessionInputStateHandler;
         const onDidChangeChatSessionItemStateEmitter = disposables.add(( new Emitter()));
         const inputStates = ( new Set());
         const collection = ( new ChatSessionItemCollectionImpl(controllerHandle, this._proxy));
+        const proxy = this._proxy;
         const controller = ( Object.freeze({
             id,
             refreshHandler: async refreshToken => {
@@ -419,6 +436,17 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             set forkHandler(handler) {
                 forkHandler = handler;
             },
+            get resolveChatSessionItem() {
+                return resolveChatSessionItemHandler;
+            },
+            set resolveChatSessionItem(handler) {
+                const hadHandler = !!resolveChatSessionItemHandler;
+                resolveChatSessionItemHandler = handler;
+                const hasHandler = !!handler;
+                if (hadHandler !== hasHandler && !isDisposed) {
+                    proxy.$updateChatSessionItemControllerCapabilities(controllerHandle, hasHandler);
+                }
+            },
             get getChatSessionInputState() {
                 return provideChatSessionInputStateHandler;
             },
@@ -443,7 +471,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                         selected: g.selected,
                         when: g.when,
                         icon: g.icon,
-                        commands: g.commands
+                        commands: g.commands,
+                        kind: g.kind
                     })));
                     const resource = inputState.sessionResource ?? inputState.untitledSessionResource;
                     if (resource) {
@@ -455,6 +484,10 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             },
             dispose: () => {
                 isDisposed = true;
+                for (const inputState of inputStates) {
+                    inputState._dispose();
+                }
+                inputStates.clear();
                 disposables.dispose();
             }
         }));
@@ -466,7 +499,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             onDidChangeChatSessionItemStateEmitter,
             inputStates
         });
-        this._proxy.$registerChatSessionItemController(controllerHandle, id);
+        this._proxy.$registerChatSessionItemController(controllerHandle, id, !!resolveChatSessionItemHandler);
         disposables.add(toDisposable(() => {
             this._chatSessionItemControllers.delete(controllerHandle);
             this._proxy.$unregisterChatSessionItemController(controllerHandle);
@@ -510,7 +543,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             throw ( new Error(`No provider for handle ${handle}`));
         }
         const sessionResource = URI.revive(sessionResourceComponents);
-        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
+        const controllerData = this.getChatSessionItemController(getChatSessionType(sessionResource));
         let inputState;
         if (controllerData?.controller.getChatSessionInputState) {
             const result = await controllerData.controller.getChatSessionInputState(isUntitledChatSession(sessionResource) ? undefined : sessionResource, {
@@ -522,6 +555,9 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         }
         inputState ??= this._createInputStateFromOptions(controllerData?.optionGroups ?? [], context.initialSessionOptions);
         if (inputState instanceof ChatSessionInputStateImpl) {
+            if (controllerData) {
+                this._disposeInputStatesForResource(controllerData.inputStates, sessionResource);
+            }
             if (isUntitledChatSession(sessionResource)) {
                 inputState.untitledSessionResource = sessionResource;
             } else {
@@ -529,7 +565,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             }
         }
         const session = await provider.provider.provideChatSessionContent(sessionResource, token, {
-            sessionOptions: context?.initialSessionOptions ?? [],
             inputState
         });
         if (token.isCancellationRequested) {
@@ -608,9 +643,10 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             }
             return;
         }
-        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
+        const sessionType = getChatSessionType(sessionResource);
+        const controllerData = this.getChatSessionItemController(sessionType);
         if (!controllerData || !controllerData.controller.getChatSessionInputState) {
-            this._logService.warn(`No valid controller found for scheme ${sessionResource.scheme}`);
+            this._logService.warn(`No valid controller found for session type ${sessionType}`);
             return;
         }
         for (const inputState of controllerData?.inputStates ?? []) {
@@ -675,14 +711,19 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         entry?.disposeCts.cancel();
     }
     async $disposeChatSessionContent(providerHandle, sessionResource) {
-        const entry = this._extHostChatSessions.get(URI.revive(sessionResource));
+        const resource = URI.revive(sessionResource);
+        const entry = this._extHostChatSessions.get(resource);
         if (!entry) {
             this._logService.warn(`No chat session found for resource: ${sessionResource}`);
             return;
         }
+        const controllerData = this.getChatSessionItemController(resource.scheme);
+        if (controllerData) {
+            this._disposeInputStatesForResource(controllerData.inputStates, resource);
+        }
         entry.disposeCts.cancel();
         entry.sessionObj.sessionDisposables.dispose();
-        this._extHostChatSessions.delete(URI.revive(sessionResource));
+        this._extHostChatSessions.delete(resource);
     }
     async $invokeChatSessionRequestHandler(handle, sessionResource, request, history, token) {
         const entry = this._extHostChatSessions.get(URI.revive(sessionResource));
@@ -713,7 +754,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             throw ( new Error(`No chat session found for resource ${( sessionResource.toString())}`));
         }
         const requestTurn = this.convertRequestDtoToRequestTurn(request);
-        const controllerData = this.getChatSessionItemController(sessionResource.scheme);
+        const controllerData = this.getChatSessionItemController(getChatSessionType(sessionResource));
         if (controllerData?.controller.forkHandler) {
             const item = await controllerData.controller.forkHandler(sessionResource, requestTurn, token);
             return ChatSessionItem.from(item);
@@ -748,6 +789,15 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         }
         return undefined;
     }
+    _disposeInputStatesForResource(inputStates, resource) {
+        for (const inputState of inputStates) {
+            const inputResource = inputState.sessionResource ?? inputState.untitledSessionResource;
+            if (inputResource && isEqual(resource, inputResource)) {
+                inputState._dispose();
+                inputStates.delete(inputState);
+            }
+        }
+    }
     _createInputStateFromOptions(groups, sessionOptions) {
         if (!sessionOptions?.length) {
             return ( new ChatSessionInputStateImpl(groups));
@@ -769,8 +819,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         return ( new ChatSessionInputStateImpl(resolvedGroups));
     }
     async getInputStateForSession(sessionResource, initialSessionOptions, token) {
-        const scheme = sessionResource?.scheme;
-        const controllerData = scheme ? this.getChatSessionItemController(scheme) : undefined;
+        const sessionType = sessionResource ? getChatSessionType(sessionResource) : undefined;
+        const controllerData = sessionType ? this.getChatSessionItemController(sessionType) : undefined;
         const resolvedResource = sessionResource && !isUntitledChatSession(sessionResource) ? sessionResource : undefined;
         if (controllerData?.controller.getChatSessionInputState) {
             const result = await controllerData.controller.getChatSessionInputState(resolvedResource, {
@@ -778,6 +828,9 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             }, token);
             if (result) {
                 if (result instanceof ChatSessionInputStateImpl) {
+                    if (sessionResource && controllerData) {
+                        this._disposeInputStatesForResource(controllerData.inputStates, sessionResource);
+                    }
                     if (sessionResource && isUntitledChatSession(sessionResource)) {
                         result.untitledSessionResource = sessionResource;
                     } else if (sessionResource) {
@@ -918,7 +971,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         return {
             type: "response",
             parts,
-            participant: turn.participant
+            participant: turn.participant,
+            details: turn.result?.details
         };
     }
     async $refreshChatSessionItems(handle, token) {
@@ -953,7 +1007,6 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 prompt: request.prompt,
                 command: request.command
             },
-            sessionOptions: request.initialSessionOptions ?? [],
             inputState
         }, token);
         if (!item) {
@@ -977,6 +1030,24 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         item.archived = archived;
         controllerData.onDidChangeChatSessionItemStateEmitter.fire(item);
     }
+    async $resolveChatSessionItem(handle, sessionResourceComponents, token) {
+        const sessionResource = URI.revive(sessionResourceComponents);
+        const controllerData = this._chatSessionItemControllers.get(handle);
+        if (!controllerData?.controller.resolveChatSessionItem) {
+            return undefined;
+        }
+        const item = controllerData.controller.items.get(sessionResource);
+        if (!item) {
+            this._logService.warn(`No item found for session resource ${( sessionResource.toString())}`);
+            return undefined;
+        }
+        await controllerData.controller.resolveChatSessionItem(item, token);
+        const updatedItem = controllerData.controller.items.get(sessionResource);
+        if (!updatedItem) {
+            return undefined;
+        }
+        return ChatSessionItem.from(updatedItem);
+    }
     async $provideChatSessionInputState(controllerHandle, sessionResourceComponents, token) {
         const controllerData = this._chatSessionItemControllers.get(controllerHandle);
         if (!controllerData) {
@@ -999,6 +1070,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             return undefined;
         }
         if (inputState instanceof ChatSessionInputStateImpl && sessionResource) {
+            this._disposeInputStatesForResource(controllerData.inputStates, sessionResource);
             if (isUntitledChatSession(sessionResource)) {
                 inputState.untitledSessionResource = sessionResource;
             } else {
@@ -1015,7 +1087,8 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             selected: g.selected,
             when: g.when,
             icon: g.icon,
-            commands: g.commands
+            commands: g.commands,
+            kind: g.kind
         })));
     }
 };

package/vscode/src/vs/workbench/api/common/extHostCustomEditors.d.ts

@@ -32,6 +32,9 @@ export declare class ExtHostCustomEditors implements extHostProtocol.ExtHostCust
         options: extHostProtocol.IWebviewPanelOptions;
         active: boolean;
     }, position: EditorGroupColumn, cancellation: CancellationToken): Promise<void>;
+    $resolveCustomEditorInlineDiff(originalResource: UriComponents, modifiedResource: UriComponents, handle: extHostProtocol.WebviewHandle, viewType: string, initData: extHostProtocol.CustomEditorDiffInitData, position: EditorGroupColumn, cancellation: CancellationToken): Promise<void>;
+    $resolveCustomEditorSideBySideDiff(originalResource: UriComponents, modifiedResource: UriComponents, webviewHandles: extHostProtocol.CustomEditorSideBySideDiffWebviewHandles, viewType: string, initData: extHostProtocol.CustomEditorSideBySideDiffInitData, position: EditorGroupColumn, cancellation: CancellationToken): Promise<void>;
+    private createCustomEditorDiffPanel;
     $disposeEdits(resourceComponents: UriComponents, viewType: string, editIds: number[]): void;
     $onMoveCustomEditor(handle: string, newResourceComponents: UriComponents, viewType: string): Promise<void>;
     $undo(resourceComponents: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void>;

package/vscode/src/vs/workbench/api/common/extHostCustomEditors.js

@@ -10,6 +10,7 @@ import { toExtensionData, shouldSerializeBuffersForPostMessage } from './extHost
 import { Cache } from './cache.js';
 import { MainContext } from './extHost.protocol.js';
 import { Disposable } from './extHostTypes.js';
+import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 
 class CustomDocumentStoreEntry {
     constructor(document, _storagePath) {
@@ -142,10 +143,13 @@ class ExtHostCustomEditors {
         if (isCustomTextEditorProvider(provider)) {
             disposables.add(this._editorProviders.addTextProvider(viewType, extension, provider));
             this._proxy.$registerTextEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
-                supportsMove: !!provider.moveCustomTextEditor
+                supportsMove: !!provider.moveCustomTextEditor,
+                supportsInlineDiff: isProposedApiEnabled(extension) && isCustomTextEditorProviderWithInlineDiffCapability(provider),
+                supportsSideBySideDiff: isProposedApiEnabled(extension) && isCustomTextEditorProviderWithSideBySideDiffCapability(provider)
             }, shouldSerializeBuffersForPostMessage(extension));
         } else {
             disposables.add(this._editorProviders.addCustomProvider(viewType, extension, provider));
+            const supportsCustomEditorDiffs = isProposedApiEnabled(extension);
             if (isCustomEditorProviderWithEditingCapability(provider)) {
                 disposables.add(provider.onDidChangeCustomDocument(e => {
                     const entry = this.getCustomDocumentEntry(viewType, e.document.uri);
@@ -157,13 +161,10 @@ class ExtHostCustomEditors {
                     }
                 }));
             }
-            this._proxy.$registerCustomEditorProvider(
-                toExtensionData(extension),
-                viewType,
-                options.webviewOptions || {},
-                !!options.supportsMultipleEditorsPerDocument,
-                shouldSerializeBuffersForPostMessage(extension)
-            );
+            this._proxy.$registerCustomEditorProvider(toExtensionData(extension), viewType, options.webviewOptions || {}, {
+                supportsInlineDiff: supportsCustomEditorDiffs && isCustomEditorProviderWithInlineDiffCapability(provider),
+                supportsSideBySideDiff: supportsCustomEditorDiffs && isCustomEditorProviderWithSideBySideDiffCapability(provider)
+            }, !!options.supportsMultipleEditorsPerDocument, shouldSerializeBuffersForPostMessage(extension));
         }
         return Disposable.from(disposables, new Disposable(() => {
             this._proxy.$unregisterEditorProvider(viewType);
@@ -213,6 +214,7 @@ class ExtHostCustomEditors {
         }
         const viewColumn = ViewColumn.to(position);
         const webview = this._extHostWebview.createNewWebview(handle, initData.contentOptions, entry.extension);
+        this._extHostWebview.ensureDefaultContentOptions(handle, initData.contentOptions, entry.extension);
         const panel = this._extHostWebviewPanels.createNewWebviewPanel(
             handle,
             viewType,
@@ -242,6 +244,123 @@ class ExtHostCustomEditors {
             }
         }
     }
+    async $resolveCustomEditorInlineDiff(
+        originalResource,
+        modifiedResource,
+        handle,
+        viewType,
+        initData,
+        position,
+        cancellation
+    ) {
+        const {
+            entry,
+            panel
+        } = this.createCustomEditorDiffPanel(handle, viewType, initData, position);
+        const revivedOriginalResource = URI.revive(originalResource);
+        const revivedModifiedResource = URI.revive(modifiedResource);
+        if (entry.type === CustomEditorType.Text) {
+            if (!isCustomTextEditorProviderWithInlineDiffCapability(entry.provider)) {
+                throw ( new Error(
+                    `Provider for '${viewType}' does not support inline custom text editor diffs`
+                ));
+            }
+            const originalDocument = this._extHostDocuments.getDocument(revivedOriginalResource);
+            const modifiedDocument = this._extHostDocuments.getDocument(revivedModifiedResource);
+            return entry.provider.resolveCustomTextEditorInlineDiff({
+                original: originalDocument,
+                modified: modifiedDocument
+            }, panel, cancellation);
+        }
+        if (!isCustomEditorProviderWithInlineDiffCapability(entry.provider)) {
+            throw ( new Error(`Provider for '${viewType}' does not support inline custom editor diffs`));
+        }
+        const {
+            document: originalDocument
+        } = this.getCustomDocumentEntry(viewType, revivedOriginalResource);
+        const {
+            document: modifiedDocument
+        } = this.getCustomDocumentEntry(viewType, revivedModifiedResource);
+        return entry.provider.resolveCustomEditorInlineDiff({
+            original: originalDocument,
+            modified: modifiedDocument
+        }, panel, cancellation);
+    }
+    async $resolveCustomEditorSideBySideDiff(
+        originalResource,
+        modifiedResource,
+        webviewHandles,
+        viewType,
+        initData,
+        position,
+        cancellation
+    ) {
+        const {
+            entry,
+            panel: originalPanel
+        } = this.createCustomEditorDiffPanel(webviewHandles.original, viewType, initData.original, position);
+        const {
+            panel: modifiedPanel
+        } = this.createCustomEditorDiffPanel(webviewHandles.modified, viewType, initData.modified, position);
+        const revivedOriginalResource = URI.revive(originalResource);
+        const revivedModifiedResource = URI.revive(modifiedResource);
+        if (entry.type === CustomEditorType.Text) {
+            if (!isCustomTextEditorProviderWithSideBySideDiffCapability(entry.provider)) {
+                throw ( new Error(
+                    `Provider for '${viewType}' does not support side by side custom text editor diffs`
+                ));
+            }
+            const originalDocument = this._extHostDocuments.getDocument(revivedOriginalResource);
+            const modifiedDocument = this._extHostDocuments.getDocument(revivedModifiedResource);
+            return entry.provider.resolveCustomTextEditorSideBySideDiff({
+                original: originalDocument,
+                modified: modifiedDocument
+            }, {
+                original: originalPanel,
+                modified: modifiedPanel
+            }, cancellation);
+        }
+        if (!isCustomEditorProviderWithSideBySideDiffCapability(entry.provider)) {
+            throw ( new Error(
+                `Provider for '${viewType}' does not support side by side custom editor diffs`
+            ));
+        }
+        const {
+            document: originalDocument
+        } = this.getCustomDocumentEntry(viewType, revivedOriginalResource);
+        const {
+            document: modifiedDocument
+        } = this.getCustomDocumentEntry(viewType, revivedModifiedResource);
+        return entry.provider.resolveCustomEditorSideBySideDiff({
+            original: originalDocument,
+            modified: modifiedDocument
+        }, {
+            original: originalPanel,
+            modified: modifiedPanel
+        }, cancellation);
+    }
+    createCustomEditorDiffPanel(handle, viewType, initData, position) {
+        const entry = this._editorProviders.get(viewType);
+        if (!entry) {
+            throw ( new Error(`No provider found for '${viewType}'`));
+        }
+        const viewColumn = ViewColumn.to(position);
+        const webview = this._extHostWebview.createNewWebview(handle, initData.contentOptions, entry.extension);
+        this._extHostWebview.ensureDefaultContentOptions(handle, initData.contentOptions, entry.extension);
+        const panel = this._extHostWebviewPanels.createNewWebviewPanel(
+            handle,
+            viewType,
+            initData.title,
+            viewColumn,
+            initData.options,
+            webview,
+            initData.active
+        );
+        return {
+            entry,
+            panel
+        };
+    }
     $disposeEdits(resourceComponents, viewType, editIds) {
         const document = this.getCustomDocumentEntry(viewType, resourceComponents);
         document.disposeEdits(editIds);
@@ -318,6 +437,18 @@ function isCustomEditorProviderWithEditingCapability(provider) {
 function isCustomTextEditorProvider(provider) {
     return typeof provider.resolveCustomTextEditor === "function";
 }
+function isCustomTextEditorProviderWithInlineDiffCapability(provider) {
+    return typeof provider.resolveCustomTextEditorInlineDiff === "function";
+}
+function isCustomTextEditorProviderWithSideBySideDiffCapability(provider) {
+    return typeof provider.resolveCustomTextEditorSideBySideDiff === "function";
+}
+function isCustomEditorProviderWithInlineDiffCapability(provider) {
+    return typeof provider.resolveCustomEditorInlineDiff === "function";
+}
+function isCustomEditorProviderWithSideBySideDiffCapability(provider) {
+    return typeof provider.resolveCustomEditorSideBySideDiff === "function";
+}
 function isEditEvent(e) {
     return typeof e.undo === "function" && typeof e.redo === "function";
 }

package/vscode/src/vs/workbench/api/common/extHostDiagnostics.js

@@ -125,7 +125,7 @@ class DiagnosticCollection {
                     marker.push({
                         severity: MarkerSeverity.Info,
                         message: ( localize(
-                            2741,
+                            2784,
                             "Not showing {0} further errors and warnings.",
                             diagnostics.length - this._maxDiagnosticsPerFile
                         )),

package/vscode/src/vs/workbench/api/common/extHostExtensionActivator.js

@@ -68,14 +68,14 @@ class ActivatedExtension {
         activationFailedError,
         activationTimes,
         module,
-        exports$1,
+        exports,
         disposable
     ) {
         this.activationFailed = activationFailed;
         this.activationFailedError = activationFailedError;
         this.activationTimes = activationTimes;
         this.module = module;
-        this.exports = exports$1;
+        this.exports = exports;
         this.disposable = disposable;
     }
 }

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -614,14 +614,14 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             extensionTestsLocationURI
         } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2742, "Cannot load test runner."))));
+            throw ( new Error(( localize(2785, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
         const testRunner = await (isESM ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))) : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
         if (!testRunner || typeof testRunner.run !== "function") {
             throw ( new Error(( localize(
-                2743,
+                2786,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));