@codingame/monaco-vscode-debug-service-override 1.82.6 → 1.83.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-debug-service-override",
-  "version": "1.82.6",
+  "version": "1.83.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -13,12 +13,12 @@
   },
   "type": "module",
   "private": false,
-  "description": "VSCode public API plugged on the monaco editor - debug service-override meta package",
+  "description": "VSCode public API plugged on the monaco editor - debug service-override",
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.6",
-    "monaco-editor": "0.43.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.1",
+    "monaco-editor": "0.44.0"
   }
 }

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -6,7 +6,7 @@ import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
 import { DisposableStore, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
@@ -149,7 +149,7 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         inputBox.value = options.initialValue;
         inputBox.focus();
         inputBox.select();
-        const done = once((success, finishEditing) => {
+        const done = createSingleCallFunction((success, finishEditing) => {
             nameElement.style.display = '';
             valueElement.style.display = '';
             inputBoxContainer.style.display = 'none';

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointEditorContribution.js

@@ -681,14 +681,14 @@ class InlineBreakpointWidget {
             });
         }));
         const updateSize = () => {
-            const lineHeight = this.editor.getOption(65 );
+            const lineHeight = this.editor.getOption(66 );
             this.domNode.style.height = `${lineHeight}px`;
             this.domNode.style.width = `${Math.ceil(0.8 * lineHeight)}px`;
             this.domNode.style.marginLeft = `4px`;
         };
         updateSize();
         this.toDispose.push(this.editor.onDidChangeConfiguration(c => {
-            if (c.hasChanged(51 ) || c.hasChanged(65 )) {
+            if (c.hasChanged(52 ) || c.hasChanged(66 )) {
                 updateSize();
             }
         }));

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointWidget.js

@@ -289,7 +289,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
     }
     centerInputVertically() {
         if (this.container && typeof this.heightInPx === 'number') {
-            const lineHeight = this.input.getOption(65 );
+            const lineHeight = this.input.getOption(66 );
             const lineNum = this.input.getModel().getLineCount();
             const newTopMargin = (this.heightInPx - lineNum * lineHeight) / 2;
             this.inputContainer.style.marginTop = newTopMargin + 'px';

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointsView.js

@@ -114,7 +114,7 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
                 await this.debugService.removeDataBreakpoints(element.getId());
             }
             else if (element instanceof InstructionBreakpoint) {
-                await this.debugService.removeInstructionBreakpoints(element.instructionReference);
+                await this.debugService.removeInstructionBreakpoints(element.instructionReference, element.offset);
             }
         });
         this._register(this.list.onDidOpen(async (e) => {
@@ -129,7 +129,7 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
             }
             if (e.element instanceof InstructionBreakpoint) {
                 const disassemblyView = await this.editorService.openEditor(DisassemblyViewInput.instance);
-                disassemblyView.goToAddress(e.element.instructionReference, e.browserEvent instanceof MouseEvent && e.browserEvent.detail === 2);
+                disassemblyView.goToInstructionAndOffset(e.element.instructionReference, e.element.offset, e.browserEvent instanceof MouseEvent && e.browserEvent.detail === 2);
             }
             if (e.browserEvent instanceof MouseEvent && e.browserEvent.detail === 2 && e.element instanceof FunctionBreakpoint && e.element !== this.inputBoxData?.breakpoint) {
                 this.renderInputBox({ breakpoint: e.element, type: 'name' });
@@ -628,7 +628,8 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
     renderElement(breakpoint, index, data) {
         data.context = breakpoint;
         data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
-        data.name.textContent = breakpoint.instructionReference;
+        data.name.textContent = '0x' + ( breakpoint.address.toString(16));
+        data.name.title = `Decimal address: breakpoint.address.toString()`;
         data.checkbox.checked = breakpoint.enabled;
         const { message, icon } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), breakpoint, this.labelService);
         data.icon.className = ThemeIcon.asClassName(icon);

package/vscode/src/vs/workbench/contrib/debug/browser/callStackView.js

@@ -226,6 +226,7 @@ let CallStackView = class CallStackView extends ViewPane {
             }
         });
         this.tree.setInput(this.debugService.getModel());
+        this._register(this.tree);
         this._register(this.tree.onDidOpen(async (e) => {
             if (this.ignoreSelectionChangedEvent) {
                 return;
@@ -389,6 +390,7 @@ let CallStackView = class CallStackView extends ViewPane {
         const contextKeyService = this.contextKeyService.createOverlay(overlay);
         const menu = this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService);
         createAndFillInContextMenuActions(menu, { arg: getContextForContributedActions(element), shouldForwardArgs: true }, result, 'inline');
+        menu.dispose();
         this.contextMenuService.showContextMenu({
             getAnchor: () => e.anchor,
             getActions: () => result.secondary,

package/vscode/src/vs/workbench/contrib/debug/browser/debug.contribution.js

@@ -176,10 +176,10 @@ MenuRegistry.appendMenuItem(MenuId.MenubarNewBreakpointMenu, {
 });
 const VIEW_CONTAINER = ( Registry.as(Extensions$2.ViewContainersRegistry)).registerViewContainer({
     id: DEBUG_PANEL_ID,
-    title: ( nls.localize(
+    title: { value: ( nls.localize(
         { comment: ['Debug is a noun in this context, not a verb.'], key: 'debugPanel' },
         "Debug Console"
-    )),
+    )), original: 'Debug Console' },
     icon: debugConsoleViewIcon,
     ctorDescriptor: ( new SyncDescriptor(
         ViewPaneContainer,
@@ -278,12 +278,23 @@ configurationRegistry.registerConfiguration({
             default: 'auto'
         },
         'debug.toolBarLocation': {
-            enum: ['floating', 'docked', 'hidden'],
+            enum: ['floating', 'docked', 'commandCenter', 'hidden'],
             markdownDescription: ( nls.localize(
                 { comment: ['This is the description for a setting'], key: 'toolBarLocation' },
-                "Controls the location of the debug toolbar. Either `floating` in all views, `docked` in the debug view, or `hidden`."
+                "Controls the location of the debug toolbar. Either `floating` in all views, `docked` in the debug view, `commandCenter` (requires `{0}`), or `hidden`.",
+                '#window.commandCenter#',
+                '#window.titleBarStyle#'
             )),
-            default: 'floating'
+            default: 'floating',
+            markdownEnumDescriptions: [
+                ( nls.localize('debugToolBar.floating', "Show debug toolbar in all views.")),
+                ( nls.localize('debugToolBar.docked', "Show debug toolbar only in debug views.")),
+                ( nls.localize(
+                    'debugToolBar.commandCenter',
+                    "`(Experimental)` Show debug toolbar in the command center."
+                )),
+                ( nls.localize('debugToolBar.hidden', "Do not show debug toolbar.")),
+            ]
         },
         'debug.showInStatusBar': {
             enum: ['never', 'always', 'onFirstSessionStart'],

package/vscode/src/vs/workbench/contrib/debug/browser/debugAdapterManager.js

@@ -324,6 +324,7 @@ let AdapterManager = class AdapterManager extends Disposable {
         }
         this.initExtensionActivationsIfNeeded();
         candidates.sort((first, second) => first.label.localeCompare(second.label));
+        candidates = candidates.filter(a => !a.isHiddenFromDropdown);
         const suggestedCandidates = [];
         const otherCandidates = [];
         candidates.forEach(d => {

package/vscode/src/vs/workbench/contrib/debug/browser/debugCommands.js

@@ -611,8 +611,23 @@ CommandsRegistry.registerCommand({
 });
 CommandsRegistry.registerCommand({
     id: SELECT_AND_START_ID,
-    handler: async (accessor) => {
+    handler: async (accessor, debugType) => {
         const quickInputService = accessor.get(IQuickInputService);
+        const debugService = accessor.get(IDebugService);
+        if (debugType) {
+            const configManager = debugService.getConfigurationManager();
+            const dynamicProviders = await configManager.getDynamicProviders();
+            for (const provider of dynamicProviders) {
+                if (provider.type === debugType) {
+                    const pick = await provider.pick();
+                    if (pick) {
+                        await configManager.selectConfiguration(pick.launch, pick.config.name, pick.config, { type: provider.type });
+                        debugService.startDebugging(pick.launch, pick.config, { startedByUser: true });
+                        return;
+                    }
+                }
+            }
+        }
         quickInputService.quickAccess.show(DEBUG_QUICK_ACCESS_PREFIX);
     }
 });

package/vscode/src/vs/workbench/contrib/debug/browser/debugEditorActions.js

@@ -2,6 +2,7 @@ import { getDomNodePagePosition } from 'monaco-editor/esm/vs/base/browser/dom.js
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
 import { EditorAction2, EditorAction, registerEditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
@@ -15,38 +16,59 @@ import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/c
 import { PanelFocusContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
 import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
 import { openBreakpointSource } from './breakpointsView.js';
-import { CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_DEBUGGERS_AVAILABLE, IDebugService, REPL_VIEW_ID, WATCH_VIEW_ID, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, BREAKPOINT_EDITOR_CONTRIBUTION_ID, EDITOR_CONTRIBUTION_ID, CONTEXT_EXCEPTION_WIDGET_VISIBLE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { DisassemblyView } from './disassemblyView.js';
+import { CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DISASSEMBLY_VIEW_FOCUS, IDebugService, REPL_VIEW_ID, WATCH_VIEW_ID, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, BREAKPOINT_EDITOR_CONTRIBUTION_ID, EDITOR_CONTRIBUTION_ID, CONTEXT_EXCEPTION_WIDGET_VISIBLE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { getEvaluatableExpressionAtPosition } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
 import { DisassemblyViewInput } from '../common/disassemblyViewInput.js';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 
-class ToggleBreakpointAction extends EditorAction {
+class ToggleBreakpointAction extends Action2 {
     constructor() {
         super({
             id: 'editor.debug.action.toggleBreakpoint',
-            label: ( nls.localize('toggleBreakpointAction', "Debug: Toggle Breakpoint")),
-            alias: 'Debug: Toggle Breakpoint',
+            title: {
+                value: ( nls.localize('toggleBreakpointAction', "Debug: Toggle Breakpoint")),
+                original: 'Debug: Toggle Breakpoint',
+                mnemonicTitle: ( nls.localize(
+                    { key: 'miToggleBreakpoint', comment: ['&& denotes a mnemonic'] },
+                    "Toggle &&Breakpoint"
+                )),
+            },
             precondition: CONTEXT_DEBUGGERS_AVAILABLE,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
+            keybinding: {
+                when: ( ContextKeyExpr.or(EditorContextKeys.editorTextFocus, CONTEXT_DISASSEMBLY_VIEW_FOCUS)),
                 primary: 67 ,
                 weight: 100
             },
-            menuOpts: {
+            menu: {
+                id: MenuId.MenubarDebugMenu,
                 when: CONTEXT_DEBUGGERS_AVAILABLE,
-                title: ( nls.localize(
-                    { key: 'miToggleBreakpoint', comment: ['&& denotes a mnemonic'] },
-                    "Toggle &&Breakpoint"
-                )),
-                menuId: MenuId.MenubarDebugMenu,
                 group: '4_new_breakpoint',
                 order: 1
             }
         });
     }
-    async run(accessor, editor) {
-        if (editor.hasModel()) {
-            const debugService = accessor.get(IDebugService);
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const debugService = accessor.get(IDebugService);
+        const activePane = editorService.activeEditorPane;
+        if (activePane instanceof DisassemblyView) {
+            const location = activePane.focusedAddressAndOffset;
+            if (location) {
+                const bps = debugService.getModel().getInstructionBreakpoints();
+                const toRemove = bps.find(bp => bp.address === location.address);
+                if (toRemove) {
+                    debugService.removeInstructionBreakpoints(toRemove.instructionReference, toRemove.offset);
+                }
+                else {
+                    debugService.addInstructionBreakpoint(location.reference, location.offset, location.address);
+                }
+            }
+            return;
+        }
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const editor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
+        if (editor?.hasModel()) {
             const modelUri = editor.getModel().uri;
             const canSet = debugService.canSetBreakpointsIn(editor.getModel());
             const lineNumbers = [...( new Set(( editor.getSelections().map(s => s.getPosition().lineNumber))))];
@@ -196,7 +218,7 @@ class OpenDisassemblyViewAction extends EditorAction2 {
     runEditorCommand(accessor, editor, ...args) {
         if (editor.hasModel()) {
             const editorService = accessor.get(IEditorService);
-            editorService.openEditor(DisassemblyViewInput.instance, { pinned: true });
+            editorService.openEditor(DisassemblyViewInput.instance, { pinned: true, revealIfOpened: true });
         }
     }
 }
@@ -236,7 +258,7 @@ class RunToCursorAction extends EditorAction {
             id: RunToCursorAction.ID,
             label: RunToCursorAction.LABEL,
             alias: 'Debug: Run to Cursor',
-            precondition: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( PanelFocusContext.toNegated()), EditorContextKeys.editorTextFocus)),
+            precondition: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( PanelFocusContext.toNegated()), ( ContextKeyExpr.or(EditorContextKeys.editorTextFocus, CONTEXT_DISASSEMBLY_VIEW_FOCUS)))),
             contextMenuOpts: {
                 group: 'debug',
                 order: 2,
@@ -511,7 +533,7 @@ class CloseExceptionWidgetAction extends EditorAction {
 }
 registerAction2(OpenDisassemblyViewAction);
 registerAction2(ToggleDisassemblyViewSourceCodeAction);
-registerEditorAction(ToggleBreakpointAction);
+registerAction2(ToggleBreakpointAction);
 registerEditorAction(ConditionalBreakpointAction);
 registerEditorAction(LogPointAction);
 registerEditorAction(EditBreakpointAction);

package/vscode/src/vs/workbench/contrib/debug/browser/debugEditorContribution.js

@@ -4,9 +4,9 @@ import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
 import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { illegalArgument, onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { visit } from 'monaco-editor/esm/vs/base/common/json.js';
 import { setProperty } from 'vscode/vscode/vs/base/common/jsonEdit';
@@ -14,6 +14,8 @@ import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
 import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
 import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { assertType, isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { CoreEditingCommands } from 'monaco-editor/esm/vs/editor/browser/coreCommands.js';
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
 import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
@@ -22,9 +24,10 @@ import { DEFAULT_WORD_REGEXP } from 'monaco-editor/esm/vs/editor/common/core/wor
 import { InjectedTextCursorStops } from 'monaco-editor/esm/vs/editor/common/model.js';
 import { ILanguageFeatureDebounceService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatureDebounce.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { ModesHoverController } from 'monaco-editor/esm/vs/editor/contrib/hover/browser/hover.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -336,7 +339,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         await this.updateInlineValueDecorations(sf);
     }
     get showHoverScheduler() {
-        const hoverOption = this.editor.getOption(59 );
+        const hoverOption = this.editor.getOption(60 );
         const scheduler = ( new RunOnceScheduler(() => {
             if (this.hoverPosition && !this.altPressed) {
                 this.showHover(this.hoverPosition, false);
@@ -677,5 +680,23 @@ DebugEditorContribution = ( __decorate([
     ( __param(8, ILanguageFeaturesService)),
     ( __param(9, ILanguageFeatureDebounceService))
 ], DebugEditorContribution));
+CommandsRegistry.registerCommand('_executeInlineValueProvider', async (accessor, uri, iRange, context) => {
+    assertType(URI.isUri(uri));
+    assertType(Range.isIRange(iRange));
+    if (!context || typeof context.frameId !== 'number' || !Range.isIRange(context.stoppedLocation)) {
+        throw illegalArgument('context');
+    }
+    const model = accessor.get(IModelService).getModel(uri);
+    if (!model) {
+        throw illegalArgument('uri');
+    }
+    const range = Range.lift(iRange);
+    const { inlineValuesProvider } = accessor.get(ILanguageFeaturesService);
+    const providers = inlineValuesProvider.ordered(model);
+    const providerResults = await Promise.all(( providers.map(
+        provider => provider.provideInlineValues(model, range, context, CancellationToken.None)
+    )));
+    return providerResults.flat().filter(isDefined);
+});
 
 export { DebugEditorContribution };

package/vscode/src/vs/workbench/contrib/debug/browser/debugHover.js

@@ -115,7 +115,7 @@ let DebugHoverWidget = class DebugHoverWidget {
             }
         }));
         this.toDispose.push(this.editor.onDidChangeConfiguration((e) => {
-            if (e.hasChanged(49 )) {
+            if (e.hasChanged(50 )) {
                 this.editor.applyFontInfo(this.domNode);
             }
         }));

package/vscode/src/vs/workbench/contrib/debug/browser/debugService.js

@@ -910,14 +910,14 @@ let DebugService = class DebugService {
         this.debugStorage.storeBreakpoints(this.model);
         await this.sendDataBreakpoints();
     }
-    async addInstructionBreakpoint(address, offset, condition, hitCondition) {
-        this.model.addInstructionBreakpoint(address, offset, condition, hitCondition);
+    async addInstructionBreakpoint(instructionReference, offset, address, condition, hitCondition) {
+        this.model.addInstructionBreakpoint(instructionReference, offset, address, condition, hitCondition);
         this.debugStorage.storeBreakpoints(this.model);
         await this.sendInstructionBreakpoints();
         this.debugStorage.storeBreakpoints(this.model);
     }
-    async removeInstructionBreakpoints(address) {
-        this.model.removeInstructionBreakpoints(address);
+    async removeInstructionBreakpoints(instructionReference, offset) {
+        this.model.removeInstructionBreakpoints(instructionReference, offset);
         this.debugStorage.storeBreakpoints(this.model);
         await this.sendInstructionBreakpoints();
     }

package/vscode/src/vs/workbench/contrib/debug/browser/debugSession.js

@@ -6,7 +6,7 @@ import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancel
 import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DisposableStore, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
@@ -76,11 +76,14 @@ let DebugSession = class DebugSession {
         else {
             this.repl = this.parentSession.repl;
         }
-        const toDispose = this.rawListeners.add(( new DisposableStore()));
+        const toDispose = ( new DisposableStore());
         const replListener = toDispose.add(( new MutableDisposable()));
         replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
         if (lifecycleService) {
-            toDispose.add(lifecycleService.onWillShutdown(() => this.shutdown()));
+            toDispose.add(lifecycleService.onWillShutdown(() => {
+                this.shutdown();
+                dispose(toDispose);
+            }));
         }
         const compoundRoot = this._options.compoundRoot;
         if (compoundRoot) {
@@ -420,7 +423,7 @@ let DebugSession = class DebugSession {
             throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'instruction breakpoints'));
         }
         if (this.raw.readyForBreakpoints) {
-            const response = await this.raw.setInstructionBreakpoints({ breakpoints: instructionBreakpoints });
+            const response = await this.raw.setInstructionBreakpoints({ breakpoints: ( instructionBreakpoints.map(ib => ib.toJSON())) });
             if (response && response.body) {
                 const data = ( new Map());
                 for (let i = 0; i < instructionBreakpoints.length; i++) {

package/vscode/src/vs/workbench/contrib/debug/browser/debugTaskRunner.js

@@ -204,24 +204,25 @@ let DebugTaskRunner = class DebugTaskRunner {
             ))]));
         }
         let taskStarted = false;
-        const inactivePromise = ( new Promise((c, e) => once(e => {
+        const taskKey = task.getMapKey();
+        const inactivePromise = ( new Promise((c) => once(e => {
             return (e.kind === "inactive"
                 || (e.kind === "processEnded"  && e.exitCode === undefined))
-                && e.taskId === task._id;
+                && e.__task?.getMapKey() === taskKey;
         }, this.taskService.onDidStateChange)(e => {
             taskStarted = true;
             c(e.kind === "processEnded"  ? { exitCode: e.exitCode } : null);
         })));
         const promise = this.taskService.getActiveTasks().then(async (tasks) => {
-            if (tasks.find(t => t._id === task._id)) {
+            if (tasks.find(t => t.getMapKey() === taskKey)) {
                 const busyTasks = await this.taskService.getBusyTasks();
-                if (busyTasks.find(t => t._id === task._id)) {
+                if (busyTasks.find(t => t.getMapKey() === taskKey)) {
                     taskStarted = true;
                     return inactivePromise;
                 }
                 return Promise.resolve(null);
             }
-            once(e => (((e.kind === "active") ) || ((e.kind === "dependsOnStarted") )) && e.taskId === task._id, this.taskService.onDidStateChange)(() => {
+            once(e => (((e.kind === "active") ) || ((e.kind === "dependsOnStarted") )) && e.__task?.getMapKey() === taskKey, this.taskService.onDidStateChange)(() => {
                 taskStarted = true;
             });
             const taskPromise = this.taskService.run(task);
@@ -232,7 +233,7 @@ let DebugTaskRunner = class DebugTaskRunner {
         });
         return ( new Promise((c, e) => {
             const waitForInput = ( new Promise(
-                resolve => once(e => ((e.kind === "acquiredInput") ) && e.taskId === task._id, this.taskService.onDidStateChange)(() => {
+                resolve => once(e => ((e.kind === "acquiredInput") ) && e.__task?.getMapKey() === taskKey, this.taskService.onDidStateChange)(() => {
                     resolve();
                 })
             ));

package/vscode/src/vs/workbench/contrib/debug/browser/debugToolBar.js

@@ -25,10 +25,11 @@ import { Themable, IThemeService } from 'monaco-editor/esm/vs/platform/theme/com
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { FocusSessionActionViewItem } from './debugActionViewItems.js';
 import { debugToolBarBackground, debugToolBarBorder } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugColors';
-import { CONTINUE_LABEL, CONTINUE_ID, PAUSE_LABEL, PAUSE_ID, DISCONNECT_ID, DISCONNECT_LABEL, STOP_LABEL, STOP_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, STEP_BACK_ID, REVERSE_CONTINUE_ID, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, FOCUS_SESSION_ID, RESTART_LABEL, RESTART_SESSION_ID, FOCUS_SESSION_LABEL } from './debugCommands.js';
+import { CONTINUE_LABEL, CONTINUE_ID, PAUSE_LABEL, PAUSE_ID, DISCONNECT_ID, DISCONNECT_LABEL, STOP_LABEL, STOP_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, STEP_BACK_ID, REVERSE_CONTINUE_ID, FOCUS_SESSION_LABEL, FOCUS_SESSION_ID, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, RESTART_LABEL, RESTART_SESSION_ID } from './debugCommands.js';
 import { debugContinue, debugPause, debugDisconnect, debugStop, debugStepOver, debugStepInto, debugStepOut, debugStepBack, debugReverseContinue, debugGripper, debugRestart } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
-import { VIEWLET_ID, CONTEXT_DEBUG_STATE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { VIEWLET_ID, CONTEXT_DEBUG_STATE, CONTEXT_IN_DEBUG_MODE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 
 const DEBUG_TOOLBAR_POSITION_KEY = 'debug.actionswidgetposition';
 const DEBUG_TOOLBAR_Y_KEY = 'debug.actionswidgety';
@@ -73,8 +74,7 @@ let DebugToolBar = class DebugToolBar extends Themable {
             const state = this.debugService.state;
             const toolBarLocation = this.configurationService.getValue('debug').toolBarLocation;
             if (state === 0  ||
-                toolBarLocation === 'docked' ||
-                toolBarLocation === 'hidden' ||
+                toolBarLocation !== 'floating' ||
                 this.debugService.getModel().getSessions().every(s => s.suppressDebugToolbar) ||
                 (state === 1  && this.debugService.initializingOptions?.suppressDebugToolbar)) {
                 return this.hide();
@@ -269,6 +269,14 @@ MenuRegistry.onDidChangeMenu(e => {
         }
     }
 });
+const CONTEXT_TOOLBAR_COMMAND_CENTER = ( ContextKeyExpr.equals('config.debug.toolBarLocation', 'commandCenter'));
+MenuRegistry.appendMenuItem(MenuId.CommandCenterCenter, {
+    submenu: MenuId.DebugToolBar,
+    title: 'Debug',
+    icon: Codicon.debug,
+    order: 1,
+    when: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, CONTEXT_TOOLBAR_COMMAND_CENTER))
+});
 registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, debugContinue, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
 registerDebugToolBarItem(PAUSE_ID, PAUSE_LABEL, 10, debugPause, ( CONTEXT_DEBUG_STATE.notEqualsTo('stopped')), ( CONTEXT_DEBUG_STATE.isEqualTo('running')));
 registerDebugToolBarItem(STOP_ID, STOP_LABEL, 70, debugStop, ( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), undefined, { id: DISCONNECT_ID, title: DISCONNECT_LABEL, icon: debugDisconnect, precondition: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)), });
@@ -279,7 +287,7 @@ registerDebugToolBarItem(STEP_OUT_ID, STEP_OUT_LABEL, 40, debugStepOut, undefine
 registerDebugToolBarItem(RESTART_SESSION_ID, RESTART_LABEL, 60, debugRestart);
 registerDebugToolBarItem(STEP_BACK_ID, ( localize('stepBackDebug', "Step Back")), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
 registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localize('reverseContinue', "Reverse")), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
-registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, undefined, CONTEXT_MULTI_SESSION_DEBUG);
+registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, ( ContextKeyExpr.and(CONTEXT_MULTI_SESSION_DEBUG, ( CONTEXT_TOOLBAR_COMMAND_CENTER.negate()))));
 MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
     group: 'navigation',
     when: ( ContextKeyExpr.and(( CONTEXT_FOCUSED_SESSION_IS_ATTACH.toNegated()), CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED)),