@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/api/browser/mainThreadTreeViews.js

@@ -10,7 +10,7 @@ import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform
 import { IExtensionService } from '../../services/extensions/common/extensions.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { createStringDataTransferItem, VSDataTransfer } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
-import { DataTransferCache } from '../common/shared/dataTransferCache.js';
+import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
 import { DataTransfer } from '../common/extHostTypeConverters.js';
 let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
     constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
@@ -38,8 +38,9 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
             )) : undefined;
             const viewer = this.getTreeView(treeViewId);
             if (viewer) {
-                viewer.showCollapseAllAction = !!options.showCollapseAll;
-                viewer.canSelectMany = !!options.canSelectMany;
+                viewer.showCollapseAllAction = options.showCollapseAll;
+                viewer.canSelectMany = options.canSelectMany;
+                viewer.manuallyManageCheckboxes = options.manuallyManageCheckboxes;
                 viewer.dragAndDropController = dndController;
                 if (dndController) {
                     this._dndControllers.set(treeViewId, dndController);
@@ -190,12 +191,16 @@ class TreeViewDragAndDropController {
         this.dragMimeTypes = dragMimeTypes;
         this.hasWillDrop = hasWillDrop;
         this._proxy = _proxy;
-        this.dataTransfersCache = ( new DataTransferCache());
+        this.dataTransfersCache = ( new DataTransferFileCache());
     }
     async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
         const request = this.dataTransfersCache.add(dataTransfer);
         try {
-            return await this._proxy.$handleDrop(this.treeViewId, request.id, await DataTransfer.toDataTransferDTO(dataTransfer), targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
+            const dataTransferDto = await DataTransfer.from(dataTransfer);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            return await this._proxy.$handleDrop(this.treeViewId, request.id, dataTransferDto, targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
         }
         finally {
             request.dispose();

package/dist/vscode/vs/workbench/api/browser/mainThreadWindow.js

@@ -6,19 +6,25 @@ import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/open
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { IHostService } from '../../services/host/browser/host.js';
+import { IUserActivityService } from '../../services/userActivity/common/userActivityService.js';
 let MainThreadWindow = class MainThreadWindow {
-    constructor(extHostContext, hostService, openerService) {
+    constructor(extHostContext, hostService, openerService, userActivityService) {
         this.hostService = hostService;
         this.openerService = openerService;
+        this.userActivityService = userActivityService;
         this.disposables = ( new DisposableStore());
         this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
         Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
+        userActivityService.onDidChangeIsActive(this.proxy.$onDidChangeWindowActive, this.proxy, this.disposables);
     }
     dispose() {
         this.disposables.dispose();
     }
-    $getWindowVisibility() {
-        return Promise.resolve(this.hostService.hasFocus);
+    $getInitialState() {
+        return Promise.resolve({
+            isFocused: this.hostService.hasFocus,
+            isActive: this.userActivityService.isActive,
+        });
     }
     async $openUri(uriComponents, uriString, options) {
         const uri = ( URI.from(uriComponents));
@@ -43,6 +49,7 @@ let MainThreadWindow = class MainThreadWindow {
 MainThreadWindow = __decorate([
     extHostNamedCustomer(MainContext.MainThreadWindow),
     ( __param(1, IHostService)),
-    ( __param(2, IOpenerService))
+    ( __param(2, IOpenerService)),
+    ( __param(3, IUserActivityService))
 ], MainThreadWindow);
 export { MainThreadWindow };

package/dist/vscode/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -23,11 +23,13 @@ import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { IEditSessionIdentityService } from '../../../platform/workspace/common/editSessions.js';
 import { SideBySideEditor, EditorResourceAccessor } from '../../common/editor.js';
 import { firstOrDefault, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ICanonicalUriService } from '../../../platform/workspace/common/canonicalUri.js';
 let MainThreadWorkspace = class MainThreadWorkspace {
-    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
+    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
         this._searchService = _searchService;
         this._contextService = _contextService;
         this._editSessionIdentityService = _editSessionIdentityService;
+        this._canonicalUriService = _canonicalUriService;
         this._editorService = _editorService;
         this._workspaceEditingService = _workspaceEditingService;
         this._notificationService = _notificationService;
@@ -41,6 +43,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         this._activeCancelTokens = Object.create(null);
         this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
         this.registeredEditSessionProviders = ( new Map());
+        this.registeredCanonicalUriProviders = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
         const workspace = this._contextService.getWorkspace();
         if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
@@ -227,21 +230,41 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         disposable?.dispose();
         this.registeredEditSessionProviders.delete(handle);
     }
+    $registerCanonicalUriProvider(handle, scheme) {
+        const disposable = this._canonicalUriService.registerCanonicalUriProvider({
+            scheme: scheme,
+            provideCanonicalUri: async (uri, targetScheme, token) => {
+                const result = await this._proxy.$provideCanonicalUri(uri, targetScheme, token);
+                if (result) {
+                    return URI.revive(result);
+                }
+                return result;
+            }
+        });
+        this.registeredCanonicalUriProviders.set(handle, disposable);
+        this._toDispose.add(disposable);
+    }
+    $unregisterCanonicalUriProvider(handle) {
+        const disposable = this.registeredCanonicalUriProviders.get(handle);
+        disposable?.dispose();
+        this.registeredCanonicalUriProviders.delete(handle);
+    }
 };
 MainThreadWorkspace = __decorate([
     extHostNamedCustomer(MainContext.MainThreadWorkspace),
     ( __param(1, ISearchService)),
     ( __param(2, IWorkspaceContextService)),
     ( __param(3, IEditSessionIdentityService)),
-    ( __param(4, IEditorService)),
-    ( __param(5, IWorkspaceEditingService)),
-    ( __param(6, INotificationService)),
-    ( __param(7, IRequestService)),
-    ( __param(8, IInstantiationService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, IEnvironmentService)),
-    ( __param(11, IFileService)),
-    ( __param(12, IWorkspaceTrustManagementService)),
-    ( __param(13, IWorkspaceTrustRequestService))
+    ( __param(4, ICanonicalUriService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IWorkspaceEditingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IRequestService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILabelService)),
+    ( __param(11, IEnvironmentService)),
+    ( __param(12, IFileService)),
+    ( __param(13, IWorkspaceTrustManagementService)),
+    ( __param(14, IWorkspaceTrustRequestService))
 ], MainThreadWorkspace);
 export { MainThreadWorkspace };

package/dist/vscode/vs/workbench/api/browser/statusBarExtensionPoint.js

@@ -0,0 +1,81 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStatusbarService } from '../../services/statusbar/browser/statusbar.js';
+import { getCodiconAriaLabel } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+const IExtensionStatusBarItemService = ( createDecorator('IExtensionStatusBarItemService'));
+let ExtensionStatusBarItemService = class ExtensionStatusBarItemService {
+    constructor(_statusbarService) {
+        this._statusbarService = _statusbarService;
+        this._entries = ( new Map());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+    }
+    dispose() {
+        this._entries.forEach(entry => entry.accessor.dispose());
+        this._entries.clear();
+        this._onDidChange.dispose();
+    }
+    setOrUpdateEntry(entryId, id, extensionId, name, text, tooltip, command, color, backgroundColor, alignLeft, priority, accessibilityInformation) {
+        let ariaLabel;
+        let role = undefined;
+        if (accessibilityInformation) {
+            ariaLabel = accessibilityInformation.label;
+            role = accessibilityInformation.role;
+        }
+        else {
+            ariaLabel = getCodiconAriaLabel(text);
+            if (tooltip) {
+                const tooltipString = typeof tooltip === 'string' ? tooltip : tooltip.value;
+                ariaLabel += `, ${tooltipString}`;
+            }
+        }
+        const entry = { name, text, tooltip, command, color, backgroundColor, ariaLabel, role };
+        if (typeof priority === 'undefined') {
+            priority = 0;
+        }
+        let alignment = alignLeft ? 0  : 1 ;
+        const existingEntry = this._entries.get(entryId);
+        if (existingEntry) {
+            alignment = existingEntry.alignment;
+            priority = existingEntry.priority;
+        }
+        if (!existingEntry) {
+            let entryPriority;
+            if (typeof extensionId === 'string') {
+                entryPriority = { primary: priority, secondary: hash(extensionId) };
+            }
+            else {
+                entryPriority = priority;
+            }
+            this._entries.set(entryId, {
+                accessor: this._statusbarService.addEntry(entry, id, alignment, entryPriority),
+                entry,
+                alignment,
+                priority
+            });
+            this._onDidChange.fire({ added: [entryId, { entry, alignment, priority }] });
+        }
+        else {
+            existingEntry.accessor.update(entry);
+            existingEntry.entry = entry;
+        }
+        return toDisposable(() => {
+            const entry = this._entries.get(entryId);
+            if (entry) {
+                entry.accessor.dispose();
+                this._entries.delete(entryId);
+                this._onDidChange.fire({ removed: entryId });
+            }
+        });
+    }
+    getEntries() {
+        return this._entries.entries();
+    }
+};
+ExtensionStatusBarItemService = ( __decorate([
+    ( __param(0, IStatusbarService))
+], ExtensionStatusBarItemService));
+export { ExtensionStatusBarItemService, IExtensionStatusBarItemService };

package/dist/vscode/vs/workbench/api/common/extHost.protocol.js

@@ -52,6 +52,7 @@ const MainContext = {
     MainThreadExtensionService: ( createProxyIdentifier('MainThreadExtensionService')),
     MainThreadSCM: ( createProxyIdentifier('MainThreadSCM')),
     MainThreadSearch: ( createProxyIdentifier('MainThreadSearch')),
+    MainThreadShare: ( createProxyIdentifier('MainThreadShare')),
     MainThreadTask: ( createProxyIdentifier('MainThreadTask')),
     MainThreadWindow: ( createProxyIdentifier('MainThreadWindow')),
     MainThreadLabelService: ( createProxyIdentifier('MainThreadLabelService')),
@@ -61,10 +62,11 @@ const MainContext = {
     MainThreadNotebookKernels: ( createProxyIdentifier('MainThreadNotebookKernels')),
     MainThreadNotebookRenderers: ( createProxyIdentifier('MainThreadNotebookRenderers')),
     MainThreadInteractive: ( createProxyIdentifier('MainThreadInteractive')),
-    MainThreadInteractiveSession: ( createProxyIdentifier('MainThreadInteractiveSession')),
+    MainThreadChat: ( createProxyIdentifier('MainThreadChat')),
     MainThreadInteractiveEditor: ( createProxyIdentifier('MainThreadInteractiveEditor')),
     MainThreadTheming: ( createProxyIdentifier('MainThreadTheming')),
     MainThreadTunnelService: ( createProxyIdentifier('MainThreadTunnelService')),
+    MainThreadManagedSockets: ( createProxyIdentifier('MainThreadManagedSockets')),
     MainThreadTimeline: ( createProxyIdentifier('MainThreadTimeline')),
     MainThreadTesting: ( createProxyIdentifier('MainThreadTesting')),
     MainThreadLocalization: ( createProxyIdentifier('MainThreadLocalizationShape')),
@@ -90,6 +92,8 @@ const ExtHostContext = {
     ExtHostLanguageFeatures: ( createProxyIdentifier('ExtHostLanguageFeatures')),
     ExtHostQuickOpen: ( createProxyIdentifier('ExtHostQuickOpen')),
     ExtHostQuickDiff: ( createProxyIdentifier('ExtHostQuickDiff')),
+    ExtHostStatusBar: ( createProxyIdentifier('ExtHostStatusBar')),
+    ExtHostShare: ( createProxyIdentifier('ExtHostShare')),
     ExtHostExtensionService: ( createProxyIdentifier('ExtHostExtensionService')),
     ExtHostLogLevelServiceShape: ( createProxyIdentifier('ExtHostLogLevelServiceShape')),
     ExtHostTerminalService: ( createProxyIdentifier('ExtHostTerminalService')),
@@ -121,10 +125,11 @@ const ExtHostContext = {
     ExtHostNotebookDocumentSaveParticipant: ( createProxyIdentifier('ExtHostNotebookDocumentSaveParticipant')),
     ExtHostInteractive: ( createProxyIdentifier('ExtHostInteractive')),
     ExtHostInteractiveEditor: ( createProxyIdentifier('ExtHostInteractiveEditor')),
-    ExtHostInteractiveSession: ( createProxyIdentifier('ExtHostInteractiveSession')),
+    ExtHostChat: ( createProxyIdentifier('ExtHostChat')),
     ExtHostSemanticSimilarity: ( createProxyIdentifier('ExtHostSemanticSimilarity')),
     ExtHostTheming: ( createProxyIdentifier('ExtHostTheming')),
     ExtHostTunnelService: ( createProxyIdentifier('ExtHostTunnelService')),
+    ExtHostManagedSockets: ( createProxyIdentifier('ExtHostManagedSockets')),
     ExtHostAuthentication: ( createProxyIdentifier('ExtHostAuthentication')),
     ExtHostTimeline: ( createProxyIdentifier('ExtHostTimeline')),
     ExtHostTesting: ( createProxyIdentifier('ExtHostTesting')),

package/dist/vscode/vs/workbench/api/common/extHostDebugService.js

@@ -8,7 +8,7 @@ import { MainContext } from './extHost.protocol.js';
 import { IExtHostEditorTabs } from './extHostEditorTabs.js';
 import { IExtHostExtensionService } from './extHostExtensionService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { SourceBreakpoint, DebugConsoleMode, Disposable, setBreakpointId, FunctionBreakpoint, Location, Position, DebugAdapterExecutable, DebugAdapterServer, DebugAdapterNamedPipeServer, DebugAdapterInlineImplementation, DataBreakpoint } from './extHostTypes.js';
+import { SourceBreakpoint, DebugConsoleMode, Disposable, setBreakpointId, FunctionBreakpoint, Location, Position, DebugAdapterExecutable, DebugAdapterServer, DebugAdapterNamedPipeServer, DebugAdapterInlineImplementation, DataBreakpoint, ThreadFocus, StackFrameFocus } from './extHostTypes.js';
 import { IExtHostWorkspace } from './extHostWorkspace.js';
 import { AbstractDebugAdapter } from '../../contrib/debug/common/abstractDebugAdapter.js';
 import { convertToVSCPaths, convertToDAPaths, isDebuggerMainContribution } from '../../contrib/debug/common/debugUtils.js';
@@ -433,22 +433,13 @@ let ExtHostDebugServiceBase = class ExtHostDebugServiceBase {
             throw new Error('no DebugSession found for debug focus context');
         }
         if (focusDto.kind === 'thread') {
-            focus = {
-                kind: focusDto.kind,
-                threadId: focusDto.threadId,
-                session,
-            };
+            focus = ( new ThreadFocus(session, focusDto.threadId));
         }
         else {
-            focus = {
-                kind: focusDto.kind,
-                threadId: focusDto.threadId,
-                frameId: focusDto.frameId,
-                session,
-            };
+            focus = ( new StackFrameFocus(session, focusDto.threadId, focusDto.frameId));
         }
         this._stackFrameFocus = focus;
-        this._onDidChangeStackFrameFocus.fire(focus);
+        this._onDidChangeStackFrameFocus.fire(this._stackFrameFocus);
     }
     $provideDebugConfigurations(configProviderHandle, folderUri, token) {
         return asPromise(async () => {

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

@@ -19,8 +19,8 @@ import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
 import { ExtensionIdentifier, ExtensionIdentifierMap, ExtensionIdentifierSet } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { ExtensionGlobalMemento, ExtensionMemento } from './extHostMemento.js';
-import { RemoteAuthorityResolverError, ExtensionMode, ExtensionKind } from './extHostTypes.js';
-import { RemoteAuthorityResolverErrorCode, getRemoteAuthorityPrefix } from '../../../platform/remote/common/remoteAuthorityResolver.js';
+import { ManagedResolvedAuthority, RemoteAuthorityResolverError, ExtensionMode, ExtensionKind } from './extHostTypes.js';
+import { RemoteAuthorityResolverErrorCode, getRemoteAuthorityPrefix, ManagedRemoteConnection, WebSocketRemoteConnection } from '../../../platform/remote/common/remoteAuthorityResolver.js';
 import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtensionStoragePaths } from './extHostStoragePaths.js';
@@ -36,11 +36,13 @@ import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { IExtHostLocalizationService } from './extHostLocalizationService.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { setTimeout0 } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IExtHostManagedSockets } from './extHostManagedSockets.js';
 var _Extension_extensionService, _Extension_originExtensionId, _Extension_identifier;
 const IHostUtils = ( createDecorator('IHostUtils'));
 let AbstractExtHostExtensionService = class AbstractExtHostExtensionService extends Disposable {
-    constructor(instaService, hostUtils, extHostContext, extHostWorkspace, extHostConfiguration, logService, initData, storagePath, extHostTunnelService, extHostTerminalService, extHostLocalizationService) {
+    constructor(instaService, hostUtils, extHostContext, extHostWorkspace, extHostConfiguration, logService, initData, storagePath, extHostTunnelService, extHostTerminalService, extHostLocalizationService, _extHostManagedSockets) {
         super();
+        this._extHostManagedSockets = _extHostManagedSockets;
         this._onDidChangeRemoteConnectionData = this._register(( new Emitter()));
         this.onDidChangeRemoteConnectionData = this._onDidChangeRemoteConnectionData.event;
         this._isTerminating = false;
@@ -598,27 +600,39 @@ let AbstractExtHostExtensionService = class AbstractExtHostExtensionService exte
             const result = await resolver.resolve(remoteAuthority, { resolveAttempt });
             performance.mark(`code/extHost/didResolveAuthorityOK/${authorityPrefix}`);
             intervalLogger.dispose();
-            logInfo(`returned ${result.host}:${result.port}`);
-            const authority = {
-                authority: remoteAuthority,
-                host: result.host,
-                port: result.port,
-                connectionToken: result.connectionToken
+            const tunnelInformation = {
+                environmentTunnels: result.environmentTunnels,
+                features: result.tunnelFeatures
             };
             const options = {
                 extensionHostEnv: result.extensionHostEnv,
                 isTrusted: result.isTrusted,
                 authenticationSession: result.authenticationSessionForInitializingExtensions ? { id: result.authenticationSessionForInitializingExtensions.id, providerId: result.authenticationSessionForInitializingExtensions.providerId } : undefined
             };
+            logInfo(`returned ${ManagedResolvedAuthority.isManagedResolvedAuthority(result) ? 'managed authority' : `${result.host}:${result.port}`}`);
+            let authority;
+            if (ManagedResolvedAuthority.isManagedResolvedAuthority(result)) {
+                const socketFactoryId = resolveAttempt;
+                this._extHostManagedSockets.setFactory(socketFactoryId, result.makeConnection);
+                authority = {
+                    authority: remoteAuthority,
+                    connectTo: ( new ManagedRemoteConnection(socketFactoryId)),
+                    connectionToken: result.connectionToken
+                };
+            }
+            else {
+                authority = {
+                    authority: remoteAuthority,
+                    connectTo: ( new WebSocketRemoteConnection(result.host, result.port)),
+                    connectionToken: result.connectionToken
+                };
+            }
             return {
                 type: 'ok',
                 value: {
-                    authority,
+                    authority: authority,
                     options,
-                    tunnelInformation: {
-                        environmentTunnels: result.environmentTunnels,
-                        features: result.tunnelFeatures
-                    }
+                    tunnelInformation,
                 }
             };
         }
@@ -717,7 +731,8 @@ AbstractExtHostExtensionService = ( __decorate([
     ( __param(7, IExtensionStoragePaths)),
     ( __param(8, IExtHostTunnelService)),
     ( __param(9, IExtHostTerminalService)),
-    ( __param(10, IExtHostLocalizationService))
+    ( __param(10, IExtHostLocalizationService)),
+    ( __param(11, IExtHostManagedSockets))
 ], AbstractExtHostExtensionService));
 function applyExtensionsDelta(activationEventsReader, oldGlobalRegistry, oldMyRegistry, extensionsDelta) {
     activationEventsReader.addActivationEvents(extensionsDelta.addActivationEvents);

package/dist/vscode/vs/workbench/api/common/extHostFileSystemConsumer.js

@@ -15,18 +15,21 @@ let ExtHostConsumerFileSystem = class ExtHostConsumerFileSystem {
         this.value = ( Object.freeze({
             async stat(uri) {
                 try {
+                    let stat;
                     const provider = that._fileSystemProvider.get(uri.scheme);
-                    if (!provider) {
-                        return await that._proxy.$stat(uri);
+                    if (provider) {
+                        await that._proxy.$ensureActivation(uri.scheme);
+                        stat = await provider.stat(uri);
+                    }
+                    else {
+                        stat = await that._proxy.$stat(uri);
                     }
-                    await that._proxy.$ensureActivation(uri.scheme);
-                    const stat = await provider.stat(uri);
                     return {
                         type: stat.type,
                         ctime: stat.ctime,
                         mtime: stat.mtime,
                         size: stat.size,
-                        permissions: stat.permissions
+                        permissions: stat.permissions === files.FilePermission.Readonly ? 1 : undefined
                     };
                 }
                 catch (err) {
@@ -88,7 +91,7 @@ let ExtHostConsumerFileSystem = class ExtHostConsumerFileSystem {
                         return await provider.delete(uri, { recursive: false, ...options });
                     }
                     else {
-                        return await that._proxy.$delete(uri, { recursive: false, useTrash: false, ...options });
+                        return await that._proxy.$delete(uri, { recursive: false, useTrash: false, atomic: false, ...options });
                     }
                 }
                 catch (err) {
@@ -124,6 +127,17 @@ let ExtHostConsumerFileSystem = class ExtHostConsumerFileSystem {
         if (err instanceof FileSystemError) {
             throw err;
         }
+        if (err instanceof files.FileSystemProviderError) {
+            switch (err.code) {
+                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);
+            }
+        }
         if (!(err instanceof Error)) {
             throw new FileSystemError(String(err));
         }

package/dist/vscode/vs/workbench/api/common/extHostLanguageFeatures.js

@@ -1,7 +1,7 @@
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Range, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, location, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
-import { Disposable, DocumentSymbol, Range as Range$2, CodeActionKind, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, Location, CompletionList, InlineCompletionTriggerKind } from './extHostTypes.js';
+import { Disposable, DocumentSymbol, Range as Range$2, CodeActionKind, InternalDataTransferItem, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, Location, CompletionList, InlineCompletionTriggerKind } from './extHostTypes.js';
 import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
 import { MainContext } from './extHost.protocol.js';
 import { regExpFlags, regExpLeadsToEndlessLoop } from 'monaco-editor/esm/vs/base/common/strings.js';
@@ -412,15 +412,16 @@ class CodeActionAdapter {
 }
 CodeActionAdapter._maxCodeActionsPerFile = 1000;
 class DocumentPasteEditProvider {
-    constructor(_proxy, _documents, _provider, _handle) {
+    constructor(_proxy, _documents, _provider, _handle, _extension) {
         this._proxy = _proxy;
         this._documents = _documents;
         this._provider = _provider;
         this._handle = _handle;
+        this._extension = _extension;
     }
     async prepareDocumentPaste(resource, ranges, dataTransferDto, token) {
         if (!this._provider.prepareDocumentPaste) {
-            return undefined;
+            return;
         }
         const doc = this._documents.getDocument(resource);
         const vscodeRanges = ( (ranges.map(range => Range.to(range))));
@@ -428,9 +429,16 @@ class DocumentPasteEditProvider {
             throw new NotImplementedError();
         });
         await this._provider.prepareDocumentPaste(doc, vscodeRanges, dataTransfer, token);
-        return DataTransfer.toDataTransferDTO(dataTransfer);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const entries = Array.from(dataTransfer).filter(([, value]) => !(value instanceof InternalDataTransferItem));
+        return DataTransfer.from(entries);
     }
     async providePasteEdits(requestId, resource, ranges, dataTransferDto, token) {
+        if (!this._provider.provideDocumentPasteEdits) {
+            return;
+        }
         const doc = this._documents.getDocument(resource);
         const vscodeRanges = ( (ranges.map(range => Range.to(range))));
         const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
@@ -441,6 +449,14 @@ class DocumentPasteEditProvider {
             return;
         }
         return {
+            id: edit.id ? this._extension.identifier.value + '.' + edit.id : this._extension.identifier.value,
+            label: edit.label ?? ( (localize(
+                'defaultPasteLabel',
+                "Paste using '{0}' extension",
+                this._extension.displayName || this._extension.name
+            ))),
+            detail: this._extension.displayName || this._extension.name,
+            priority: edit.priority ?? 0,
             insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
             additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
         };
@@ -846,7 +862,17 @@ class CompletionsAdapter {
         if (!resolvedItem) {
             return undefined;
         }
-        return this._convertCompletionItem(resolvedItem, id);
+        const enforcedResolvedItem = {
+            ...item,
+            documentation: resolvedItem.documentation,
+            detail: resolvedItem.detail,
+            additionalTextEdits: resolvedItem.additionalTextEdits
+        };
+        if (item.insertText !== resolvedItem.insertText) {
+            this._apiDeprecation.report('CompletionItem.insertText', this._extension, 'extension MAY NOT change \'insertText\' of a CompletionItem during resolve');
+            enforcedResolvedItem.insertText = resolvedItem.insertText;
+        }
+        return this._convertCompletionItem(enforcedResolvedItem, id);
     }
     releaseCompletionItems(id) {
         this._disposables.get(id)?.dispose();
@@ -1473,11 +1499,13 @@ class DocumentOnDropEditAdapter {
             return undefined;
         }
         return {
+            id: edit.id ? this._extension.identifier.value + '.' + edit.id : this._extension.identifier.value,
             label: edit.label ?? ( (localize(
                 'defaultDropLabel',
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             ))),
+            priority: edit.priority ?? 0,
             insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
             additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
         };
@@ -1961,7 +1989,7 @@ class ExtHostLanguageFeatures {
              (new DocumentOnDropEditAdapter(this._proxy, this._documents, provider, handle, extension)),
             extension
         ))));
-        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector, extension), extension.identifier, isProposedApiEnabled(extension, 'dropMetadata') ? metadata : undefined);
+        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector, extension), isProposedApiEnabled(extension, 'dropMetadata') ? metadata : undefined);
         return this._createDisposable(handle);
     }
     $provideDocumentOnDropEdits(handle, requestId, resource, position, dataTransferDto, token) {
@@ -1970,10 +1998,15 @@ class ExtHostLanguageFeatures {
     registerDocumentPasteEditProvider(extension, selector, provider, metadata) {
         const handle = this._nextHandle();
         this._adapter.set(handle, ( (new AdapterData(
-             (new DocumentPasteEditProvider(this._proxy, this._documents, provider, handle)),
+             (new DocumentPasteEditProvider(this._proxy, this._documents, provider, handle, extension)),
             extension
         ))));
-        this._proxy.$registerPasteEditProvider(handle, this._transformDocumentSelector(selector, extension), !!provider.prepareDocumentPaste, metadata.pasteMimeTypes);
+        this._proxy.$registerPasteEditProvider(handle, this._transformDocumentSelector(selector, extension), {
+            supportsCopy: !!provider.prepareDocumentPaste,
+            supportsPaste: !!provider.provideDocumentPasteEdits,
+            copyMimeTypes: metadata.copyMimeTypes,
+            pasteMimeTypes: metadata.pasteMimeTypes,
+        });
         return this._createDisposable(handle);
     }
     $prepareDocumentPaste(handle, resource, ranges, dataTransfer, token) {

package/dist/vscode/vs/workbench/api/common/extHostManagedSockets.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IExtHostManagedSockets = ( createDecorator('IExtHostManagedSockets'));
+export { IExtHostManagedSockets };