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

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.d.ts

@@ -42,7 +42,9 @@ declare class XtermTerminal extends DisposableStore implements IXtermTerminal, I
     readonly raw: Terminal;
     private _core;
     private static _suggestedRendererType;
+    private static _checkedWebglCompatible;
     private _attached?;
+    private _isPhysicalMouseWheel;
     private _markNavigationAddon;
     private _shellIntegrationAddon;
     private _decorationAddon;
@@ -100,9 +102,10 @@ declare class XtermTerminal extends DisposableStore implements IXtermTerminal, I
     getSelectionAsHtml(command?: ITerminalCommand): Promise<string>;
     attachToElement(container: HTMLElement, partialOptions?: Partial<IXtermAttachToElementOptions>): HTMLElement;
     private _setFocused;
-    write(data: string | Uint8Array): void;
+    write(data: string | Uint8Array, callback?: () => void): void;
     resize(columns: number, rows: number): void;
     updateConfig(): void;
+    private _updateSmoothScrolling;
     private _shouldLoadWebgl;
     private _shouldLoadCanvas;
     forceRedraw(): void;
@@ -128,13 +131,16 @@ declare class XtermTerminal extends DisposableStore implements IXtermTerminal, I
     clearBuffer(): void;
     hasSelection(): boolean;
     clearSelection(): void;
+    selectMarkedRange(fromMarkerId: string, toMarkerId: string, scrollIntoView?: boolean): void;
     selectAll(): void;
     focus(): void;
     copySelection(asHtml?: boolean, command?: ITerminalCommand): Promise<void>;
     private _setCursorBlink;
     private _setCursorStyle;
+    private _setCursorStyleInactive;
     private _setCursorWidth;
     private _enableWebglRenderer;
+    private _disableWebglForThisSession;
     private _enableCanvasRenderer;
     protected _getCanvasAddonConstructor(): Promise<typeof CanvasAddon>;
     private _refreshImageAddon;

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.js

@@ -22,6 +22,9 @@ import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/com
 import { TerminalContextKeys } from '../../common/terminalContextKey.js';
 import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { MouseWheelClassifier } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { StandardWheelEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+var XtermTerminal_1;
 let CanvasAddon;
 let ImageAddon;
 let SearchAddon;
@@ -44,7 +47,9 @@ function getFullBufferLineAsString(lineIndex, buffer) {
     return { lineData, lineIndex };
 }
 let XtermTerminal = class XtermTerminal extends DisposableStore {
+    static { XtermTerminal_1 = this; }
     static { this._suggestedRendererType = undefined; }
+    static { this._checkedWebglCompatible = false; }
     get findResult() { return this._lastFindResult; }
     get isStdinDisabled() { return !!this.raw.options.disableStdin; }
     get markTracker() { return this._markNavigationAddon; }
@@ -74,22 +79,23 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         this._themeService = _themeService;
         this._telemetryService = _telemetryService;
         this._clipboardService = _clipboardService;
+        this._isPhysicalMouseWheel = MouseWheelClassifier.INSTANCE.isPhysicalMouseWheel();
         this._attachedDisposables = this.add(( new DisposableStore()));
-        this._onDidRequestRunCommand = ( new Emitter());
+        this._onDidRequestRunCommand = this.add(( new Emitter()));
         this.onDidRequestRunCommand = this._onDidRequestRunCommand.event;
-        this._onDidRequestFocus = ( new Emitter());
+        this._onDidRequestFocus = this.add(( new Emitter()));
         this.onDidRequestFocus = this._onDidRequestFocus.event;
-        this._onDidRequestSendText = ( new Emitter());
+        this._onDidRequestSendText = this.add(( new Emitter()));
         this.onDidRequestSendText = this._onDidRequestSendText.event;
-        this._onDidRequestFreePort = ( new Emitter());
+        this._onDidRequestFreePort = this.add(( new Emitter()));
         this.onDidRequestFreePort = this._onDidRequestFreePort.event;
-        this._onDidChangeFindResults = ( new Emitter());
+        this._onDidChangeFindResults = this.add(( new Emitter()));
         this.onDidChangeFindResults = this._onDidChangeFindResults.event;
-        this._onDidChangeSelection = ( new Emitter());
+        this._onDidChangeSelection = this.add(( new Emitter()));
         this.onDidChangeSelection = this._onDidChangeSelection.event;
-        this._onDidChangeFocus = ( new Emitter());
+        this._onDidChangeFocus = this.add(( new Emitter()));
         this.onDidChangeFocus = this._onDidChangeFocus.event;
-        this._onDidDispose = ( new Emitter());
+        this._onDidDispose = this.add(( new Emitter()));
         this.onDidDispose = this._onDidDispose.event;
         const font = this._configHelper.getFont(undefined, true);
         const config = this._configHelper.config;
@@ -113,7 +119,8 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
             minimumContrastRatio: config.minimumContrastRatio,
             tabStopWidth: config.tabStopWidth,
             cursorBlink: config.cursorBlinking,
-            cursorStyle: config.cursorStyle === 'line' ? 'bar' : config.cursorStyle,
+            cursorStyle: vscodeToXtermCursorStyle(config.cursorStyle),
+            cursorInactiveStyle: vscodeToXtermCursorStyle(config.cursorStyleInactive),
             cursorWidth: config.cursorWidth,
             macOptionIsMeta: config.macOptionIsMeta,
             macOptionClickForcesSelection: config.macOptionClickForcesSelection,
@@ -123,12 +130,13 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
             scrollSensitivity: config.mouseWheelScrollSensitivity,
             wordSeparator: config.wordSeparators,
             overviewRulerWidth: 10,
-            smoothScrollDuration: config.smoothScrolling ? 125  : 0
+            ignoreBracketedPasteMode: config.ignoreBracketedPasteMode
         })));
+        this._updateSmoothScrolling();
         this._core = this.raw._core;
         this.add(this._configurationService.onDidChangeConfiguration(async (e) => {
             if (e.affectsConfiguration("terminal.integrated.gpuAcceleration" )) {
-                XtermTerminal._suggestedRendererType = undefined;
+                XtermTerminal_1._suggestedRendererType = undefined;
             }
             if (e.affectsConfiguration('terminal.integrated') || e.affectsConfiguration('editor.fastScrollSensitivity') || e.affectsConfiguration('editor.mouseWheelScrollSensitivity') || e.affectsConfiguration('editor.multiCursorModifier')) {
                 this.updateConfig();
@@ -227,6 +235,15 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         ad.add(dom.addDisposableListener(this.raw.textarea, 'focus', () => this._setFocused(true)));
         ad.add(dom.addDisposableListener(this.raw.textarea, 'blur', () => this._setFocused(false)));
         ad.add(dom.addDisposableListener(this.raw.textarea, 'focusout', () => this._setFocused(false)));
+        ad.add(dom.addDisposableListener(this.raw.element, dom.EventType.MOUSE_WHEEL, (e) => {
+            const classifier = MouseWheelClassifier.INSTANCE;
+            classifier.acceptStandardWheelEvent(( new StandardWheelEvent(e)));
+            const value = classifier.isPhysicalMouseWheel();
+            if (value !== this._isPhysicalMouseWheel) {
+                this._isPhysicalMouseWheel = value;
+                this._updateSmoothScrolling();
+            }
+        }, { passive: true }));
         this._suggestAddon?.setContainer(container);
         this._attached = { container, options };
         return this._attached?.container.querySelector('.xterm-screen');
@@ -236,8 +253,8 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         this._anyTerminalFocusContextKey.set(isFocused);
         this._anyFocusedTerminalHasSelection.set(isFocused && this.raw.hasSelection());
     }
-    write(data) {
-        this.raw.write(data);
+    write(data, callback) {
+        this.raw.write(data, callback);
     }
     resize(columns, rows) {
         this.raw.resize(columns, rows);
@@ -247,6 +264,7 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         this.raw.options.altClickMovesCursor = config.altClickMovesCursor;
         this._setCursorBlink(config.cursorBlinking);
         this._setCursorStyle(config.cursorStyle);
+        this._setCursorStyleInactive(config.cursorStyleInactive);
         this._setCursorWidth(config.cursorWidth);
         this.raw.options.scrollback = config.scrollback;
         this.raw.options.drawBoldTextInBrightColors = config.drawBoldTextInBrightColors;
@@ -261,7 +279,8 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         this.raw.options.rightClickSelectsWord = config.rightClickBehavior === 'selectWord';
         this.raw.options.wordSeparator = config.wordSeparators;
         this.raw.options.customGlyphs = config.customGlyphs;
-        this.raw.options.smoothScrollDuration = config.smoothScrolling ? 125  : 0;
+        this.raw.options.ignoreBracketedPasteMode = config.ignoreBracketedPasteMode;
+        this._updateSmoothScrolling();
         if (this._attached?.options.enableGpu) {
             if (this._shouldLoadWebgl()) {
                 this._enableWebglRenderer();
@@ -277,11 +296,14 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
             }
         }
     }
+    _updateSmoothScrolling() {
+        this.raw.options.smoothScrollDuration = this._configHelper.config.smoothScrolling && this._isPhysicalMouseWheel ? 125  : 0;
+    }
     _shouldLoadWebgl() {
-        return !isSafari && (this._configHelper.config.gpuAcceleration === 'auto' && XtermTerminal._suggestedRendererType === undefined) || this._configHelper.config.gpuAcceleration === 'on';
+        return !isSafari && (this._configHelper.config.gpuAcceleration === 'auto' && XtermTerminal_1._suggestedRendererType === undefined) || this._configHelper.config.gpuAcceleration === 'on';
     }
     _shouldLoadCanvas() {
-        return (this._configHelper.config.gpuAcceleration === 'auto' && (XtermTerminal._suggestedRendererType === undefined || XtermTerminal._suggestedRendererType === 'canvas')) || this._configHelper.config.gpuAcceleration === 'canvas';
+        return (this._configHelper.config.gpuAcceleration === 'auto' && (XtermTerminal_1._suggestedRendererType === undefined || XtermTerminal_1._suggestedRendererType === 'canvas')) || this._configHelper.config.gpuAcceleration === 'canvas';
     }
     forceRedraw() {
         this.raw.clearTextureAtlas();
@@ -406,6 +428,21 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
     clearSelection() {
         this.raw.clearSelection();
     }
+    selectMarkedRange(fromMarkerId, toMarkerId, scrollIntoView = false) {
+        const detectionCapability = this.shellIntegration.capabilities.get(4 );
+        if (!detectionCapability) {
+            return;
+        }
+        const start = detectionCapability.getMark(fromMarkerId);
+        const end = detectionCapability.getMark(toMarkerId);
+        if (start === undefined || end === undefined) {
+            return;
+        }
+        this.raw.selectLines(start.line, end.line);
+        if (scrollIntoView) {
+            this.raw.scrollToLine(start.line);
+        }
+    }
     selectAll() {
         this.raw.focus();
         this.raw.selectAll();
@@ -446,8 +483,15 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         }
     }
     _setCursorStyle(style) {
-        if (this.raw.options.cursorStyle !== style) {
-            this.raw.options.cursorStyle = (style === 'line') ? 'bar' : style;
+        const mapped = vscodeToXtermCursorStyle(style);
+        if (this.raw.options.cursorStyle !== mapped) {
+            this.raw.options.cursorStyle = mapped;
+        }
+    }
+    _setCursorStyleInactive(style) {
+        const mapped = vscodeToXtermCursorStyle(style);
+        if (this.raw.options.cursorInactiveStyle !== mapped) {
+            this.raw.options.cursorInactiveStyle = mapped;
         }
     }
     _setCursorWidth(width) {
@@ -459,6 +503,19 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
         if (!this.raw.element || this._webglAddon) {
             return;
         }
+        if (!XtermTerminal_1._checkedWebglCompatible) {
+            XtermTerminal_1._checkedWebglCompatible = true;
+            const checkCanvas = document.createElement('canvas');
+            const checkGl = checkCanvas.getContext('webgl2');
+            const debugInfo = checkGl?.getExtension('WEBGL_debug_renderer_info');
+            if (checkGl && debugInfo) {
+                const renderer = checkGl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+                if (renderer.startsWith('ANGLE (Google, Vulkan 1.3.0 (SwiftShader Device (Subzero)')) {
+                    this._disableWebglForThisSession();
+                    return;
+                }
+            }
+        }
         const Addon = await this._getWebglAddonConstructor();
         this._webglAddon = ( new Addon());
         this._disposeOfCanvasRenderer();
@@ -477,11 +534,14 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
             if (!neverMeasureRenderTime && this._configHelper.config.gpuAcceleration !== 'off') {
                 this._measureRenderTime();
             }
-            XtermTerminal._suggestedRendererType = 'canvas';
-            this._disposeOfWebglRenderer();
-            this._enableCanvasRenderer();
+            this._disableWebglForThisSession();
         }
     }
+    _disableWebglForThisSession() {
+        XtermTerminal_1._suggestedRendererType = 'canvas';
+        this._disposeOfWebglRenderer();
+        this._enableCanvasRenderer();
+    }
     async _enableCanvasRenderer() {
         if (!this.raw.element || this._canvasAddon) {
             return;
@@ -499,7 +559,7 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
             if (!neverMeasureRenderTime && this._configHelper.config.gpuAcceleration !== 'off') {
                 this._measureRenderTime();
             }
-            XtermTerminal._suggestedRendererType = 'dom';
+            XtermTerminal_1._suggestedRendererType = 'dom';
             this._disposeOfCanvasRenderer();
         }
         this._refreshImageAddon();
@@ -587,7 +647,7 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
             const medianTime = frameTimes.sort((a, b) => a - b)[Math.floor(frameTimes.length / 2)];
             if (medianTime > 50 ) {
                 if (this._configHelper.config.gpuAcceleration === 'auto') {
-                    XtermTerminal._suggestedRendererType = 'dom';
+                    XtermTerminal_1._suggestedRendererType = 'dom';
                     this.updateConfig();
                 }
                 else {
@@ -690,7 +750,7 @@ let XtermTerminal = class XtermTerminal extends DisposableStore {
 XtermTerminal.__decorator = ( __decorate([
     debounce(100)
 ], XtermTerminal.prototype, "_refreshImageAddon", null));
-XtermTerminal = ( __decorate([
+XtermTerminal = XtermTerminal_1 = ( __decorate([
     ( __param(9, IConfigurationService)),
     ( __param(10, IInstantiationService)),
     ( __param(11, ITerminalLogService)),
@@ -716,7 +776,7 @@ function getXtermScaledDimensions(font, width, height) {
 }
 function vscodeToXtermLogLevel(logLevel) {
     switch (logLevel) {
-        case LogLevel.Trace:
+        case LogLevel.Trace: return 'trace';
         case LogLevel.Debug: return 'debug';
         case LogLevel.Info: return 'info';
         case LogLevel.Warning: return 'warn';
@@ -724,4 +784,10 @@ function vscodeToXtermLogLevel(logLevel) {
         default: return 'off';
     }
 }
+function vscodeToXtermCursorStyle(style) {
+    if (style === 'line') {
+        return 'bar';
+    }
+    return style;
+}
 export { XtermTerminal, getXtermScaledDimensions };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm-private.d.ts

@@ -49,4 +49,4 @@ interface IEventEmitter<T> {
 	fire(e: T): void;
 }
 
-export { IEventEmitter, IXtermCore, XtermAttributes };
+export type { IEventEmitter, IXtermCore, XtermAttributes };

package/vscode/src/vs/workbench/contrib/terminal/common/environmentVariable.d.ts

@@ -0,0 +1,9 @@
+import { EnvironmentVariableScope } from '../../../../platform/terminal/common/environmentVariable.js';
+import { ITerminalStatus } from './terminal.js';
+
+interface IEnvironmentVariableInfo {
+    readonly requiresAction: boolean;
+    getStatus(scope: EnvironmentVariableScope | undefined): ITerminalStatus;
+}
+
+export type { IEnvironmentVariableInfo };

package/vscode/src/vs/workbench/contrib/terminal/common/environmentVariableService.js

@@ -5,13 +5,15 @@ import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/st
 import { IExtensionService } from '../../../services/extensions/common/extensions.js';
 import { MergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariableCollection.js';
 import { deserializeEnvironmentVariableCollection, deserializeEnvironmentDescriptionMap, serializeEnvironmentVariableCollection, serializeEnvironmentDescriptionMap } from '../../../../platform/terminal/common/environmentVariableShared.js';
-let EnvironmentVariableService = class EnvironmentVariableService {
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+let EnvironmentVariableService = class EnvironmentVariableService extends Disposable {
     get onDidChangeCollections() { return this._onDidChangeCollections.event; }
     constructor(_extensionService, _storageService) {
+        super();
         this._extensionService = _extensionService;
         this._storageService = _storageService;
         this.collections = ( new Map());
-        this._onDidChangeCollections = ( new Emitter());
+        this._onDidChangeCollections = this._register(( new Emitter()));
         this._storageService.remove("terminal.integrated.environmentVariableCollections" , 1 );
         const serializedPersistedCollections = this._storageService.get("terminal.integrated.environmentVariableCollectionsV2" , 1 );
         if (serializedPersistedCollections) {

package/vscode/src/vs/workbench/contrib/terminal/common/history.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { env } from 'monaco-editor/esm/vs/base/common/process.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IFileService, FileOperationError } from 'monaco-editor/esm/vs/platform/files/common/files.js';
@@ -75,16 +75,16 @@ let TerminalPersistedHistory = class TerminalPersistedHistory extends Disposable
         this._isReady = false;
         this._isStale = true;
         this._entries = ( new LRUCache(this._getHistoryLimit()));
-        this._configurationService.onDidChangeConfiguration(e => {
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration("terminal.integrated.shellIntegration.history" )) {
                 this._entries.limit = this._getHistoryLimit();
             }
-        });
-        this._storageService.onDidChangeValue(e => {
-            if (e.key === this._getTimestampStorageKey() && !this._isStale) {
+        }));
+        this._register(this._storageService.onDidChangeValue(-1 , this._getTimestampStorageKey(), this._register(( new DisposableStore())))(() => {
+            if (!this._isStale) {
                 this._isStale = this._storageService.getNumber(this._getTimestampStorageKey(), -1 , 0) !== this._timestamp;
             }
-        });
+        }));
     }
     add(key, value) {
         this._ensureUpToDate();

package/vscode/src/vs/workbench/contrib/terminal/common/remote/remoteTerminalChannel.js

@@ -1,5 +1,4 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { IWorkbenchConfigurationService } from '../../../../services/configuration/common/configuration.js';
 import { IRemoteAuthorityResolverService } from '../../../../../platform/remote/common/remoteAuthorityResolver.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
@@ -70,7 +69,7 @@ let RemoteTerminalChannelClient = class RemoteTerminalChannelClient {
     async createProcess(shellLaunchConfig, configuration, activeWorkspaceRootUri, options, shouldPersistTerminal, cols, rows, unicodeVersion) {
         await this._configurationService.whenRemoteConfigurationLoaded();
         const resolvedVariables = Object.create(null);
-        const lastActiveWorkspace = activeWorkspaceRootUri ? withNullAsUndefined(this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined;
+        const lastActiveWorkspace = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
         let allResolvedVariables = undefined;
         try {
             allResolvedVariables = (await this._resolverService.resolveAnyMap(lastActiveWorkspace, {
@@ -118,7 +117,7 @@ let RemoteTerminalChannelClient = class RemoteTerminalChannelClient {
             unicodeVersion,
             resolverEnv
         };
-        return await this._channel.call('$createProcess', args);
+        return await this._channel.call("$createProcess" , args);
     }
     requestDetachInstance(workspaceId, instanceId) {
         return this._channel.call("$requestDetachInstance" , [workspaceId, instanceId]);
@@ -210,7 +209,7 @@ let RemoteTerminalChannelClient = class RemoteTerminalChannelClient {
             workspaceId: workspace.id,
             tabs: layout ? layout.tabs : []
         };
-        return this._channel.call('$setTerminalLayoutInfo', args);
+        return this._channel.call("$setTerminalLayoutInfo" , args);
     }
     updateTitle(id, title, titleSource) {
         return this._channel.call("$updateTitle" , [id, title, titleSource]);
@@ -229,10 +228,10 @@ let RemoteTerminalChannelClient = class RemoteTerminalChannelClient {
         const args = {
             workspaceId: workspace.id,
         };
-        return this._channel.call('$getTerminalLayoutInfo', args);
+        return this._channel.call("$getTerminalLayoutInfo" , args);
     }
-    reviveTerminalProcesses(state, dateTimeFormatLocate) {
-        return this._channel.call("$reviveTerminalProcesses" , [state, dateTimeFormatLocate]);
+    reviveTerminalProcesses(workspaceId, state, dateTimeFormatLocate) {
+        return this._channel.call("$reviveTerminalProcesses" , [workspaceId, state, dateTimeFormatLocate]);
     }
     getRevivedPtyNewId(id) {
         return this._channel.call("$getRevivedPtyNewId" , [id]);

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.d.ts

@@ -1,9 +1,13 @@
 import { Event } from '../../../../base/common/event.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { OperatingSystem } from '../../../../base/common/platform.js';
 import Severity from '../../../../base/common/severity.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { URI } from '../../../../base/common/uri.js';
-import { IShellLaunchConfig, TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
+import { ITerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/capabilities.js';
+import { IMergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariable.js';
+import { IShellLaunchConfig, TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalBackend, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
+import { IEnvironmentVariableInfo } from './environmentVariable.js';
 
 type FontWeight = 'normal' | 'bold' | number;
 interface ITerminalProfiles {
@@ -49,6 +53,7 @@ interface ITerminalConfiguration {
     rightClickBehavior: 'default' | 'copyPaste' | 'paste' | 'selectWord' | 'nothing';
     cursorBlinking: boolean;
     cursorStyle: 'block' | 'underline' | 'line';
+    cursorStyleInactive: 'outline' | 'block' | 'underline' | 'line' | 'none';
     cursorWidth: number;
     drawBoldTextInBrightColors: boolean;
     fastScrollSensitivity: number;
@@ -119,6 +124,7 @@ interface ITerminalConfiguration {
     };
     enableImages: boolean;
     smoothScrolling: boolean;
+    ignoreBracketedPasteMode: boolean;
 }
 interface ITerminalConfigHelper {
     config: ITerminalConfiguration;
@@ -156,6 +162,33 @@ interface IRemoteTerminalAttachTarget {
     fixedDimensions: IFixedTerminalDimensions | undefined;
     shellIntegrationNonce: string;
 }
+/** Read-only process information that can apply to detached terminals. */
+interface ITerminalProcessInfo {
+    readonly processState: ProcessState;
+    readonly ptyProcessReady: Promise<void>;
+    readonly shellProcessId: number | undefined;
+    readonly remoteAuthority: string | undefined;
+    readonly os: OperatingSystem | undefined;
+    readonly userHome: string | undefined;
+    readonly initialCwd: string;
+    readonly environmentVariableInfo: IEnvironmentVariableInfo | undefined;
+    readonly persistentProcessId: number | undefined;
+    readonly shouldPersist: boolean;
+    readonly hasWrittenData: boolean;
+    readonly hasChildProcesses: boolean;
+    readonly backend: ITerminalBackend | undefined;
+    readonly capabilities: ITerminalCapabilityStore;
+    readonly shellIntegrationNonce: string;
+    readonly extEnvironmentVariableCollection: IMergedEnvironmentVariableCollection | undefined;
+}
+declare const enum ProcessState {
+    Uninitialized = 1,
+    Launching = 2,
+    Running = 3,
+    KilledDuringLaunch = 4,
+    KilledByUser = 5,
+    KilledByProcess = 6
+}
 interface ITerminalProcessExtHostProxy extends IDisposable {
     readonly instanceId: number;
     emitData(data: string): void;
@@ -207,4 +240,4 @@ interface ITerminalStatusHoverAction {
     run: () => void;
 }
 
-export { ConfirmOnExit, ConfirmOnKill, FontWeight, IRemoteTerminalAttachTarget, IStartExtensionTerminalRequest, ITerminalConfigHelper, ITerminalConfiguration, ITerminalFont, ITerminalProcessExtHostProxy, ITerminalProfiles, ITerminalStatus, ITerminalStatusHoverAction };
+export { type ConfirmOnExit, type ConfirmOnKill, type FontWeight, type IRemoteTerminalAttachTarget, type IStartExtensionTerminalRequest, type ITerminalConfigHelper, type ITerminalConfiguration, type ITerminalFont, type ITerminalProcessExtHostProxy, type ITerminalProcessInfo, type ITerminalProfiles, type ITerminalStatus, type ITerminalStatusHoverAction, ProcessState };

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.js

@@ -2,11 +2,6 @@ import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const TERMINAL_VIEW_ID = 'terminal';
 const TERMINAL_CREATION_COMMANDS = ['workbench.action.terminal.toggleTerminal', 'workbench.action.terminal.new', 'workbench.action.togglePanel', 'workbench.action.terminal.focus'];
-const TerminalCursorStyle = {
-    BLOCK: 'block',
-    LINE: 'line',
-    UNDERLINE: 'underline'
-};
 const TERMINAL_CONFIG_SECTION = 'terminal.integrated';
 const DEFAULT_LETTER_SPACING = 0;
 const MINIMUM_LETTER_SPACING = -5;
@@ -84,7 +79,8 @@ const DEFAULT_COMMANDS_TO_SKIP_SHELL = [
     "workbench.action.terminal.acceptSelectedSuggestion" ,
     "workbench.action.terminal.hideSuggestWidget" ,
     "workbench.action.terminal.focusHover" ,
-    'editor.action.accessibilityHelp',
+    "workbench.action.terminal.focusAccessibleBuffer" ,
+    "editor.action.accessibilityHelp" ,
     'editor.action.toggleTabFocusMode',
     'notifications.hideList',
     'notifications.hideToasts',
@@ -240,4 +236,4 @@ const terminalContributionsDescriptor = {
         },
     },
 };
-export { DEFAULT_BOLD_FONT_WEIGHT, DEFAULT_COMMANDS_TO_SKIP_SHELL, DEFAULT_FONT_WEIGHT, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, DEFAULT_LOCAL_ECHO_EXCLUDE, ITerminalProfileResolverService, ITerminalProfileService, MAXIMUM_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, SUGGESTIONS_FONT_WEIGHT, TERMINAL_CONFIG_SECTION, TERMINAL_CREATION_COMMANDS, TERMINAL_VIEW_ID, TerminalCursorStyle, terminalContributionsDescriptor };
+export { DEFAULT_BOLD_FONT_WEIGHT, DEFAULT_COMMANDS_TO_SKIP_SHELL, DEFAULT_FONT_WEIGHT, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, DEFAULT_LOCAL_ECHO_EXCLUDE, ITerminalProfileResolverService, ITerminalProfileService, MAXIMUM_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, SUGGESTIONS_FONT_WEIGHT, TERMINAL_CONFIG_SECTION, TERMINAL_CREATION_COMMANDS, TERMINAL_VIEW_ID, terminalContributionsDescriptor };

package/vscode/src/vs/workbench/contrib/terminal/common/terminalConfiguration.js

@@ -1,6 +1,6 @@
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, MINIMUM_FONT_WEIGHT, MAXIMUM_FONT_WEIGHT, SUGGESTIONS_FONT_WEIGHT, TerminalCursorStyle, DEFAULT_COMMANDS_TO_SKIP_SHELL, DEFAULT_LOCAL_ECHO_EXCLUDE } from './terminal.js';
+import { DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, MINIMUM_FONT_WEIGHT, MAXIMUM_FONT_WEIGHT, SUGGESTIONS_FONT_WEIGHT, DEFAULT_COMMANDS_TO_SKIP_SHELL, DEFAULT_LOCAL_ECHO_EXCLUDE } from './terminal.js';
 import { isMacintosh, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
@@ -401,10 +401,18 @@ const terminalConfiguration = {
         ["terminal.integrated.cursorStyle" ]: {
             description: ( (localize(
                 'terminal.integrated.cursorStyle',
-                "Controls the style of terminal cursor."
+                "Controls the style of terminal cursor when the terminal is focused."
             ))),
-            enum: [TerminalCursorStyle.BLOCK, TerminalCursorStyle.LINE, TerminalCursorStyle.UNDERLINE],
-            default: TerminalCursorStyle.BLOCK
+            enum: ['block', 'line', 'underline'],
+            default: 'block'
+        },
+        ["terminal.integrated.cursorStyleInactive" ]: {
+            description: ( (localize(
+                'terminal.integrated.cursorStyleInactive',
+                "Controls the style of terminal cursor when the terminal is not focused."
+            ))),
+            enum: ['outline', 'block', 'line', 'underline', 'none'],
+            default: 'outline'
         },
         ["terminal.integrated.cursorWidth" ]: {
             markdownDescription: ( (localize(
@@ -803,16 +811,13 @@ const terminalConfiguration = {
                 "Terminal style of locally echoed text; either a font style or an RGB color."
             ))),
             default: 'dim',
-            oneOf: [
+            anyOf: [
                 {
-                    type: 'string',
-                    default: 'dim',
-                    enum: ['bold', 'dim', 'italic', 'underlined', 'inverted'],
+                    enum: ['bold', 'dim', 'italic', 'underlined', 'inverted', '#ff0000'],
                 },
                 {
                     type: 'string',
                     format: 'color-hex',
-                    default: '#ff0000',
                 }
             ]
         },
@@ -847,6 +852,26 @@ const terminalConfiguration = {
             ],
             default: 'onExit'
         },
+        ["terminal.integrated.hideOnStartup" ]: {
+            description: ( (localize(
+                'terminal.integrated.hideOnStartup',
+                "Whether to hide the terminal view on startup, avoiding creating a terminal when there are no persistent sessions."
+            ))),
+            type: 'string',
+            enum: ['never', 'whenEmpty', 'always'],
+            markdownEnumDescriptions: [
+                ( (localize('hideOnStartup.never', "Never hide the terminal view on startup."))),
+                ( (localize(
+                'hideOnStartup.whenEmpty',
+                "Only hide the terminal when there are no persistent sessions restored."
+            ))),
+                ( (localize(
+                'hideOnStartup.always',
+                "Always hide the terminal, even when there are persistent sessions restored."
+            )))
+            ],
+            default: 'never'
+        },
         ["terminal.integrated.customGlyphs" ]: {
             description: ( (localize(
                 'terminal.integrated.customGlyphs',
@@ -945,6 +970,16 @@ const terminalConfiguration = {
             type: 'boolean',
             default: false
         },
+        ["terminal.integrated.ignoreBracketedPasteMode" ]: {
+            markdownDescription: ( (localize(
+                'terminal.integrated.ignoreBracketedPasteMode',
+                "Controls whether the terminal will ignore bracketed paste mode even if the terminal was put into the mode, omitting the {0} and {1} sequences when pasting. This is useful when the shell is not respecting the mode which can happen in sub-shells for example.",
+                '`\\x1b[200~`',
+                '`\\x1b[201~`'
+            ))),
+            type: 'boolean',
+            default: false
+        },
         ["terminal.integrated.enableImages" ]: {
             restricted: true,
             markdownDescription: ( (localize(
@@ -953,8 +988,25 @@ const terminalConfiguration = {
                 `\`#${"terminal.integrated.gpuAcceleration" }#\``
             ))),
             type: 'boolean',
-            default: true
+            default: false
         },
+        ["terminal.integrated.focusAfterRun" ]: {
+            markdownDescription: ( (localize(
+                'terminal.integrated.focusAfterRun',
+                "Controls whether the terminal, accessible buffer, or neither will be focused after `Terminal: Run Selected Text In Active Terminal` has been run."
+            ))),
+            enum: ['terminal', 'accessible-buffer', 'none'],
+            default: 'none',
+            tags: ['accessibility'],
+            markdownEnumDescriptions: [
+                ( (localize('terminal.integrated.focusAfterRun.terminal', "Always focus the terminal."))),
+                ( (localize(
+                'terminal.integrated.focusAfterRun.accessible-buffer',
+                "Always focus the accessible buffer."
+            ))),
+                ( (localize('terminal.integrated.focusAfterRun.none', "Do nothing."))),
+            ]
+        }
     }
 };
 function registerTerminalConfiguration() {

package/vscode/src/vs/workbench/contrib/terminal/common/terminalContextKey.js

@@ -24,6 +24,14 @@ var TerminalContextKeys;
             "Whether the terminal accessible buffer is focused."
         ))
     ));
+    TerminalContextKeys.accessibleBufferOnLastLine = ( new RawContextKey(
+        "terminalAccessibleBufferOnLastLine" ,
+        false,
+        ( localize(
+            'terminalAccessibleBufferOnLastLineContextKey',
+            "Whether the accessible buffer focus is on the last line."
+        ))
+    ));
     TerminalContextKeys.editorFocus = ( new RawContextKey(
         "terminalEditorFocus" ,
         false,