@codingame/monaco-vscode-api 1.83.2 → 1.83.3-next.0

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.js

@@ -1,4 +1,4 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
@@ -10,10 +10,7 @@ registry.registerConfiguration({
     'properties': {
         'workbench.enableExperiments': {
             'type': 'boolean',
-            'description': ( localize(
-                'workbench.enableExperiments',
-                "Fetches experiments to run from a Microsoft online service."
-            )),
+            'description': localizeWithPath('vs/workbench/services/assignment/common/assignmentService', 'workbench.enableExperiments', "Fetches experiments to run from a Microsoft online service."),
             'default': true,
             'scope': 1 ,
             'restricted': true,

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -5,6 +5,7 @@ import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 function getAuthenticationProviderActivationEvent(id) { return `onAuthenticationRequest:${id}`; }
 function readAccountUsages(storageService, providerId, accountName) {
     const accountKey = `${providerId}-${accountName}-usages`;
@@ -76,10 +77,39 @@ CommandsRegistry.registerCommand('workbench.getCodeExchangeProxyEndpoints', func
     const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
     return environmentService.options?.codeExchangeProxyEndpoints;
 });
+const authenticationDefinitionSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: {
+            type: 'string',
+            description: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.id', 'The id of the authentication provider.')
+        },
+        label: {
+            type: 'string',
+            description: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.label', 'The human readable name of the authentication provider.'),
+        }
+    }
+};
+( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'authentication',
+    jsonSchema: {
+        description: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', { key: 'authenticationExtensionPoint', comment: [`'Contributes' means adds here`] }, 'Contributes authentication'),
+        type: 'array',
+        items: authenticationDefinitionSchema
+    },
+    activationEventsGenerator: (authenticationProviders, result) => {
+        for (const authenticationProvider of authenticationProviders) {
+            if (authenticationProvider.id) {
+                result.push(`onAuthenticationRequest:${authenticationProvider.id}`);
+            }
+        }
+    }
+}));
 MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
     command: {
         id: 'noAuthenticationProviders',
-        title: ( nls.localize('authentication.Placeholder', "No accounts requested yet...")),
+        title: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.Placeholder', "No accounts requested yet..."),
         precondition: ContextKeyExpr.false()
     },
 });

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -103,10 +103,7 @@ let JSONEditingService = class JSONEditingService {
     toErrorMessage(error) {
         switch (error) {
             case 0 : {
-                return ( nls.localize(
-                    'errorInvalidFile',
-                    "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
-                ));
+                return nls.localizeWithPath('vs/workbench/services/configuration/common/jsonEditingService', 'errorInvalidFile', "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again.");
             }
         }
     }

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -4,7 +4,7 @@ import * as types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import { isWindows, isMacintosh, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { VariableKind, VariableError } from './configurationResolver.js';
 import { replaceAsync } from 'monaco-editor/esm/vs/base/common/strings.js';
 class AbstractVariableResolverService {
@@ -133,7 +133,7 @@ class AbstractVariableResolverService {
             if (filePath) {
                 return normalizeDriveLetter(filePath);
             }
-            throw new VariableError(variableKind, (localize('canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
+            throw new VariableError(variableKind, (localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
         };
         const getFolderPathForFile = (variableKind) => {
             const filePath = getFilePath(variableKind);
@@ -143,7 +143,7 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
+            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -151,15 +151,15 @@ class AbstractVariableResolverService {
                 if (folder) {
                     return folder;
                 }
-                throw new VariableError(variableKind, localize('canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
+                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
             }
             if (folderUri) {
                 return folderUri;
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
-                throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
+                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
             }
-            throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
+            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
         };
         switch (variable) {
             case 'env':
@@ -172,19 +172,19 @@ class AbstractVariableResolverService {
                     }
                     return '';
                 }
-                throw new VariableError(VariableKind.Env, localize('missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
+                throw new VariableError(VariableKind.Env, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
             case 'config':
                 if (argument) {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (types.isUndefinedOrNull(config)) {
-                        throw new VariableError(VariableKind.Config, localize('configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
+                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
                     }
                     if (types.isObject(config)) {
-                        throw new VariableError(VariableKind.Config, localize('configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
+                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
                     }
                     return config;
                 }
-                throw new VariableError(VariableKind.Config, localize('missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
+                throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
             case 'command':
                 return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
             case 'input':
@@ -193,11 +193,11 @@ class AbstractVariableResolverService {
                 if (argument) {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
-                        throw new VariableError(VariableKind.ExtensionInstallFolder, localize('extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
+                        throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
                     }
                     return this.fsPath(ext.extensionLocation);
                 }
-                throw new VariableError(VariableKind.ExtensionInstallFolder, localize('missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
+                throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
             default: {
                 switch (variable) {
                     case 'workspaceRoot':
@@ -212,21 +212,21 @@ class AbstractVariableResolverService {
                         if (environment.userHome) {
                             return environment.userHome;
                         }
-                        throw new VariableError(VariableKind.UserHome, localize('canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
+                        throw new VariableError(VariableKind.UserHome, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
                     }
                     case 'lineNumber': {
                         const lineNumber = this._context.getLineNumber();
                         if (lineNumber) {
                             return lineNumber;
                         }
-                        throw new VariableError(VariableKind.LineNumber, localize('canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
+                        throw new VariableError(VariableKind.LineNumber, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
                     }
                     case 'selectedText': {
                         const selectedText = this._context.getSelectedText();
                         if (selectedText) {
                             return selectedText;
                         }
-                        throw new VariableError(VariableKind.SelectedText, localize('canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
+                        throw new VariableError(VariableKind.SelectedText, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
                     }
                     case 'file':
                         return getFilePath(VariableKind.File);
@@ -291,7 +291,7 @@ class AbstractVariableResolverService {
             if (typeof v === 'string') {
                 return v;
             }
-            throw new VariableError(variableKind, localize('noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
+            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
         }
         return match;
     }

package/vscode/src/vs/workbench/services/decorations/browser/decorationsService.js

@@ -8,7 +8,7 @@ import { createCSSRule, asCSSPropertyValue, removeCSSRulesContainingSelector, cr
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
@@ -147,7 +147,7 @@ class DecorationStyles {
         const strikethrough = ( data.some(d => d.strikethrough));
         if (onlyChildren) {
             badgeClassName = rule.bubbleBadgeClassName;
-            tooltip = ( localize('bubbleTitle', "Contains emphasized items"));
+            tooltip = localizeWithPath('vs/workbench/services/decorations/browser/decorationsService', 'bubbleTitle', "Contains emphasized items");
         }
         return {
             labelClassName,

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -2,7 +2,7 @@ import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
 import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -15,10 +15,7 @@ const editorAssociationsConfigurationNode = {
     properties: {
         'workbench.editorAssociations': {
             type: 'object',
-            markdownDescription: ( localize(
-                'editor.editorAssociations',
-                "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
-            )),
+            markdownDescription: localizeWithPath('vs/workbench/services/editor/common/editorResolverService', 'editor.editorAssociations', "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."),
             additionalProperties: {
                 type: 'string'
             }

package/vscode/src/vs/workbench/services/extensions/browser/extensionUrlHandler.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
@@ -67,8 +67,8 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.extensions.action.manageAuthorizedExtensionURIs',
-            title: { value: ( localize('manage', "Manage Authorized Extension URIs...")), original: 'Manage Authorized Extension URIs...' },
-            category: { value: ( localize('extensions', "Extensions")), original: 'Extensions' },
+            title: { value: localizeWithPath('vs/workbench/services/extensions/browser/extensionUrlHandler', 'manage', "Manage Authorized Extension URIs..."), original: 'Manage Authorized Extension URIs...' },
+            category: { value: localizeWithPath('vs/workbench/services/extensions/browser/extensionUrlHandler', 'extensions', "Extensions"), original: 'Extensions' },
             menu: {
                 id: MenuId.CommandPalette,
                 when: ( IsWebContext.toNegated())
@@ -81,7 +81,7 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
         const storage = ( new UserTrustedExtensionIdStorage(storageService));
         const items = ( storage.extensions.map(label => ({ label, picked: true })));
         if (items.length === 0) {
-            await quickInputService.pick([{ label: ( localize('no', 'There are currently no authorized extension URIs.')) }]);
+            await quickInputService.pick([{ label: localizeWithPath('vs/workbench/services/extensions/browser/extensionUrlHandler', 'no', 'There are currently no authorized extension URIs.') }]);
             return;
         }
         const result = await quickInputService.pick(items, { canPickMany: true });

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.js

@@ -224,11 +224,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         if (result.removedDueToLooping.length > 0) {
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( nls.localize(
-                    'looping',
-                    "The following extensions contain dependency loops and have been disabled: {0}",
-                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', ')
-                ))
+                message: nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'looping', "The following extensions contain dependency loops and have been disabled: {0}", ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', '))
             });
         }
         this._doHandleExtensionPoints([].concat(toAdd).concat(toRemove));
@@ -380,11 +376,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         if (result.removedDueToLooping.length > 0) {
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( nls.localize(
-                    'looping',
-                    "The following extensions contain dependency loops and have been disabled: {0}",
-                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', ')
-                ))
+                message: nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'looping', "The following extensions contain dependency loops and have been disabled: {0}", ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', '))
             });
         }
         this._doHandleExtensionPoints(this._registry.getAllExtensionDescriptions());
@@ -395,11 +387,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
-            const msg = ( nls.localize(
-                'extensionTestError',
-                "No extension host found that can launch the test runner at {0}.",
-                ( this._environmentService.extensionTestsLocationURI.toString())
-            ));
+            const msg = nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionTestError', "No extension host found that can launch the test runner at {0}.", ( this._environmentService.extensionTestsLocationURI.toString()));
             console.error(msg);
             this._notificationService.error(msg);
             return;
@@ -561,12 +549,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( nls.localize(
-                            'extensionStopVetoError',
-                            "{0} (Error: {1})",
-                            reason,
-                            toErrorMessage(error)
-                        )));
+                        vetoReasons.add(nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionStopVetoError', "{0} (Error: {1})", reason, toErrorMessage(error)));
                     });
                 }
             }
@@ -578,21 +561,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         else {
             const vetoReasonsArray = Array.from(vetoReasons);
             this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`);
-            await this._dialogService.warn(( nls.localize(
-                'extensionStopVetoMessage',
-                "The following operation was blocked: {0}",
-                reason
-            )), vetoReasonsArray.length === 1 ?
-                ( nls.localize(
-                    'extensionStopVetoDetailsOne',
-                    "The reason for blocking the operation: {0}",
-                    vetoReasonsArray[0]
-                )) :
-                ( nls.localize(
-                    'extensionStopVetoDetailsMany',
-                    "The reasons for blocking the operation:\n- {0}",
-                    vetoReasonsArray.join('\n -')
-                )));
+            await this._dialogService.warn(nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionStopVetoMessage', "The following operation was blocked: {0}", reason), vetoReasonsArray.length === 1 ?
+                nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionStopVetoDetailsOne', "The reason for blocking the operation: {0}", vetoReasonsArray[0]) :
+                nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionStopVetoDetailsMany', "The reasons for blocking the operation:\n- {0}", vetoReasonsArray.join('\n -')));
         }
         return !veto;
     }
@@ -683,18 +654,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._remoteCrashTracker.registerCrash();
             if (this._remoteCrashTracker.shouldAutomaticallyRestart()) {
                 this._logService.info(`Automatically restarting the remote extension host.`);
-                this._notificationService.status(( nls.localize(
-                    'extensionService.autoRestart',
-                    "The remote extension host terminated unexpectedly. Restarting..."
-                )), { hideAfter: 5000 });
+                this._notificationService.status(nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionService.autoRestart', "The remote extension host terminated unexpectedly. Restarting..."), { hideAfter: 5000 });
                 this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
             }
             else {
-                this._notificationService.prompt(Severity.Error, ( nls.localize(
-                    'extensionService.crash',
-                    "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
-                )), [{
-                        label: ( nls.localize('restart', "Restart Remote Extension Host")),
+                this._notificationService.prompt(Severity.Error, nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'extensionService.crash', "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."), [{
+                        label: nls.localizeWithPath('vs/workbench/services/extensions/common/abstractExtensionService', 'restart', "Restart Remote Extension Host"),
                         run: () => {
                             this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
                         }

package/vscode/src/vs/workbench/services/extensions/common/extensionHostManager.js

@@ -606,7 +606,7 @@ registerAction2(class MeasureExtHostLatencyAction extends Action2 {
         super({
             id: 'editor.action.measureExtHostLatency',
             title: {
-                value: ( nls.localize('measureExtHostLatency', "Measure Extension Host Latency")),
+                value: nls.localizeWithPath('vs/workbench/services/extensions/common/extensionHostManager', 'measureExtHostLatency', "Measure Extension Host Latency"),
                 original: 'Measure Extension Host Latency'
             },
             category: Categories.Developer,