@codingame/monaco-vscode-api 24.2.0 → 25.0.0

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -282,176 +282,176 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1671, 'Error at Position')),
+        name: ( localize(1678, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1672, 'Error')),
+        announcementMessage: ( localize(1679, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1673, 'Warning at Position')),
+        name: ( localize(1680, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1674, 'Warning')),
+        announcementMessage: ( localize(1681, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1675, 'Error on Line')),
+        name: ( localize(1682, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1676, 'Error on Line')),
+        announcementMessage: ( localize(1683, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1677, 'Warning on Line')),
+        name: ( localize(1684, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1678, 'Warning on Line')),
+        announcementMessage: ( localize(1685, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1679, 'Folded Area on Line')),
+        name: ( localize(1686, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1680, 'Folded')),
+        announcementMessage: ( localize(1687, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1681, 'Breakpoint on Line')),
+        name: ( localize(1688, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1682, 'Breakpoint')),
+        announcementMessage: ( localize(1689, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1683, 'Inline Suggestion on Line')),
+        name: ( localize(1690, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.nextEditSuggestion = AccessibilitySignal.register({
-        name: ( localize(1684, 'Next Edit Suggestion on Line')),
+        name: ( localize(1691, 'Next Edit Suggestion on Line')),
         sound: Sound.nextEditSuggestion,
         legacySoundSettingsKey: 'audioCues.nextEditSuggestion',
         settingsKey: 'accessibility.signals.nextEditSuggestion',
-        announcementMessage: ( localize(1685, 'Next Edit Suggestion')),
+        announcementMessage: ( localize(1692, 'Next Edit Suggestion')),
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1686, 'Terminal Quick Fix')),
+        name: ( localize(1693, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1687, 'Quick Fix')),
+        announcementMessage: ( localize(1694, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1688, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1695, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1689, 'Breakpoint')),
+        announcementMessage: ( localize(1696, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1690, 'No Inlay Hints on Line')),
+        name: ( localize(1697, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1691, 'No Inlay Hints')),
+        announcementMessage: ( localize(1698, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1692, 'Task Completed')),
+        name: ( localize(1699, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1693, 'Task Completed')),
+        announcementMessage: ( localize(1700, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1694, 'Task Failed')),
+        name: ( localize(1701, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1695, 'Task Failed')),
+        announcementMessage: ( localize(1702, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1696, 'Terminal Command Failed')),
+        name: ( localize(1703, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1697, 'Command Failed')),
+        announcementMessage: ( localize(1704, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1698, 'Terminal Command Succeeded')),
+        name: ( localize(1705, 'Terminal Command Succeeded')),
         sound: Sound.terminalCommandSucceeded,
-        announcementMessage: ( localize(1699, 'Command Succeeded')),
+        announcementMessage: ( localize(1706, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1700, 'Terminal Bell')),
+        name: ( localize(1707, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1701, 'Terminal Bell')),
+        announcementMessage: ( localize(1708, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1702, 'Notebook Cell Completed')),
+        name: ( localize(1709, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1703, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1710, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1704, 'Notebook Cell Failed')),
+        name: ( localize(1711, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1705, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1712, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1706, 'Diff Line Inserted')),
+        name: ( localize(1713, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1707, 'Diff Line Deleted')),
+        name: ( localize(1714, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1708, 'Diff Line Modified')),
+        name: ( localize(1715, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: ( localize(1709, 'Chat Edit Modified File')),
+        name: ( localize(1716, 'Chat Edit Modified File')),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: ( localize(1710, 'File Modified from Chat Edits')),
+        announcementMessage: ( localize(1717, 'File Modified from Chat Edits')),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1711, 'Chat Request Sent')),
+        name: ( localize(1718, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1712, 'Chat Request Sent')),
+        announcementMessage: ( localize(1719, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1713, 'Chat Response Received')),
+        name: ( localize(1720, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -464,81 +464,80 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1714, 'Code Action Request Triggered')),
+        name: ( localize(1721, 'Code Action Request Triggered')),
         sound: Sound.codeActionTriggered,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1715, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1722, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1716, 'Code Action Applied')),
+        name: ( localize(1723, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.codeActionApplied,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1717, 'Progress')),
+        name: ( localize(1724, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1718, 'Progress')),
+        announcementMessage: ( localize(1725, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1719, 'Clear')),
+        name: ( localize(1726, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1720, 'Clear')),
+        announcementMessage: ( localize(1727, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1721, 'Save')),
+        name: ( localize(1728, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1722, 'Save')),
+        announcementMessage: ( localize(1729, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1723, 'Format')),
+        name: ( localize(1730, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1724, 'Format')),
+        announcementMessage: ( localize(1731, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1725, 'Voice Recording Started')),
+        name: ( localize(1732, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1726, 'Voice Recording Stopped')),
+        name: ( localize(1733, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
     static { this.editsKept = AccessibilitySignal.register({
-        name: ( localize(1727, 'Edits Kept')),
+        name: ( localize(1734, 'Edits Kept')),
         sound: Sound.editsKept,
-        announcementMessage: ( localize(1728, 'Edits Kept')),
+        announcementMessage: ( localize(1735, 'Edits Kept')),
         settingsKey: 'accessibility.signals.editsKept',
     }); }
     static { this.editsUndone = AccessibilitySignal.register({
-        name: ( localize(1729, 'Undo Edits')),
+        name: ( localize(1736, 'Undo Edits')),
         sound: Sound.editsUndone,
-        announcementMessage: ( localize(1730, 'Edits Undone')),
+        announcementMessage: ( localize(1737, 'Edits Undone')),
         settingsKey: 'accessibility.signals.editsUndone',
     }); }
     static { this.chatUserActionRequired = AccessibilitySignal.register({
-        name: ( localize(1731, 'Chat User Action Required')),
+        name: ( localize(1738, 'Chat User Action Required')),
         sound: Sound.chatUserActionRequired,
-        announcementMessage: ( localize(1732, 'Chat User Action Required')),
-        settingsKey: 'accessibility.signals.chatUserActionRequired',
-        managesOwnEnablement: true
+        announcementMessage: ( localize(1739, 'Chat User Action Required')),
+        settingsKey: 'accessibility.signals.chatUserActionRequired'
     }); }
 }
 

package/vscode/src/vs/platform/action/common/actionCommonCategories.js

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1733, 'View')),
-    Help: ( localize2(1734, 'Help')),
-    Test: ( localize2(1735, 'Test')),
-    File: ( localize2(1736, 'File')),
-    Preferences: ( localize2(1737, 'Preferences')),
-    Developer: ( localize2(1738, "Developer")),
+    View: ( localize2(1740, 'View')),
+    Help: ( localize2(1741, 'Help')),
+    Test: ( localize2(1742, 'Test')),
+    File: ( localize2(1743, 'File')),
+    Preferences: ( localize2(1744, 'Preferences')),
+    Developer: ( localize2(1745, "Developer")),
 }));
 
 export { Categories };

package/vscode/src/vs/platform/actionWidget/browser/actionList.js

@@ -124,10 +124,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = ( localize(1739, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
+                data.container.title = ( localize(1746, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
             }
             else {
-                data.container.title = ( localize(1740, "{0} to Apply", actionTitle));
+                data.container.title = ( localize(1747, "{0} to Apply", actionTitle));
             }
         }
         else {
@@ -195,13 +195,13 @@ let ActionList = class ActionList extends Disposable {
                             label = label + ', ' + stripNewlines(element.description);
                         }
                         if (element.disabled) {
-                            label = ( localize(1741, "{0}, Disabled Reason: {1}", label, element.disabled));
+                            label = ( localize(1748, "{0}, Disabled Reason: {1}", label, element.disabled));
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => ( localize(1742, "Action Widget")),
+                getWidgetAriaLabel: () => ( localize(1749, "Action Widget")),
                 getRole: (e) => {
                     switch (e.kind) {
                         case ActionListItemKind.Action:

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.css

@@ -11,11 +11,11 @@
 	z-index: 40;
 	display: block;
 	width: 100%;
-	border: 1px solid var(--vscode-menu-border) !important;
+	border: 1px solid var(--vscode-editorHoverWidget-border) !important;
 	border-radius: 5px;
 	background-color: var(--vscode-menu-background);
 	color: var(--vscode-menu-foreground);
-	padding: 4px;
+	padding: 4px 0;
 	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
 }
 
@@ -57,10 +57,11 @@
 /** Styles for each row in the list element **/
 .action-widget .monaco-list .monaco-list-row {
 	padding: 0 4px 0 4px;
+	margin: 0 4px 0 4px;
 	white-space: nowrap;
 	cursor: pointer;
 	touch-action: none;
-	width: 100%;
+	width: calc(100% - 8px);
 	border-radius: 3px;
 }
 
@@ -85,9 +86,10 @@
 	border-top: 1px solid var(--vscode-editorHoverWidget-border);
 	color: var(--vscode-descriptionForeground);
 	font-size: 12px;
-	padding: 0;
-	margin: 4px 0 0 0;
+	margin: 4px 0px;
+	width: 100%;
 	cursor: default;
+	-webkit-user-select: none;
 	user-select: none;
 	border-radius: 0;
 }
@@ -155,8 +157,8 @@
 
 .action-widget .action-widget-action-bar {
 	background-color: var(--vscode-menu-background);
-	border-top: 1px solid var(--vscode-menu-border);
-	margin-top: 2px;
+	border-top: 1px solid var(--vscode-editorHoverWidget-border);
+	margin-top: 4px;
 }
 
 .action-widget .action-widget-action-bar::before {
@@ -166,7 +168,8 @@
 }
 
 .action-widget .action-widget-action-bar .actions-container {
-	padding: 4px 8px 2px 24px;
+	padding: 4px 8px 2px 28px;
+	width: auto;
 }
 
 .action-widget-action-bar .action-label {

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.js

@@ -29,9 +29,9 @@ import '../../theme/common/colors/searchColors.js';
 import { IActionWidgetService } from './actionWidget.service.js';
 
 registerCss(actionWidget);
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1743, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1750, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1744, "Whether the action widget list is visible"))))
+    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1751, "Whether the action widget list is visible"))))
 };
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
@@ -134,7 +134,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(1745, "Hide action widget")),
+            title: ( localize2(1752, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -151,7 +151,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(1746, "Select previous action")),
+            title: ( localize2(1753, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -172,7 +172,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(1747, "Select next action")),
+            title: ( localize2(1754, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -193,7 +193,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1748, "Accept selected action")),
+            title: ( localize2(1755, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -213,7 +213,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1749, "Preview selected action")),
+            title: ( localize2(1756, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -189,17 +189,17 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localize(1752, "{0} ({1})", tooltip, keybindingLabel))
+            ? ( localize(1759, "{0} ({1})", tooltip, keybindingLabel))
             : tooltip;
         if (!this._wantsAltCommand && this._menuItemAction.alt?.enabled) {
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altKeybinding = this._keybindingService.lookupKeybinding(this._menuItemAction.alt.id, this._contextKeyService);
             const altKeybindingLabel = altKeybinding && altKeybinding.getLabel();
             const altTitleSection = altKeybindingLabel
-                ? ( localize(1752, "{0} ({1})", altTooltip, altKeybindingLabel))
+                ? ( localize(1759, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localize(
-                1753,
+                1760,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -275,10 +275,10 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(1754, '{1} to {0}', this._action.label, kb2));
+                this.label.textContent = ( localize(1761, '{1} to {0}', this._action.label, kb2));
             }
             else {
-                this.label.textContent = ( localize(1755, '{0} ({1})', this._action.label, kb2));
+                this.label.textContent = ( localize(1762, '{0} ({1})', this._action.label, kb2));
             }
         }
     }

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -144,7 +144,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     else {
                         primaryActions.push(toAction({
                             id: 'label',
-                            label: ( localize(1756, "Hide")),
+                            label: ( localize(1763, "Hide")),
                             enabled: false,
                             run() { }
                         }));
@@ -158,7 +158,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( new Separator()));
                     actions.push(toAction({
                         id: 'resetThisMenu',
-                        label: ( localize(1757, "Reset Menu")),
+                        label: ( localize(1764, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

package/vscode/src/vs/platform/actions/common/actions.d.ts

@@ -267,18 +267,13 @@ export declare class MenuId {
     static readonly DiffEditorHunkToolbar: MenuId;
     static readonly DiffEditorSelectionToolbar: MenuId;
     static readonly AgentSessionsViewerFilterSubMenu: MenuId;
-    static readonly AgentSessionsInstallMenu: MenuId;
     static readonly AgentSessionsContext: MenuId;
     static readonly AgentSessionsCreateSubMenu: MenuId;
     static readonly AgentSessionsToolbar: MenuId;
     static readonly AgentSessionItemToolbar: MenuId;
+    static readonly AgentSessionSectionToolbar: MenuId;
     static readonly ChatViewSessionTitleNavigationToolbar: MenuId;
     static readonly ChatViewSessionTitleToolbar: MenuId;
-    /**
-     * @deprecated TODO@bpasero remove
-    */
-    static readonly AgentSessionsViewTitle: MenuId;
-    static readonly AgentSessionsFilterSubMenu: MenuId;
     /**
      * Create or reuse a `MenuId` with the given identifier
      */

package/vscode/src/vs/platform/actions/common/actions.js

@@ -238,15 +238,13 @@ class MenuId {
     static { this.DiffEditorHunkToolbar = ( new MenuId('DiffEditorHunkToolbar')); }
     static { this.DiffEditorSelectionToolbar = ( new MenuId('DiffEditorSelectionToolbar')); }
     static { this.AgentSessionsViewerFilterSubMenu = ( new MenuId('AgentSessionsViewerFilterSubMenu')); }
-    static { this.AgentSessionsInstallMenu = ( new MenuId('AgentSessionsInstallMenu')); }
     static { this.AgentSessionsContext = ( new MenuId('AgentSessionsContext')); }
     static { this.AgentSessionsCreateSubMenu = ( new MenuId('AgentSessionsCreateSubMenu')); }
     static { this.AgentSessionsToolbar = ( new MenuId('AgentSessionsToolbar')); }
     static { this.AgentSessionItemToolbar = ( new MenuId('AgentSessionItemToolbar')); }
+    static { this.AgentSessionSectionToolbar = ( new MenuId('AgentSessionSectionToolbar')); }
     static { this.ChatViewSessionTitleNavigationToolbar = ( new MenuId('ChatViewSessionTitleNavigationToolbar')); }
     static { this.ChatViewSessionTitleToolbar = ( new MenuId('ChatViewSessionTitleToolbar')); }
-    static { this.AgentSessionsViewTitle = ( new MenuId('AgentSessionsViewTitle')); }
-    static { this.AgentSessionsFilterSubMenu = ( new MenuId('AgentSessionsFilterSubMenu')); }
     static for(identifier) {
         return MenuId._instances.get(identifier) ?? ( new MenuId(identifier));
     }

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -9,7 +9,7 @@ class MenuHiddenStatesReset extends Action2 {
     constructor() {
         super({
             id: 'menu.resetHiddenStates',
-            title: ( localize2(1758, "Reset All Menus")),
+            title: ( localize2(1765, "Reset All Menus")),
             category: Categories.View,
             f1: true
         });

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -408,7 +408,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localize(1759, 'Hide \'{0}\'', title)),
+        label: ( localize(1766, 'Hide \'{0}\'', title)),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({
@@ -426,7 +426,7 @@ function createMenuHide(menu, command, states) {
 function createConfigureKeybindingAction(commandService, keybindingService, commandId, when = undefined, enabled = true) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1760, "Configure Keybinding")),
+        label: ( localize(1767, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);