@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.0-next.0

package/vscode/src/vs/workbench/api/browser/mainThreadEditors.js

@@ -14,7 +14,9 @@ import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/c
 import { IWorkingCopyService } from '../../services/workingCopy/common/workingCopyService.js';
 import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+var MainThreadTextEditors_1;
 let MainThreadTextEditors = class MainThreadTextEditors {
+    static { MainThreadTextEditors_1 = this; }
     static { this.INSTANCE_COUNT = 0; }
     constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService, _configurationService) {
         this._editorLocator = _editorLocator;
@@ -23,7 +25,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
         this._editorGroupService = _editorGroupService;
         this._configurationService = _configurationService;
         this._toDispose = ( new DisposableStore());
-        this._instanceId = String(++MainThreadTextEditors.INSTANCE_COUNT);
+        this._instanceId = String(++MainThreadTextEditors_1.INSTANCE_COUNT);
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostEditors));
         this._textEditorsListenersMap = Object.create(null);
         this._editorPositionData = null;
@@ -204,7 +206,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
         return Promise.resolve([]);
     }
 };
-MainThreadTextEditors = ( __decorate([
+MainThreadTextEditors = MainThreadTextEditors_1 = ( __decorate([
     ( __param(2, ICodeEditorService)),
     ( __param(3, IEditorService)),
     ( __param(4, IEditorGroupsService)),

package/vscode/src/vs/workbench/api/browser/mainThreadInlineChat.js

@@ -16,9 +16,10 @@ let MainThreadInlineChat = class MainThreadInlineChat {
     dispose() {
         this._registrations.dispose();
     }
-    async $registerInteractiveEditorProvider(handle, debugName, supportsFeedback) {
+    async $registerInteractiveEditorProvider(handle, label, debugName, supportsFeedback) {
         const unreg = this._inlineChatService.addProvider({
             debugName,
+            label,
             prepareInlineChatSession: async (model, range, token) => {
                 const session = await this._proxy.$prepareSession(handle, model.uri, range, token);
                 if (!session) {

package/vscode/src/vs/workbench/api/browser/mainThreadLanguageFeatures.js

@@ -291,8 +291,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         }
         this._registrations.set(handle, this._languageFeaturesService.codeActionProvider.register(selector, provider));
     }
-    $registerPasteEditProvider(handle, selector, metadata) {
-        const provider = ( new MainThreadPasteEditProvider(handle, this._proxy, metadata, this._uriIdentService));
+    $registerPasteEditProvider(handle, selector, id, metadata) {
+        const provider = ( new MainThreadPasteEditProvider(handle, this._proxy, id, metadata, this._uriIdentService));
         this._pasteEditProviders.set(handle, provider);
         this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentPasteEditProvider.register(selector, provider), toDisposable(() => this._pasteEditProviders.delete(handle))));
     }
@@ -751,8 +751,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         }));
     }
-    $registerDocumentOnDropEditProvider(handle, selector, metadata) {
-        const provider = ( new MainThreadDocumentOnDropEditProvider(handle, metadata, this._proxy, this._uriIdentService));
+    $registerDocumentOnDropEditProvider(handle, selector, id, metadata) {
+        const provider = ( new MainThreadDocumentOnDropEditProvider(handle, this._proxy, id, metadata, this._uriIdentService));
         this._documentOnDropEditProviders.set(handle, provider);
         this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentOnDropEditProvider.register(selector, provider), toDisposable(() => this._documentOnDropEditProviders.delete(handle))));
     }
@@ -763,6 +763,10 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         }
         return provider.resolveDocumentOnDropFileData(requestId, dataId);
     }
+    $registerMappedEditsProvider(handle, selector) {
+        const provider = ( new MainThreadMappedEditsProvider(handle, this._proxy, this._uriIdentService));
+        this._registrations.set(handle, this._languageFeaturesService.mappedEditsProvider.register(selector, provider));
+    }
 };
 MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadLanguageFeatures),
@@ -772,11 +776,12 @@ MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = __decorate([
     ( __param(4, IUriIdentityService))
 ], MainThreadLanguageFeatures);
 let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
-    constructor(handle, _proxy, metadata, _uriIdentService) {
-        this.handle = handle;
+    constructor(_handle, _proxy, id, metadata, _uriIdentService) {
+        this._handle = _handle;
         this._proxy = _proxy;
         this._uriIdentService = _uriIdentService;
         this.dataTransfers = ( new DataTransferFileCache());
+        this.id = id;
         this.copyMimeTypes = metadata.copyMimeTypes;
         this.pasteMimeTypes = metadata.pasteMimeTypes;
         if (metadata.supportsCopy) {
@@ -785,7 +790,7 @@ let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
                 if (token.isCancellationRequested) {
                     return undefined;
                 }
-                const newDataTransfer = await this._proxy.$prepareDocumentPaste(handle, model.uri, selections, dataTransferDto, token);
+                const newDataTransfer = await this._proxy.$prepareDocumentPaste(_handle, model.uri, selections, dataTransferDto, token);
                 if (!newDataTransfer) {
                     return undefined;
                 }
@@ -804,7 +809,7 @@ let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
                     if (token.isCancellationRequested) {
                         return;
                     }
-                    const result = await this._proxy.$providePasteEdits(this.handle, request.id, model.uri, selections, dataTransferDto, token);
+                    const result = await this._proxy.$providePasteEdits(this._handle, request.id, model.uri, selections, dataTransferDto, token);
                     if (!result) {
                         return;
                     }
@@ -824,14 +829,15 @@ let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
     }
 };
 MainThreadPasteEditProvider = ( __decorate([
-    ( __param(3, IUriIdentityService))
+    ( __param(4, IUriIdentityService))
 ], MainThreadPasteEditProvider));
 let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditProvider {
-    constructor(handle, metadata, _proxy, _uriIdentService) {
-        this.handle = handle;
+    constructor(_handle, _proxy, id, metadata, _uriIdentService) {
+        this._handle = _handle;
         this._proxy = _proxy;
         this._uriIdentService = _uriIdentService;
         this.dataTransfers = ( new DataTransferFileCache());
+        this.id = id;
         this.dropMimeTypes = metadata?.dropMimeTypes ?? ['*/*'];
     }
     async provideDocumentOnDropEdits(model, position, dataTransfer, token) {
@@ -841,7 +847,7 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
             if (token.isCancellationRequested) {
                 return;
             }
-            const edit = await this._proxy.$provideDocumentOnDropEdits(this.handle, request.id, model.uri, position, dataTransferDto, token);
+            const edit = await this._proxy.$provideDocumentOnDropEdits(this._handle, request.id, model.uri, position, dataTransferDto, token);
             if (!edit) {
                 return;
             }
@@ -859,7 +865,7 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
     }
 };
 MainThreadDocumentOnDropEditProvider = ( __decorate([
-    ( __param(3, IUriIdentityService))
+    ( __param(4, IUriIdentityService))
 ], MainThreadDocumentOnDropEditProvider));
 class MainThreadDocumentSemanticTokensProvider {
     constructor(_proxy, _handle, _legend, onDidChange) {
@@ -925,4 +931,15 @@ class MainThreadDocumentRangeSemanticTokensProvider {
         throw new Error(`Unexpected`);
     }
 }
-export { MainThreadDocumentRangeSemanticTokensProvider, MainThreadDocumentSemanticTokensProvider, MainThreadLanguageFeatures };
+class MainThreadMappedEditsProvider {
+    constructor(_handle, _proxy, _uriService) {
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this._uriService = _uriService;
+    }
+    async provideMappedEdits(document, codeBlocks, context, token) {
+        const res = await this._proxy.$provideMappedEdits(this._handle, document.uri, codeBlocks, context, token);
+        return res ? reviveWorkspaceEditDto(res, this._uriService) : null;
+    }
+}
+export { MainThreadDocumentRangeSemanticTokensProvider, MainThreadDocumentSemanticTokensProvider, MainThreadLanguageFeatures, MainThreadMappedEditsProvider };

package/vscode/src/vs/workbench/api/browser/mainThreadManagedSockets.js

@@ -1,12 +1,10 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ManagedSocket, connectManagedSocket } from '../../../platform/remote/common/managedSocket.js';
+import { IRemoteSocketFactoryService } from '../../../platform/remote/common/remoteSocketFactoryService.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { IRemoteSocketFactoryService } from '../../../platform/remote/common/remoteSocketFactoryService.js';
-import { SocketDiagnostics } from '../../../base/parts/ipc/common/ipc.net.js';
-import { PauseableEmitter, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { makeRawSocketHeaders, socketRawEndHeaderSequence } from '../../../platform/remote/common/managedSocket.js';
 let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable {
     constructor(extHostContext, _remoteSocketFactoryService) {
         super();
@@ -34,7 +32,7 @@ let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable
                             onEnd: ( new Emitter()),
                         };
                         that._remoteSockets.set(socketId, half);
-                        ManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half)
+                        MainThreadManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half)
                             .then(socket => {
                             socket.onDidDispose(() => that._remoteSockets.delete(socketId));
                             resolve(socket);
@@ -70,77 +68,24 @@ MainThreadManagedSockets = __decorate([
     extHostNamedCustomer(MainContext.MainThreadManagedSockets),
     ( __param(1, IRemoteSocketFactoryService))
 ], MainThreadManagedSockets);
-class ManagedSocket extends Disposable {
+class MainThreadManagedSocket extends ManagedSocket {
     static connect(socketId, proxy, path, query, debugLabel, half) {
-        const socket = ( new ManagedSocket(socketId, proxy, debugLabel, half.onClose, half.onData, half.onEnd));
-        socket.write(VSBuffer.fromString(makeRawSocketHeaders(path, query)));
-        const d = ( new DisposableStore());
-        return ( new Promise((resolve, reject) => {
-            let dataSoFar;
-            d.add(socket.onData(d => {
-                if (!dataSoFar) {
-                    dataSoFar = d;
-                }
-                else {
-                    dataSoFar = VSBuffer.concat([dataSoFar, d], dataSoFar.byteLength + d.byteLength);
-                }
-                const index = dataSoFar.indexOf(socketRawEndHeaderSequence);
-                if (index === -1) {
-                    return;
-                }
-                resolve(socket);
-                socket.pauseData();
-                const rest = dataSoFar.slice(index + socketRawEndHeaderSequence.byteLength);
-                if (rest.byteLength) {
-                    half.onData.fire(rest);
-                }
-            }));
-            d.add(socket.onClose(err => reject(err ?? ( new Error('socket closed')))));
-            d.add(socket.onEnd(() => reject(( new Error('socket ended')))));
-        })).finally(() => d.dispose());
+        const socket = ( new MainThreadManagedSocket(socketId, proxy, debugLabel, half));
+        return connectManagedSocket(socket, path, query, debugLabel, half);
     }
-    constructor(socketId, proxy, debugLabel, onCloseEmitter, onDataEmitter, onEndEmitter) {
-        super();
+    constructor(socketId, proxy, debugLabel, half) {
+        super(debugLabel, half);
         this.socketId = socketId;
         this.proxy = proxy;
-        this.debugLabel = debugLabel;
-        this.pausableDataEmitter = this._register(( new PauseableEmitter()));
-        this.onData = (...args) => {
-            if (this.pausableDataEmitter.isPaused) {
-                queueMicrotask(() => this.pausableDataEmitter.resume());
-            }
-            return this.pausableDataEmitter.event(...args);
-        };
-        this.didDisposeEmitter = this._register(( new Emitter()));
-        this.onDidDispose = this.didDisposeEmitter.event;
-        this.ended = false;
-        this._register(onDataEmitter);
-        this._register(onDataEmitter.event(data => this.pausableDataEmitter.fire(data)));
-        this.onClose = this._register(onCloseEmitter).event;
-        this.onEnd = this._register(onEndEmitter).event;
-    }
-    pauseData() {
-        this.pausableDataEmitter.pause();
     }
     write(buffer) {
         this.proxy.$remoteSocketWrite(this.socketId, buffer);
     }
-    end() {
-        this.ended = true;
+    closeRemote() {
         this.proxy.$remoteSocketEnd(this.socketId);
     }
     drain() {
         return this.proxy.$remoteSocketDrain(this.socketId);
     }
-    traceSocketEvent(type, data) {
-        SocketDiagnostics.traceSocketEvent(this, this.debugLabel, type, data);
-    }
-    dispose() {
-        if (!this.ended) {
-            this.proxy.$remoteSocketEnd(this.socketId);
-        }
-        this.didDisposeEmitter.fire();
-        super.dispose();
-    }
 }
-export { MainThreadManagedSockets, ManagedSocket };
+export { MainThreadManagedSocket, MainThreadManagedSockets };

package/vscode/src/vs/workbench/api/browser/mainThreadStorage.js

@@ -2,6 +2,7 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IExtensionStorageService } from '../../../platform/extensionManagement/common/extensionStorage.js';
 import { migrateExtensionStorage } from '../../services/extensions/common/extensionStorageMigration.js';
@@ -13,17 +14,17 @@ let MainThreadStorage = class MainThreadStorage {
         this._storageService = _storageService;
         this._instantiationService = _instantiationService;
         this._logService = _logService;
+        this._storageListener = ( new DisposableStore());
         this._sharedStorageKeysToWatch = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStorage));
-        this._storageListener = this._storageService.onDidChangeValue(e => {
-            const shared = e.scope === 0 ;
-            if (shared && ( this._sharedStorageKeysToWatch.has(e.key))) {
-                const rawState = this._extensionStorageService.getExtensionStateRaw(e.key, shared);
+        this._storageListener.add(this._storageService.onDidChangeValue(0 , undefined, this._storageListener)(e => {
+            if (( this._sharedStorageKeysToWatch.has(e.key))) {
+                const rawState = this._extensionStorageService.getExtensionStateRaw(e.key, true);
                 if (typeof rawState === 'string') {
-                    this._proxy.$acceptValue(shared, e.key, rawState);
+                    this._proxy.$acceptValue(true, e.key, rawState);
                 }
             }
-        });
+        }));
     }
     dispose() {
         this._storageListener.dispose();

package/vscode/src/vs/workbench/api/browser/mainThreadTask.js

@@ -288,7 +288,7 @@ var TaskSourceDTO;
         }
         else {
             scope = 3 ;
-            workspaceFolder = types.withNullAsUndefined(workspace.getWorkspaceFolder(URI.revive(value.scope)));
+            workspaceFolder = workspace.getWorkspaceFolder(URI.revive(value.scope)) ?? undefined;
         }
         const result = {
             kind: TaskSourceKind.Extension,

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalService.js

@@ -13,12 +13,10 @@ import { IEnvironmentVariableService } from '../../contrib/terminal/common/envir
 import { serializeEnvironmentVariableCollection, deserializeEnvironmentVariableCollection, deserializeEnvironmentDescriptionMap } from '../../../platform/terminal/common/environmentVariableShared.js';
 import { ITerminalProfileResolverService, ITerminalProfileService } from '../../contrib/terminal/common/terminal.js';
 import { IRemoteAgentService } from '../../services/remote/common/remoteAgentService.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { TerminalQuickFixType } from '../common/extHostTypes.js';
 import { ITerminalLinkProviderService } from '../../contrib/terminalContrib/links/browser/links.js';
-import { ITerminalQuickFixService } from '../../contrib/terminalContrib/quickFix/browser/quickFix.js';
+import { ITerminalQuickFixService, TerminalQuickFixType } from '../../contrib/terminalContrib/quickFix/browser/quickFix.js';
 let MainThreadTerminalService = class MainThreadTerminalService {
     constructor(_extHostContext, _terminalService, _terminalLinkProviderService, _terminalQuickFixService, _instantiationService, _environmentVariableService, _logService, _terminalProfileResolverService, remoteAgentService, _terminalGroupService, _terminalEditorService, _terminalProfileService) {
         this._extHostContext = _extHostContext;
@@ -38,6 +36,7 @@ let MainThreadTerminalService = class MainThreadTerminalService {
         this._profileProviders = ( new Map());
         this._quickFixProviders = ( new Map());
         this._dataEventTracker = ( new MutableDisposable());
+        this._sendCommandEventListener = ( new MutableDisposable());
         this._os = OS;
         this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostTerminalService));
         this._store.add(_terminalService.onDidCreateInstance((instance) => {
@@ -85,7 +84,7 @@ let MainThreadTerminalService = class MainThreadTerminalService {
         }
     }
     async _updateDefaultProfile() {
-        const remoteAuthority = withNullAsUndefined(this._extHostContext.remoteAuthority);
+        const remoteAuthority = this._extHostContext.remoteAuthority ?? undefined;
         const defaultProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os });
         const defaultAutomationProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os, allowAutomationShell: true });
         this._proxy.$acceptDefaultProfile(...(await Promise.all([defaultProfile, defaultAutomationProfile])));
@@ -183,6 +182,26 @@ let MainThreadTerminalService = class MainThreadTerminalService {
     $stopSendingDataEvents() {
         this._dataEventTracker.clear();
     }
+    $startSendingCommandEvents() {
+        this._logService.info('$startSendingCommandEvents');
+        if (this._sendCommandEventListener.value) {
+            return;
+        }
+        const multiplexer = this._terminalService.onInstanceCapabilityEvent(2 , capability => capability.onCommandFinished);
+        multiplexer.event(e => {
+            this._onDidExecuteCommand(e.instance.instanceId, {
+                commandLine: e.data.command,
+                cwd: e.data.cwd,
+                exitCode: e.data.exitCode,
+                output: e.data.getOutput()
+            });
+        });
+        this._sendCommandEventListener.value = multiplexer;
+    }
+    $stopSendingCommandEvents() {
+        this._logService.info('$stopSendingCommandEvents');
+        this._sendCommandEventListener.clear();
+    }
     $startLinkProvider() {
         this._linkProvider?.dispose();
         this._linkProvider = this._terminalLinkProviderService.registerLinkProvider(( new ExtensionTerminalLinkProvider(this._proxy)));
@@ -207,19 +226,19 @@ let MainThreadTerminalService = class MainThreadTerminalService {
     }
     async $registerQuickFixProvider(id, extensionId) {
         this._quickFixProviders.set(id, this._terminalQuickFixService.registerQuickFixProvider(id, {
-            provideTerminalQuickFixes: async (terminalCommand, lines, option, token) => {
+            provideTerminalQuickFixes: async (terminalCommand, lines, options, token) => {
                 if (token.isCancellationRequested) {
                     return;
                 }
-                if (option.outputMatcher?.length && option.outputMatcher.length > 40) {
-                    option.outputMatcher.length = 40;
+                if (options.outputMatcher?.length && options.outputMatcher.length > 40) {
+                    options.outputMatcher.length = 40;
                     this._logService.warn('Cannot exceed output matcher length of 40');
                 }
-                const commandLineMatch = terminalCommand.command.match(option.commandLineMatcher);
-                if (!commandLineMatch) {
+                const commandLineMatch = terminalCommand.command.match(options.commandLineMatcher);
+                if (!commandLineMatch || !lines) {
                     return;
                 }
-                const outputMatcher = option.outputMatcher;
+                const outputMatcher = options.outputMatcher;
                 let outputMatch;
                 if (outputMatcher) {
                     outputMatch = getOutputMatchForLines(lines, outputMatcher);
@@ -251,6 +270,9 @@ let MainThreadTerminalService = class MainThreadTerminalService {
     _onTerminalData(terminalId, data) {
         this._proxy.$acceptTerminalProcessData(terminalId, data);
     }
+    _onDidExecuteCommand(terminalId, command) {
+        this._proxy.$acceptDidExecuteCommand(terminalId, command);
+    }
     _onTitleChanged(terminalId, name) {
         this._proxy.$acceptTerminalTitleChange(terminalId, name);
     }
@@ -375,11 +397,14 @@ function getOutputMatchForLines(lines, outputMatcher) {
     return match ? { regexMatch: match, outputLines: lines } : undefined;
 }
 function parseQuickFix(id, source, fix) {
-    let type = TerminalQuickFixType.Command;
+    let type = TerminalQuickFixType.TerminalCommand;
     if ('uri' in fix) {
         fix.uri = URI.revive(fix.uri);
         type = TerminalQuickFixType.Opener;
     }
+    else if ('id' in fix) {
+        type = TerminalQuickFixType.VscodeCommand;
+    }
     return { id, type, source, ...fix };
 }
 export { MainThreadTerminalService, getOutputMatchForLines };

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -3,7 +3,7 @@ import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { ExtHostContext, CandidatePortSource, MainContext } from '../common/extHost.protocol.js';
 import { TunnelDtoConverter } from '../common/extHostTunnelService.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, TunnelSource, TunnelCloseReason, IRemoteExplorerService, makeAddress } from '../../services/remote/common/remoteExplorerService.js';
+import { PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, IRemoteExplorerService } from '../../services/remote/common/remoteExplorerService.js';
 import { ITunnelService, TunnelProtocol } from '../../../platform/tunnel/common/tunnel.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -13,7 +13,7 @@ import { IRemoteAgentService } from '../../services/remote/common/remoteAgentSer
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { forwardedPortsViewEnabled } from '../../contrib/remote/browser/tunnelView.js';
+import { TunnelSource, TunnelCloseReason, forwardedPortsViewEnabled, makeAddress } from '../../services/remote/common/tunnelModel.js';
 let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
         super();
@@ -89,18 +89,18 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
             },
             elevateIfNeeded: false
         });
-        if (tunnel) {
-            if (!this.elevateionRetry
-                && (tunnelOptions.localAddressPort !== undefined)
-                && (tunnel.tunnelLocalPort !== undefined)
-                && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort)
-                && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort)
-                && this.tunnelService.canElevate) {
-                this.elevationPrompt(tunnelOptions, tunnel, source);
-            }
-            return TunnelDtoConverter.fromServiceTunnel(tunnel);
+        if (!tunnel || (typeof tunnel === 'string')) {
+            return undefined;
+        }
+        if (!this.elevateionRetry
+            && (tunnelOptions.localAddressPort !== undefined)
+            && (tunnel.tunnelLocalPort !== undefined)
+            && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort)
+            && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort)
+            && this.tunnelService.canElevate) {
+            this.elevationPrompt(tunnelOptions, tunnel, source);
         }
-        return undefined;
+        return TunnelDtoConverter.fromServiceTunnel(tunnel);
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
         return this.notificationService.prompt(Severity.Info, ( nls.localize(
@@ -152,11 +152,15 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         const tunnelProvider = {
             forwardPort: (tunnelOptions, tunnelCreationOptions) => {
                 const forward = this._proxy.$forwardPort(tunnelOptions, tunnelCreationOptions);
-                return forward.then(tunnel => {
-                    this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
-                    if (!tunnel) {
+                return forward.then(tunnelOrError => {
+                    if (!tunnelOrError) {
                         return undefined;
                     }
+                    else if (typeof tunnelOrError === 'string') {
+                        return tunnelOrError;
+                    }
+                    const tunnel = tunnelOrError;
+                    this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
                     return {
                         tunnelRemotePort: tunnel.remoteAddress.port,
                         tunnelRemoteHost: tunnel.remoteAddress.host,
@@ -173,10 +177,10 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
                 });
             }
         };
-        this.tunnelService.setTunnelProvider(tunnelProvider);
         if (features) {
             this.tunnelService.setTunnelFeatures(features);
         }
+        this.tunnelService.setTunnelProvider(tunnelProvider);
         this.contextKeyService.createKey(forwardedPortsViewEnabled.key, true);
     }
     async $setCandidateFilter() {

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -10,7 +10,9 @@ import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/pr
 import { ExtHostContext } from '../common/extHost.protocol.js';
 import { deserializeWebviewMessage, serializeWebviewMessage } from '../common/extHostWebviewMessaging.js';
 import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
+var MainThreadWebviews_1;
 let MainThreadWebviews = class MainThreadWebviews extends Disposable {
+    static { MainThreadWebviews_1 = this; }
     static { this.standardSupportedLinkSchemes = ( (new Set([
         Schemas.http,
         Schemas.https,
@@ -69,7 +71,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
         }
     }
     isSupportedLink(webview, link) {
-        if (( (MainThreadWebviews.standardSupportedLinkSchemes.has(link.scheme)))) {
+        if (( (MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme)))) {
             return true;
         }
         if (!isWeb && this._productService.urlProtocol === link.scheme) {
@@ -108,7 +110,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
 		</html>`;
     }
 };
-MainThreadWebviews = ( (__decorate([
+MainThreadWebviews = MainThreadWebviews_1 = ( (__decorate([
     ( (__param(1, IOpenerService))),
     ( (__param(2, IProductService)))
 ], MainThreadWebviews)));

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

@@ -2,7 +2,6 @@ import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.
 import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
@@ -135,11 +134,11 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const includeFolder = URI.revive(_includeFolder);
         const workspace = this._contextService.getWorkspace();
         const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, {
-            maxResults: withNullAsUndefined(maxResults),
+            maxResults: maxResults ?? undefined,
             disregardExcludeSettings: (excludePatternOrDisregardExcludes === false) || undefined,
             disregardSearchExcludeSettings: true,
             disregardIgnoreFiles: true,
-            includePattern: withNullAsUndefined(includePattern),
+            includePattern: includePattern ?? undefined,
             excludePattern: typeof excludePatternOrDisregardExcludes === 'string' ? excludePatternOrDisregardExcludes : undefined,
             _reason: 'startFileSearch'
         });

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

@@ -6,6 +6,7 @@ import { getCodiconAriaLabel } from 'monaco-editor/esm/vs/base/common/iconLabels
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
+import { STATUS_BAR_WARNING_ITEM_BACKGROUND, STATUS_BAR_ERROR_ITEM_BACKGROUND } from '../../common/theme.js';
 const IExtensionStatusBarItemService = ( createDecorator('IExtensionStatusBarItemService'));
 let ExtensionStatusBarItemService = class ExtensionStatusBarItemService {
     constructor(_statusbarService) {
@@ -33,7 +34,15 @@ let ExtensionStatusBarItemService = class ExtensionStatusBarItemService {
                 ariaLabel += `, ${tooltipString}`;
             }
         }
-        const entry = { name, text, tooltip, command, color, backgroundColor, ariaLabel, role };
+        let kind = undefined;
+        switch (backgroundColor?.id) {
+            case STATUS_BAR_ERROR_ITEM_BACKGROUND:
+            case STATUS_BAR_WARNING_ITEM_BACKGROUND:
+                kind = backgroundColor.id === STATUS_BAR_ERROR_ITEM_BACKGROUND ? 'error' : 'warning';
+                color = undefined;
+                backgroundColor = undefined;
+        }
+        const entry = { name, text, tooltip, command, color, backgroundColor, ariaLabel, role, kind };
         if (typeof priority === 'undefined') {
             priority = 0;
         }

package/vscode/src/vs/workbench/api/browser/viewsExtensionPoint.js

@@ -557,7 +557,7 @@ let ViewsExtensionHandler = class ViewsExtensionHandler {
                         name: item.name,
                         when: ContextKeyExpr.deserialize(item.when),
                         containerIcon: icon || viewContainer?.icon,
-                        containerTitle: item.contextualTitle || viewContainer?.title,
+                        containerTitle: item.contextualTitle || (viewContainer && (typeof viewContainer.title === 'string' ? viewContainer.title : viewContainer.title.value)),
                         canToggleVisibility: true,
                         canMoveView: viewContainer?.id !== VIEWLET_ID,
                         treeView: type === ViewType.Tree ? this.instantiationService.createInstance(CustomTreeView, item.id, item.name, extension.description.identifier.value) : undefined,

package/vscode/src/vs/workbench/api/common/extHost.api.impl.d.ts

@@ -11,4 +11,4 @@ interface IExtensionApiFactory {
     (extension: IExtensionDescription, extensionInfo: IExtensionRegistries, configProvider: ExtHostConfigProvider): typeof vscode;
 }
 
-export { IExtensionApiFactory, IExtensionRegistries };
+export type { IExtensionApiFactory, IExtensionRegistries };