@codingame/monaco-vscode-api 34.1.3 → 35.0.1

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsService.js

@@ -54,7 +54,7 @@ var ToolDataSource;
         if (source.type === "internal") {
             return {
                 ordinal: 1,
-                label: ( localize(8390, "Built-In"))
+                label: ( localize(9007, "Built-In"))
             };
         } else if (source.type === "mcp") {
             return {
@@ -64,7 +64,7 @@ var ToolDataSource;
         } else if (source.type === "user") {
             return {
                 ordinal: 0,
-                label: ( localize(8391, "User Defined"))
+                label: ( localize(9008, "User Defined"))
             };
         } else {
             return {
@@ -93,7 +93,7 @@ function toolContentToA11yString(part) {
             return p.value;
         case "data":
             return localize(
-                8392,
+                9009,
                 "{0} of {1} binary data",
                 ByteSize.formatSize(p.value.data.byteLength),
                 p.value.mimeType || "unknown"
@@ -112,6 +112,32 @@ var ToolInvocationPresentation;
     ToolInvocationPresentation["Hidden"] = "hidden";
     ToolInvocationPresentation["HiddenAfterComplete"] = "hiddenAfterComplete";
 })(ToolInvocationPresentation || (ToolInvocationPresentation = {}));
+class ToolAndToolSetEnablementMap {
+    static fromEntries(entries) {
+        return ( new ToolAndToolSetEnablementMap(( new Map(entries))));
+    }
+    static fromMap(map) {
+        return ( new ToolAndToolSetEnablementMap(( new Map(map))));
+    }
+    constructor(_map) {
+        this._map = _map;
+    }
+    [Symbol.iterator]() {
+        return this._map[Symbol.iterator]();
+    }
+    get(toolOrToolSet) {
+        return this._map.get(toolOrToolSet);
+    }
+    has(toolOrToolSet) {
+        return ( this._map.has(toolOrToolSet));
+    }
+    get size() {
+        return this._map.size;
+    }
+    entries() {
+        return this._map.entries();
+    }
+}
 function isToolSet(obj) {
     return !!obj && obj.getTools !== undefined;
 }
@@ -122,7 +148,10 @@ class ToolSet {
         icon,
         source,
         description,
+        detail,
         legacyFullNames,
+        deprecated,
+        hiddenInToolsPicker,
         _contextKeyService
     ) {
         this.id = id;
@@ -130,7 +159,10 @@ class ToolSet {
         this.icon = icon;
         this.source = source;
         this.description = description;
+        this.detail = detail;
         this.legacyFullNames = legacyFullNames;
+        this.deprecated = deprecated;
+        this.hiddenInToolsPicker = hiddenInToolsPicker;
         this._contextKeyService = _contextKeyService;
         this._tools = ( new ObservableSet());
         this._toolSets = ( new ObservableSet());
@@ -182,9 +214,18 @@ class ToolSetForModel {
     get description() {
         return this._toolSet.description;
     }
+    get detail() {
+        return this._toolSet.detail;
+    }
     get legacyFullNames() {
         return this._toolSet.legacyFullNames;
     }
+    get deprecated() {
+        return this._toolSet.deprecated;
+    }
+    get hiddenInToolsPicker() {
+        return this._toolSet.hiddenInToolsPicker;
+    }
     constructor(_toolSet, model, toolFilter) {
         this._toolSet = _toolSet;
         this.model = model;
@@ -223,4 +264,4 @@ var VSCodeToolReference;
     VSCodeToolReference.vscode = "vscode";
 })(VSCodeToolReference || (VSCodeToolReference = {}));
 
-export { SpecedToolAliases, ToolDataSource, ToolInvocationPresentation, ToolSet, ToolSetForModel, VSCodeToolReference, createToolSchemaUri, isToolInvocationContext, isToolResultInputOutputDetails, isToolResultOutputDetails, isToolSet, stringifyPromptTsxPart, toolContentToA11yString, toolMatchesModel, toolResultHasBuffers };
+export { SpecedToolAliases, ToolAndToolSetEnablementMap, ToolDataSource, ToolInvocationPresentation, ToolSet, ToolSetForModel, VSCodeToolReference, createToolSchemaUri, isToolInvocationContext, isToolResultInputOutputDetails, isToolResultOutputDetails, isToolSet, stringifyPromptTsxPart, toolContentToA11yString, toolMatchesModel, toolResultHasBuffers };

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service.d.ts

@@ -8,7 +8,7 @@ import { ChatRequestToolReferenceEntry } from "../attachments/chatVariableEntrie
 import { IVariableReference } from "../chatModes.js";
 import { IChatToolInvocation } from "../chatService/chatService.js";
 import { ILanguageModelChatMetadata } from "../languageModels.js";
-import { ToolSet, IToolData, IToolInvokedEvent, IToolImpl, IBeginToolCallOptions, IToolInvocation, CountTokensCallback, IToolResult, IToolSet, ToolDataSource, IToolAndToolSetEnablementMap } from "./languageModelToolsService.js";
+import { ToolSet, IToolData, IToolInvokedEvent, IToolImpl, IBeginToolCallOptions, IToolInvocation, CountTokensCallback, IToolResult, IToolSet, ToolDataSource, ToolAndToolSetEnablementMap } from "./languageModelToolsService.js";
 export declare const ILanguageModelToolsService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelToolsService>;
 export interface ILanguageModelToolsService {
     _serviceBrand: undefined;
@@ -79,10 +79,14 @@ export interface ILanguageModelToolsService {
     createToolSet(source: ToolDataSource, id: string, referenceName: string, options?: {
         icon?: ThemeIcon;
         description?: string;
+        detail?: string;
         legacyFullNames?: string[];
+        deprecated?: boolean;
+        hiddenInToolsPicker?: boolean;
     }): ToolSet & IDisposable;
     getFullReferenceNames(): Iterable<string>;
-    getFullReferenceName(tool: IToolData, toolSet?: IToolSet): string;
+    getFullReferenceName(tool: IToolData | IToolSet, toolSet?: IToolSet): string;
+    getFullReferenceNameMap(): Map<IToolData | IToolSet, string>;
     getToolByFullReferenceName(fullReferenceName: string): IToolData | IToolSet | undefined;
     getDeprecatedFullReferenceNames(): Map<string, Set<string>>;
     /**
@@ -91,7 +95,7 @@ export interface ILanguageModelToolsService {
     * @param model Optional language model metadata to filter tools by.
     * If undefined is passed, all tools will be returned, even if normally disabled.
     */
-    toToolAndToolSetEnablementMap(fullReferenceNames: readonly string[], model: ILanguageModelChatMetadata | undefined): IToolAndToolSetEnablementMap;
-    toFullReferenceNames(map: IToolAndToolSetEnablementMap): string[];
+    toToolAndToolSetEnablementMap(fullReferenceNames: readonly string[], model: ILanguageModelChatMetadata | undefined): ToolAndToolSetEnablementMap;
+    toFullReferenceNames(map: ToolAndToolSetEnablementMap): string[];
     toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[];
 }

package/vscode/src/vs/workbench/contrib/chat/common/voiceClient/voiceClientService.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Session context sent to the voice server for grounding.
+ */
+export interface IVoiceSessionContext {
+    sessions: {
+        id: string;
+        is_active: boolean;
+        agent_state: string;
+        agent_state_detail?: string;
+        last_response_summary?: string;
+    }[];
+    active_session?: {
+        id: string;
+        last_message: string | null;
+    };
+    display_locale?: string;
+}
+/**
+ * Inbound message types emitted by the voice client service.
+ */
+export interface IVoiceTranscription {
+    readonly text: string;
+    readonly status?: "partial" | "final";
+    readonly committed?: string;
+}
+export interface IVoiceAudioResponse {
+    readonly audio: string;
+    readonly isFirstChunk: boolean;
+    readonly isFinal: boolean;
+    readonly codingSessionId?: string;
+    readonly transcript?: string;
+}
+export interface IVoiceToolCall {
+    readonly callId: string;
+    readonly name: string;
+    readonly args: Record<string, unknown>;
+}
+export interface IVoiceSpeechStarted {
+}
+export interface IVoiceSessionInit {
+    readonly sessionId: string;
+}
+/**
+ * One entry in the cross-session timeline the FE replays to the BE on
+ * ``start_session``. The BE's coding_agent renders these into a
+ * ``[PRIOR_CONTEXT]`` block on the *first* command after reconnect so the
+ * model can answer "what were we doing?" / "remember xyz?" without any
+ * server-side persistence.
+ *
+ * Kinds:
+ *   user_voice         — what the user said
+ *   agent_voice        — what the voice agent spoke back
+ *   agent_tool_call    — a tool the voice agent dispatched (send_to_chat, etc.)
+ *   coding_event       — a coding-session status transition
+ *                        (e.g. ``thinking → waiting_for_confirmation``)
+ *   coding_agent_reply — first ~2 sentences of the latest Copilot Chat
+ *                        response per active session (synthesized
+ *                        FE-side at connect time, never persisted to disk)
+ */
+export type IVoicePriorTimelineKind = "user_voice" | "agent_voice" | "agent_tool_call" | "coding_event" | "coding_agent_reply";
+export interface IVoicePriorTimelineEntry {
+    readonly kind: IVoicePriorTimelineKind;
+    /** ISO 8601 wall-clock time of the entry. Used for chronological ordering. */
+    readonly timestamp: string;
+    /**
+     * Human/LLM-readable one-line summary. The BE renders this directly
+     * into the prompt without further parsing.
+     */
+    readonly text: string;
+    /** Tool name for ``agent_tool_call`` entries (also encoded inside ``text``). */
+    readonly toolName?: string;
+    /** Originating coding-session id for ``coding_event`` / ``coding_agent_reply``. */
+    readonly codingSessionId?: string;
+    /** Status string for ``coding_event`` (e.g. ``thinking``, ``idle``). */
+    readonly codingStatus?: string;
+}
+/**
+ * Payload sent to the backend for a user-initiated feedback submission.
+ */
+export interface IVoiceFeedbackPayload {
+    readonly feedbackText: string;
+    readonly machineId: string;
+    readonly userId: string;
+    readonly sessionId: string;
+    readonly submissionId: string;
+    readonly transcriptHistory: readonly IVoiceFeedbackTranscriptTurn[];
+    readonly clientSessionState: Record<string, unknown>;
+    readonly clientEnvironment: Record<string, unknown>;
+    readonly timestamp: string;
+}
+export interface IVoiceFeedbackTranscriptTurn {
+    readonly role: "user" | "assistant";
+    readonly text: string;
+    readonly timestamp: string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/voiceClient/voiceClientService.service.d.ts

@@ -0,0 +1,65 @@
+import { Event } from "../../../../../base/common/event.js";
+import { IVoiceSessionContext, IVoicePriorTimelineEntry, IVoiceFeedbackPayload, IVoiceTranscription, IVoiceAudioResponse, IVoiceToolCall, IVoiceSpeechStarted, IVoiceSessionInit } from "./voiceClientService.js";
+export interface IVoiceClientService {
+    readonly _serviceBrand: undefined;
+    connect(window: Window & typeof globalThis, authToken?: string): Promise<void>;
+    disconnect(): void;
+    sendPttStart(turnId: string): void;
+    sendPttAudioChunk(audio: string): void;
+    sendPttEnd(): void;
+    /**
+    * Send a per-press post-mortem diagnostic payload for tail-loss
+    * investigation. Fired ~500ms after `pttUp` by the mic service.
+    * `metrics` is an opaque object echoed straight into a structured
+    * backend log keyed by `turnId`.
+    */
+    sendPttDiagnostic(turnId: string, metrics: Record<string, unknown>): void;
+    sendSessionContext(context: IVoiceSessionContext): void;
+    /**
+    * Synchronously flush any pending debounced ``session_context`` delta on the
+    * wire. Use this before sending a ``session_state_change`` so the backend
+    * has the latest per-session ``last_response_summary`` / ``agent_state``
+    * before it reacts to the state transition (e.g. to run summarisation).
+    * Safe to call when no flush is pending — it just no-ops.
+    */
+    flushSessionContext(): void;
+    /**
+    * Clear the cached last-sent fields for a session so the next
+    * ``_sendDelta`` treats it as a brand-new session (full field send).
+    * Use when the confirmation detail changes within the same
+    * ``agent_state`` — the normal merge-patch would strip the detail
+    * because the state field itself didn't change.
+    */
+    invalidateSessionCache(sessionId: string): void;
+    sendToolResult(callId: string, result: string): void;
+    /**
+    * Notify the backend of a session state transition.
+    *
+    * ``detail`` carries the human-readable description of the transition
+    * (e.g. the confirmation prompt content for ``waiting_for_confirmation``)
+    * and ``lastResponseSummary`` carries the agent's last response text for
+    * ``idle`` transitions. Including them inline ensures the BE has the data
+    * it needs to react/summarise without depending on the separate (debounced)
+    * ``session_context`` delta arriving first or being current.
+    */
+    sendSessionStateChange(sessionId: string, newState: string, label: string, detail?: string, lastResponseSummary?: string): void;
+    stopSpeaking(): void;
+    sendStartSession(context: IVoiceSessionContext, machineId: string, priorTimeline?: readonly IVoicePriorTimelineEntry[]): void;
+    sendResumeSession(context: IVoiceSessionContext, machineId: string): void;
+    submitFeedback(payload: IVoiceFeedbackPayload): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    readonly onTranscription: Event<IVoiceTranscription>;
+    readonly onAudioResponse: Event<IVoiceAudioResponse>;
+    readonly onToolCall: Event<IVoiceToolCall>;
+    readonly onSpeechStarted: Event<IVoiceSpeechStarted>;
+    readonly onSessionInit: Event<IVoiceSessionInit>;
+    readonly onError: Event<string>;
+    readonly onDidChangeConnectionState: Event<boolean>;
+    readonly isConnected: boolean;
+    readonly isResuming: boolean;
+    /** Backend session id assigned by the realtime server, or ``undefined`` when not yet established. */
+    readonly currentSessionId: string | undefined;
+}
+export declare const IVoiceClientService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IVoiceClientService>;

package/vscode/src/vs/workbench/contrib/chat/common/voiceClient/voiceClientService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IVoiceClientService = ( createDecorator("voiceClientService"));
+
+export { IVoiceClientService };

package/vscode/src/vs/workbench/contrib/chat/common/voicePlaybackService.service.d.ts

@@ -0,0 +1,47 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IVoicePlaybackEntry } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/voicePlaybackService";
+export declare const IVoicePlaybackService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IVoicePlaybackService>;
+/**
+* Tracks voice playback state for chat sessions: which session is currently
+* speaking, and what the last played message was for each session. Used by
+* the agent sessions view to highlight the speaking row and to drive the
+* "Replay Last Played" action.
+*
+* Playback is reported by the voice agent webview through the workbench
+* commands `_chat.voicePlayback.notifyStart` / `_chat.voicePlayback.notifyEnd`.
+*/
+export interface IVoicePlaybackService {
+    readonly _serviceBrand: undefined;
+    /**
+    * The session resource currently being spoken aloud, or `undefined` if
+    * playback is generic (no session id from the backend) or stopped.
+    */
+    readonly speakingSession: IObservable<URI | undefined>;
+    /**
+    * Increments whenever the per-session last-played map changes. Consumers
+    * can subscribe via `read(reader)` to refresh state without us exposing
+    * the underlying `ResourceMap`.
+    */
+    readonly lastPlayedVersion: IObservable<number>;
+    /**
+    * Records the start of a TTS playback. When `sessionResource` is undefined,
+    * the audio is generic and no per-session state is updated.
+    */
+    notifyPlaybackStart(sessionResource: URI | undefined, transcript: string | undefined): void;
+    notifyPlaybackEnd(sessionResource: URI | undefined): void;
+    getLastPlayed(sessionResource: URI): IVoicePlaybackEntry | undefined;
+    hasLastPlayed(sessionResource: URI): boolean;
+    /**
+    * Replays the last played message for `sessionResource` by re-synthesizing
+    * the saved transcript through the registered speech provider. Resolves
+    * once playback completes (or immediately when there is nothing to replay
+    * or no speech provider is available).
+    */
+    replay(sessionResource: URI): Promise<void>;
+    /**
+    * Stops any active playback for the given session (or all playback if
+    * no session is specified).
+    */
+    stop(sessionResource?: URI): void;
+}

package/vscode/src/vs/workbench/contrib/chat/common/voicePlaybackService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IVoicePlaybackService = ( createDecorator("voicePlaybackService"));
+
+export { IVoicePlaybackService };

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -17,13 +17,13 @@ const createCodeActionsAutoSave = description => {
         type: "string",
         enum: ["always", "explicit", "never", true, false],
         enumDescriptions: [( localize(
-            8412,
+            9029,
             "Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes."
-        )), ( localize(8413, "Triggers Code Actions only when explicitly saved")), ( localize(8414, "Never triggers Code Actions on save")), ( localize(
-            8415,
+        )), ( localize(9030, "Triggers Code Actions only when explicitly saved")), ( localize(9031, "Never triggers Code Actions on save")), ( localize(
+            9032,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"explicit\"."
         )), ( localize(
-            8416,
+            9033,
             "Never triggers Code Actions on save. This value will be deprecated in favor of \"never\"."
         ))],
         default: "explicit",
@@ -34,11 +34,11 @@ const createNotebookCodeActionsAutoSave = description => {
     return {
         type: ["string", "boolean"],
         enum: ["explicit", "never", true, false],
-        enumDescriptions: [( localize(8417, "Triggers Code Actions only when explicitly saved.")), ( localize(8418, "Never triggers Code Actions on save.")), ( localize(
-            8419,
+        enumDescriptions: [( localize(9034, "Triggers Code Actions only when explicitly saved.")), ( localize(9035, "Never triggers Code Actions on save.")), ( localize(
+            9036,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"explicit\"."
         )), ( localize(
-            8420,
+            9037,
             "Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of \"never\"."
         ))],
         default: "explicit",
@@ -58,7 +58,7 @@ const codeActionsOnSaveSchema = {
         }
     }],
     markdownDescription: ( localize(
-        8421,
+        9038,
         "Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `\"source.organizeImports\": \"explicit\" `",
         "`#files.autoSave#`"
     )),
@@ -89,7 +89,7 @@ const notebookCodeActionsOnSaveSchema = {
         }
     }],
     markdownDescription: ( localize(
-        8422,
+        9039,
         "Run a series of Code Actions for a notebook on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `\"notebook.source.organizeImports\": \"explicit\"`",
         "`#files.autoSave#`"
     )),
@@ -144,12 +144,12 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         for (const codeActionKind of allProvidedKinds) {
             if (CodeActionKind.Source.contains(codeActionKind) && !properties[codeActionKind.value]) {
                 properties[codeActionKind.value] = createCodeActionsAutoSave(( localize(
-                    8423,
+                    9040,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    8423,
+                    9040,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.js

@@ -32,12 +32,12 @@ import { isWindows } from '../../../../../base/common/platform.js';
 var EditorDictation_1;
 registerCss(editorDictation);
 const EDITOR_DICTATION_IN_PROGRESS = ( new RawContextKey("editorDictation.inProgress", false));
-const VOICE_CATEGORY = ( localize2(8429, "Voice"));
+const VOICE_CATEGORY = ( localize2(9046, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: "workbench.action.editorDictation.start",
-            title: ( localize2(8430, "Start Dictation in Editor")),
+            title: ( localize2(9047, "Start Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: ( ContextKeyExpr.and(HasSpeechProvider, ( SpeechToTextInProgress.toNegated()), (
             EditorContextKeys.readOnly.toNegated()))),
@@ -74,7 +74,7 @@ class EditorDictationStopAction extends EditorAction2 {
     constructor() {
         super({
             id: EditorDictationStopAction.ID,
-            title: ( localize2(8431, "Stop Dictation in Editor")),
+            title: ( localize2(9048, "Stop Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: EDITOR_DICTATION_IN_PROGRESS,
             f1: true,
@@ -99,7 +99,7 @@ class DictationWidget extends Disposable {
         const stopActionKeybinding = keybindingService.lookupKeybinding(EditorDictationStopAction.ID)?.getLabel();
         actionBar.push(toAction({
             id: EditorDictationStopAction.ID,
-            label: stopActionKeybinding ? ( localize(8432, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(8433, "Stop Dictation")),
+            label: stopActionKeybinding ? ( localize(9049, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(9050, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), {

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorAccessibilityHelp.js

@@ -31,12 +31,12 @@ class DiffEditorAccessibilityHelp {
             return;
         }
         const switchSides = ( localize(
-            8434,
+            9051,
             "Run the command Diff Editor: Switch Side{0} to toggle between the original and modified editors.",
             "<keybinding:diffEditor.switchSide>"
         ));
         const diffEditorActiveAnnouncement = ( localize(
-            8435,
+            9052,
             "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."
         ));
         const keys = [
@@ -44,13 +44,13 @@ class DiffEditorAccessibilityHelp {
             "accessibility.signals.diffLineInserted",
             "accessibility.signals.diffLineModified"
         ];
-        const content = [( localize(8436, "You are in a diff editor.")), ( localize(
-            8437,
+        const content = [( localize(9053, "You are in a diff editor.")), ( localize(
+            9054,
             "View the next{0} or previous{1} diff in diff review mode, which is optimized for screen readers.",
             "<keybinding:" + AccessibleDiffViewerNext.id + ">",
             "<keybinding:" + AccessibleDiffViewerPrev.id + ">"
         )), switchSides, diffEditorActiveAnnouncement, ( localize(
-            8438,
+            9055,
             "To control which accessibility signals should be played, the following settings can be configured: {0}.",
             keys.join(", ")
         ))];

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorHelper.js

@@ -46,7 +46,7 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
                     const helperWidget = store.add(this._instantiationService.createInstance(
                         FloatingEditorClickWidget,
                         this._diffEditor.getModifiedEditor(),
-                        ( localize(8439, "Show Whitespace Differences")),
+                        ( localize(9056, "Show Whitespace Differences")),
                         null
                     ));
                     store.add(helperWidget.onClick(() => {
@@ -63,11 +63,11 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
                 const diffComputationResult = this._diffEditor.getDiffComputationResult();
                 if (diffComputationResult && diffComputationResult.quitEarly) {
                     this._notificationService.prompt(Severity$1.Warning, ( localize(
-                        8440,
+                        9057,
                         "The diff algorithm was stopped early (after {0} ms.)",
                         this._diffEditor.maxComputationTime
                     )), [{
-                        label: ( localize(8441, "Remove Limit")),
+                        label: ( localize(9058, "Remove Limit")),
                         run: () => {
                             this._textResourceConfigurationService.updateValue(
                                 this._diffEditor.getModel().modified.uri,

package/vscode/src/vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget.js

@@ -29,11 +29,11 @@ import '../../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../../platform/theme/common/colors/searchColors.js';
 
 registerCss(simpleFindWidget);
-const NLS_FIND_INPUT_LABEL = ( localize(8448, "Find"));
-const NLS_FIND_INPUT_PLACEHOLDER = ( localize(8449, "Find"));
-const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(8450, "Previous Match"));
-const NLS_NEXT_MATCH_BTN_LABEL = ( localize(8451, "Next Match"));
-const NLS_CLOSE_BTN_LABEL = ( localize(8452, "Close"));
+const NLS_FIND_INPUT_LABEL = ( localize(9065, "Find"));
+const NLS_FIND_INPUT_PLACEHOLDER = ( localize(9066, "Find"));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(9067, "Previous Match"));
+const NLS_NEXT_MATCH_BTN_LABEL = ( localize(9068, "Next Match"));
+const NLS_CLOSE_BTN_LABEL = ( localize(9069, "Close"));
 const SIMPLE_FIND_WIDGET_INITIAL_WIDTH = 310;
 const MATCHES_COUNT_WIDTH = 73;
 class SimpleFindWidget extends Widget {
@@ -359,7 +359,7 @@ class SimpleFindWidget extends Widget {
         if (!this._accessibilityHelpHintAnnounced && this._configurationService.getValue("accessibility.verbosity.find") && this._accessibilityService.isScreenReaderOptimized()) {
             const keybinding = this._keybindingService.lookupKeybinding("editor.action.accessibilityHelp")?.getAriaLabel();
             if (keybinding) {
-                findLabel += ", " + ( localize(8453, "Press {0} for accessibility help", keybinding));
+                findLabel += ", " + ( localize(9070, "Press {0} for accessibility help", keybinding));
                 this._accessibilityHelpHintAnnounced = true;
                 this._labelResetTimeout?.dispose();
                 this._labelResetTimeout = disposableTimeout(() => {
@@ -373,12 +373,12 @@ class SimpleFindWidget extends Widget {
     }
     _announceSearchResults(label, searchString) {
         if (!searchString) {
-            return localize(8454, "Enter search input");
+            return localize(9071, "Enter search input");
         }
         if (label === NLS_NO_RESULTS) {
-            return searchString === "" ? ( localize(8455, "{0} found", label)) : ( localize(8456, "{0} found for '{1}'", label, searchString));
+            return searchString === "" ? ( localize(9072, "{0} found", label)) : ( localize(9073, "{0} found for '{1}'", label, searchString));
         }
-        return localize(8457, "{0} found for '{1}'", label, searchString);
+        return localize(9074, "{0} found for '{1}'", label, searchString);
     }
 }
 const simpleFindWidgetSashBorder = registerColor("simpleFindWidget.sashBorder", {
@@ -386,7 +386,7 @@ const simpleFindWidgetSashBorder = registerColor("simpleFindWidget.sashBorder",
     light: "#C8C8C8",
     hcDark: "#6FC3DF",
     hcLight: "#0F4A85"
-}, ( localize(8458, "Border color of the sash border.")));
+}, ( localize(9075, "Border color of the sash border.")));
 registerThemingParticipant((theme, collector) => {
     const resizeBorderBackground = theme.getColor(simpleFindWidgetSashBorder);
     collector.addRule(

package/vscode/src/vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens.js

@@ -103,7 +103,7 @@ class InspectEditorTokens extends EditorAction {
     constructor() {
         super({
             id: "editor.action.inspectTMScopes",
-            label: ( localize2(8459, "Developer: Inspect Editor Tokens and Scopes")),
+            label: ( localize2(9076, "Developer: Inspect Editor Tokens and Scopes")),
             precondition: undefined
         });
     }
@@ -186,7 +186,7 @@ class InspectEditorTokensWidget extends Disposable {
         const backend = this._model.tokenization.tokens.get();
         const asTreeSitterBackend = backend instanceof TreeSitterSyntaxTokenBackend ? backend : undefined;
         clearNode(this._domNode);
-        this._domNode.appendChild(createTextNode(( localize(8460, "Loading..."))));
+        this._domNode.appendChild(createTextNode(( localize(9077, "Loading..."))));
         Promise.all([grammar, semanticTokens]).then(([grammar, semanticTokens]) => {
             if (this._isDisposed) {
                 return;

package/vscode/src/vs/workbench/contrib/codeEditor/browser/largeFileOptimizations.js

@@ -28,15 +28,15 @@ let LargeFileOptimizationsWarner = class LargeFileOptimizationsWarner extends Di
         }
         if (model.isTooLargeForTokenization()) {
             const message = ( localize(
-                8461,
+                9078,
                 "{0}: tokenization, wrapping, folding, codelens, word highlighting and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.",
                 basename(model.uri.path)
             ));
             this._notificationService.prompt(Severity$1.Info, message, [{
-                label: ( localize(8462, "Forcefully Enable Features")),
+                label: ( localize(9079, "Forcefully Enable Features")),
                 run: () => {
                     this._configurationService.updateValue(`editor.largeFileOptimizations`, false).then(() => {
-                        this._notificationService.info(( localize(8463, "Please reopen file in order for this setting to take effect.")));
+                        this._notificationService.info(( localize(9080, "Please reopen file in order for this setting to take effect.")));
                     }, err => {
                         this._notificationService.error(err);
                     });

package/vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js

@@ -210,7 +210,7 @@ let GotoSymbolQuickAccessProvider = class GotoSymbolQuickAccessProvider extends
                     return true;
                 });
                 if (filteredItems.length === 0) {
-                    const label = ( localize(8474, "No matching entries"));
+                    const label = ( localize(9091, "No matching entries"));
                     picker.items = [{
                         label,
                         index: -1,
@@ -251,8 +251,8 @@ class GotoSymbolAction extends Action2 {
         super({
             id: GotoSymbolAction.ID,
             title: {
-                ...( localize2(8475, "Go to Symbol in Editor...")),
-                mnemonicTitle: ( localize(8476, "Go to &&Symbol in Editor..."))
+                ...( localize2(9092, "Go to Symbol in Editor...")),
+                mnemonicTitle: ( localize(9093, "Go to &&Symbol in Editor..."))
             },
             f1: true,
             keybinding: {
@@ -278,14 +278,14 @@ registerAction2(GotoSymbolAction);
     ctor: GotoSymbolQuickAccessProvider,
     prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX,
     contextKey: "inFileSymbolsPicker",
-    placeholder: ( localize(8477, "Type the name of a symbol to go to.")),
+    placeholder: ( localize(9094, "Type the name of a symbol to go to.")),
     helpEntries: [{
-        description: ( localize(8478, "Go to Symbol in Editor")),
+        description: ( localize(9095, "Go to Symbol in Editor")),
         prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX,
         commandId: GotoSymbolAction.ID,
         commandCenterOrder: 40
     }, {
-        description: ( localize(8479, "Go to Symbol in Editor by Category")),
+        description: ( localize(9096, "Go to Symbol in Editor by Category")),
         prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX_BY_CATEGORY
     }]
 });