chrome-devtools-frontend 1.0.1704172 → 1.0.1705227

package/AUTHORS

@@ -124,6 +124,7 @@ Yoichiro Hibara <hibarayoichiro871@gmail.com>
 Yoni Feigelson <yfeigelson@gmail.com>
 Young Min Kim <y@ylem.kim>
 Yuan Zhuang <joann.yuanzhuang@gmail.com>
+Zeeshan Ahmad <zeeshanahmad125114@gmail.com>
 Zuyao Chen <zuyaocat@gmail.com>
 # Please DO NOT APPEND here. See comments at the top of the file.
 # END individuals section.

package/docs/architecture_of_devtools.md

@@ -121,7 +121,7 @@ There are multiple variants of the DevTools application.
 The main DevTools application is [devtools_app.ts](../front_end/entrypoints/devtools_app/devtools_app.ts), which developers can open via F12 or "Right click -> Inspect element" in their Chromium browser.
 Other application entrypoints are a dedicated tool for debugging Node on which multiple targets can be inspected ([node_app.ts](../front_end/entrypoints/node_app/node_app.ts)), a non-browser context debugger for V8 targets ([js_app.ts](../front_end/entrypoints/js_app/js_app.ts)), a (service) worker context ([worker_app.ts](../front_end/entrypoints/worker_app/worker_app.ts)), remote debugging of (Android) devices ([inspector.ts](../front_end/entrypoints/inspector/inspector.ts)) and a basic version of DevTools which was initially intended for non-browser targets but doesn't have any particular use case that differentiates it from the other variants ([ndb_app.ts](../front_end/entrypoints/ndb_app/ndb_app.ts)).
 
-Each application entrypoint has a corresponding `.html` file with the same name, that is automatically in the frontend generated and can be loaded by the Chromium DevTools backend.
+Each application entrypoint has a corresponding `.html` file with the same name, that is automatically generated in the frontend and can be loaded by the Chromium DevTools backend.
 The JavaScript files import the relevant "meta" files containing the declarations of DevTools features.
 
 ## Upfront declaration of DevTools features

package/docs/cookbook/localization.md

@@ -286,8 +286,8 @@ const UIStrings = {
 
 ## How to prevent a term being localized
 
-Any text within the backticks will not be translated. For example, if the
-'robots.txt' in string 'Requesting for robots.txt …' should not be translated:
+Any text within the backticks will not be translated. For example,
+'robots.txt' in the string 'Requesting for robots.txt …' should not be translated:
 
 ```ts
 // in example.js file

package/front_end/core/common/README.md

@@ -6,14 +6,15 @@ A settings registration is represented by the `SettingRegistration` interface, d
 
 All settings have to be registered using the function `Common.Settings.registerSettingExtension` which expects an object of type `SettingRegistration` as parameter.
 
-As an example, take the registration of the `showHTMLComments` setting, which allows users to determine if HTML comments are shown in the Elements tree:
+As an example, take the registration of the `show-html-comments` setting, which allows users to determine if HTML comments are shown in the Elements tree:
 
 ```ts
 Common.Settings.registerSettingExtension({
   category: Common.Settings.SettingCategory.ELEMENTS,
+  storageType: Common.Settings.SettingStorageType.SYNCED,
   order: 3,
-  title: ls`Show HTML comments`,
-  settingName: 'showHTMLComments',
+  title: ls`HTML comments`,
+  settingName: 'show-html-comments',
   settingType: Common.Settings.SettingType.BOOLEAN,
   defaultValue: true,
   options: [

package/front_end/entrypoints/formatter_actions/formatter_actions.ts

@@ -51,6 +51,24 @@ export const enum ScopeKind {
   ARROW_FUNCTION = 4,
 }
 
+/**
+ * Describes a single scope for `javaScriptSubstitute`.
+ */
+export interface ScopeVariableMapping {
+  /**
+   * Authored variable name -> generated binding expression, or `null` if the variable is unavailable.
+   */
+  bindings: Map<string, string|null>;
+  /**
+   * Generated identifiers declared by this scope. Together with the free identifiers of `bindings`, these
+   * shadow bindings of outer scopes that refer to the same generated identifiers.
+   *
+   * This is needed when a generated identifier doesn't show up in any binding expression, e.g. because
+   * multiple generated identifiers map to the same authored name, or the authored name is unknown.
+   */
+  generatedNames: string[];
+}
+
 export interface ScopeTreeNode {
   variables: Array<{name: string, kind: DefinitionKind, offsets: number[]}>;
   start: number;

package/front_end/entrypoints/formatter_worker/Substitute.ts

@@ -3,13 +3,13 @@
 // found in the LICENSE file.
 
 import * as Acorn from '../../third_party/acorn/acorn.js';
-import {DefinitionKind} from '../formatter_actions/formatter_actions.js';
+import {DefinitionKind, type ScopeVariableMapping} from '../formatter_actions/formatter_actions.js';
 
 import {ECMA_VERSION} from './AcornTokenizer.js';
 import {ScopeVariableAnalysis, type VariableUses} from './ScopeParser.js';
 
-export function substituteExpression(expression: string, nameMaps: Array<Map<string, string|null>>): string {
-  const replacements = computeSubstitution(expression, nameMaps);
+export function substituteExpression(expression: string, scopes: ScopeVariableMapping[]): string {
+  const replacements = computeSubstitution(expression, scopes);
   return applySubstitution(expression, replacements);
 }
 
@@ -52,12 +52,12 @@ function parseBindingExpression(expression: string): {
 }
 
 /**
- * Given an |expression| and a mapping from names to new names, the |computeSubstitution|
+ * Given an |expression| and a list of |scopes| (from inner-most to outer-most), the |computeSubstitution|
  * function returns a list of replacements sorted by the offset. The function throws if
  * it cannot parse the expression or the substitution is impossible to perform (for example
  * if the substitution target is 'this' within a function, it would become bound there).
  **/
-function computeSubstitution(expression: string, nameMaps: Array<Map<string, string|null>>): Replacement[] {
+function computeSubstitution(expression: string, scopes: ScopeVariableMapping[]): Replacement[] {
   // Parse the expression and find variables and scopes.
   const root = Acorn.parse(expression, {
     ecmaVersion: ECMA_VERSION,
@@ -75,10 +75,11 @@ function computeSubstitution(expression: string, nameMaps: Array<Map<string, str
   const allNames = scopeVariables.getAllNames();
   const nameMap = new Map<string, string|null>();
   const parsedBindings = new Map<string, ReturnType<typeof parseBindingExpression>>();
+  // Generated identifiers declared by the scopes visited so far. Outer bindings referring to them are shadowed.
   const shadowedNames = new Set<string>();
-  for (const scopeMap of nameMaps) {
-    const scopeNames = new Set<string>();
-    for (const [name, rename] of scopeMap.entries()) {
+  for (const {bindings, generatedNames} of scopes) {
+    const scopeNames = new Set<string>(generatedNames);
+    for (const [name, rename] of bindings.entries()) {
       let parsed: ReturnType<typeof parseBindingExpression>|undefined;
       if (rename !== null) {
         try {

package/front_end/entrypoints/formatter_worker/formatter_worker-entrypoint.ts

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 import * as Platform from '../../core/platform/platform.js';
-import {FormatterActions} from '../formatter_actions/formatter_actions.js';
+import {FormatterActions, type ScopeVariableMapping} from '../formatter_actions/formatter_actions.js';
 
 import * as FormatterWorker from './formatter_worker.js';
 
@@ -13,7 +13,7 @@ Platform.HostRuntime.HOST_RUNTIME.workerScope.onmessage = function(event): void
     indentString: string,
     content: string,
     mimeType: string,
-    mapping: Array<Map<string, string|null>>,
+    mapping: ScopeVariableMapping[],
     sourceType: 'module'|'script',
   } = event.data.params;
   if (!method) {

package/front_end/foundation/Universe.ts

@@ -21,6 +21,7 @@ import * as LiveMetrics from '../models/live-metrics/live-metrics.js';
 import * as Logs from '../models/logs/logs.js';
 import * as Persistence from '../models/persistence/persistence.js';
 import * as ProjectSettings from '../models/project_settings/project_settings.js';
+import * as SourceMapScopes from '../models/source_map_scopes/source_map_scopes.js';
 import * as Workspace from '../models/workspace/workspace.js';
 import * as WorkspaceDiff from '../models/workspace_diff/workspace_diff.js';
 
@@ -160,6 +161,10 @@ export class Universe {
         resourceMapping, targetManager, ignoreListManager, workspace);
     context.set(Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding, debuggerWorkspaceBinding);
 
+    const scopeChainResolver =
+        new SourceMapScopes.ScopeChainResolver.ScopeChainResolver(targetManager, debuggerWorkspaceBinding);
+    context.set(SourceMapScopes.ScopeChainResolver.ScopeChainResolver, scopeChainResolver);
+
     const presentationConsoleMessageManager =
         new Bindings.PresentationConsoleMessageHelper.PresentationConsoleMessageManager(
             targetManager, workspace, debuggerWorkspaceBinding, cssWorkspaceBinding);
@@ -383,6 +388,10 @@ export class Universe {
                                           null;
   }
 
+  get scopeChainResolver(): SourceMapScopes.ScopeChainResolver.ScopeChainResolver {
+    return this.context.get(SourceMapScopes.ScopeChainResolver.ScopeChainResolver);
+  }
+
   get settings(): Common.Settings.Settings {
     return this.context.get(Common.Settings.Settings);
   }

package/front_end/generated/InspectorBackendCommands.ts

@@ -545,7 +545,8 @@ inspectorBackend.registerCommand("Emulation.setSafeAreaInsetsOverride", [{"name"
 inspectorBackend.registerCommand("Emulation.setVirtualKeyboardGeometryOverride", [{"name": "keyboardRect", "type": "object", "optional": true, "description": "", "typeRef": "DOM.Rect"}], [], "Overrides virtual keyboard geometry in CSS pixels, relative to the top-level viewport. The provided rect is used for navigator.virtualKeyboard.boundingRect, geometrychange events, and env(keyboard-inset-*) values on the inspected frame. The override applies independently of navigator.virtualKeyboard.overlaysContent so clients can preview overlay geometry without mutating page state. Values are rounded to the nearest CSS pixel. Omitting the rect clears the override.");
 inspectorBackend.registerEnum("Emulation.SetDeviceMetricsOverrideRequestScrollbarType", {Overlay: "overlay", Default: "default"});
 inspectorBackend.registerEnum("Emulation.SetDeviceMetricsOverrideRequestViewportMeta", {Enable: "enable", Default: "default"});
-inspectorBackend.registerCommand("Emulation.setDeviceMetricsOverride", [{"name": "width", "type": "number", "optional": false, "description": "Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null}, {"name": "height", "type": "number", "optional": false, "description": "Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null}, {"name": "deviceScaleFactor", "type": "number", "optional": false, "description": "Overriding device scale factor value. 0 disables the override.", "typeRef": null}, {"name": "mobile", "type": "boolean", "optional": false, "description": "Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.", "typeRef": null}, {"name": "scale", "type": "number", "optional": true, "description": "Scale to apply to resulting view image.", "typeRef": null}, {"name": "screenWidth", "type": "number", "optional": true, "description": "Overriding screen width value in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "screenHeight", "type": "number", "optional": true, "description": "Overriding screen height value in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "positionX", "type": "number", "optional": true, "description": "Overriding view X position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "positionY", "type": "number", "optional": true, "description": "Overriding view Y position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "dontSetVisibleSize", "type": "boolean", "optional": true, "description": "Do not set visible view size, rely upon explicit setVisibleSize call.", "typeRef": null}, {"name": "screenOrientation", "type": "object", "optional": true, "description": "Screen orientation override.", "typeRef": "Emulation.ScreenOrientation"}, {"name": "viewport", "type": "object", "optional": true, "description": "If set, the visible area of the page will be overridden to this viewport. This viewport change is not observed by the page, e.g. viewport-relative elements do not change positions.", "typeRef": "Page.Viewport"}, {"name": "displayFeature", "type": "object", "optional": true, "description": "If set, the display feature of a multi-segment screen. If not set, multi-segment support is turned-off. Deprecated, use Emulation.setDisplayFeaturesOverride.", "typeRef": "Emulation.DisplayFeature"}, {"name": "devicePosture", "type": "object", "optional": true, "description": "If set, the posture of a foldable device. If not set the posture is set to continuous. Deprecated, use Emulation.setDevicePostureOverride.", "typeRef": "Emulation.DevicePosture"}, {"name": "scrollbarType", "type": "string", "optional": true, "description": "Scrollbar type. Default: `default`.", "typeRef": "Emulation.SetDeviceMetricsOverrideRequestScrollbarType"}, {"name": "screenOrientationLockEmulation", "type": "boolean", "optional": true, "description": "If set to true, enables screen orientation lock emulation, which intercepts screen.orientation.lock() calls from the page and reports orientation changes via screenOrientationLockChanged events. This is useful for emulating mobile device orientation lock behavior in responsive design mode.", "typeRef": null}, {"name": "viewportMeta", "type": "string", "optional": true, "description": "Viewport meta tag behavior. Default: `default`. Note: if `mobile` is `true`, the viewport meta tag is always enabled.", "typeRef": "Emulation.SetDeviceMetricsOverrideRequestViewportMeta"}], [], "Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and \"device-width\"/\"device-height\"-related CSS media query results).");
+inspectorBackend.registerEnum("Emulation.SetDeviceMetricsOverrideRequestTextLayoutMode", {Mobile: "mobile", Default: "default"});
+inspectorBackend.registerCommand("Emulation.setDeviceMetricsOverride", [{"name": "width", "type": "number", "optional": false, "description": "Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null}, {"name": "height", "type": "number", "optional": false, "description": "Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null}, {"name": "deviceScaleFactor", "type": "number", "optional": false, "description": "Overriding device scale factor value. 0 disables the override.", "typeRef": null}, {"name": "mobile", "type": "boolean", "optional": false, "description": "Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.", "typeRef": null}, {"name": "scale", "type": "number", "optional": true, "description": "Scale to apply to resulting view image.", "typeRef": null}, {"name": "screenWidth", "type": "number", "optional": true, "description": "Overriding screen width value in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "screenHeight", "type": "number", "optional": true, "description": "Overriding screen height value in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "positionX", "type": "number", "optional": true, "description": "Overriding view X position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "positionY", "type": "number", "optional": true, "description": "Overriding view Y position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null}, {"name": "dontSetVisibleSize", "type": "boolean", "optional": true, "description": "Do not set visible view size, rely upon explicit setVisibleSize call.", "typeRef": null}, {"name": "screenOrientation", "type": "object", "optional": true, "description": "Screen orientation override.", "typeRef": "Emulation.ScreenOrientation"}, {"name": "viewport", "type": "object", "optional": true, "description": "If set, the visible area of the page will be overridden to this viewport. This viewport change is not observed by the page, e.g. viewport-relative elements do not change positions.", "typeRef": "Page.Viewport"}, {"name": "displayFeature", "type": "object", "optional": true, "description": "If set, the display feature of a multi-segment screen. If not set, multi-segment support is turned-off. Deprecated, use Emulation.setDisplayFeaturesOverride.", "typeRef": "Emulation.DisplayFeature"}, {"name": "devicePosture", "type": "object", "optional": true, "description": "If set, the posture of a foldable device. If not set the posture is set to continuous. Deprecated, use Emulation.setDevicePostureOverride.", "typeRef": "Emulation.DevicePosture"}, {"name": "scrollbarType", "type": "string", "optional": true, "description": "Scrollbar type. Default: `default`.", "typeRef": "Emulation.SetDeviceMetricsOverrideRequestScrollbarType"}, {"name": "screenOrientationLockEmulation", "type": "boolean", "optional": true, "description": "If set to true, enables screen orientation lock emulation, which intercepts screen.orientation.lock() calls from the page and reports orientation changes via screenOrientationLockChanged events. This is useful for emulating mobile device orientation lock behavior in responsive design mode.", "typeRef": null}, {"name": "viewportMeta", "type": "string", "optional": true, "description": "Viewport meta tag behavior. Default: `default`. Note: if `mobile` is `true`, the viewport meta tag is always enabled.", "typeRef": "Emulation.SetDeviceMetricsOverrideRequestViewportMeta"}, {"name": "textLayoutMode", "type": "string", "optional": true, "description": "Text layout mode. Default: `default`. Note: if `mobile` is `true`, mobile text layout mode (text autosizing) is always enabled.", "typeRef": "Emulation.SetDeviceMetricsOverrideRequestTextLayoutMode"}], [], "Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and \"device-width\"/\"device-height\"-related CSS media query results).");
 inspectorBackend.registerCommand("Emulation.setDevicePostureOverride", [{"name": "posture", "type": "object", "optional": false, "description": "", "typeRef": "Emulation.DevicePosture"}], [], "Start reporting the given posture value to the Device Posture API. This override can also be set in setDeviceMetricsOverride().");
 inspectorBackend.registerCommand("Emulation.clearDevicePostureOverride", [], [], "Clears a device posture override set with either setDeviceMetricsOverride() or setDevicePostureOverride() and starts using posture information from the platform again. Does nothing if no override is set.");
 inspectorBackend.registerCommand("Emulation.setDisplayFeaturesOverride", [{"name": "features", "type": "array", "optional": false, "description": "", "typeRef": "Emulation.DisplayFeature"}], [], "Start using the given display features to pupulate the Viewport Segments API. This override can also be set in setDeviceMetricsOverride().");
@@ -1240,7 +1241,7 @@ inspectorBackend.registerEvent("Preload.ruleSetUpdated", ["ruleSet"]);
 inspectorBackend.registerEvent("Preload.ruleSetRemoved", ["id"]);
 inspectorBackend.registerEvent("Preload.preloadEnabledStateUpdated", ["disabledByPreference", "disabledByDataSaver", "disabledByBatterySaver", "disabledByHoldbackPrefetchSpeculationRules", "disabledByHoldbackPrerenderSpeculationRules"]);
 inspectorBackend.registerEvent("Preload.prefetchStatusUpdated", ["key", "pipelineId", "initiatingFrameId", "prefetchUrl", "status", "prefetchStatus", "requestId"]);
-inspectorBackend.registerEvent("Preload.prerenderStatusUpdated", ["key", "pipelineId", "status", "prerenderStatus", "disallowedMojoInterface", "mismatchedHeaders"]);
+inspectorBackend.registerEvent("Preload.prerenderStatusUpdated", ["key", "pipelineId", "status", "effectiveAction", "prerenderStatus", "disallowedMojoInterface", "mismatchedHeaders"]);
 inspectorBackend.registerEvent("Preload.preloadingAttemptSourcesUpdated", ["loaderId", "preloadingAttemptSources"]);
 inspectorBackend.registerCommand("Preload.enable", [], [], "");
 inspectorBackend.registerCommand("Preload.disable", [], [], "");

package/front_end/generated/protocol.ts

@@ -7517,6 +7517,11 @@ export namespace Emulation {
     Default = 'default',
   }
 
+  export const enum SetDeviceMetricsOverrideRequestTextLayoutMode {
+    Mobile = 'mobile',
+    Default = 'default',
+  }
+
   export interface SetDeviceMetricsOverrideRequest {
     /**
      * Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.
@@ -7599,6 +7604,11 @@ export namespace Emulation {
      * the viewport meta tag is always enabled.
      */
     viewportMeta?: SetDeviceMetricsOverrideRequestViewportMeta;
+    /**
+     * Text layout mode. Default: `default`. Note: if `mobile` is `true`,
+     * mobile text layout mode (text autosizing) is always enabled.
+     */
+    textLayoutMode?: SetDeviceMetricsOverrideRequestTextLayoutMode;
   }
 
   export interface SetDevicePostureOverrideRequest {
@@ -17557,6 +17567,12 @@ export namespace Preload {
     key: PreloadingAttemptKey;
     pipelineId: PreloadPipelineId;
     status: PreloadingStatus;
+    /**
+     * The action currently performed by this attempt. This differs from
+     * `key.action` after a prerender-until-script attempt is upgraded in place
+     * to a full prerender.
+     */
+    effectiveAction?: SpeculationAction;
     prerenderStatus?: PrerenderFinalStatus;
     /**
      * This is used to give users more information about the name of Mojo interface

package/front_end/models/formatter/FormatterWorkerPool.ts

@@ -5,7 +5,12 @@
 import * as Platform from '../../core/platform/platform.js';
 import * as FormatterActions from '../../entrypoints/formatter_actions/formatter_actions.js';
 
-export {DefinitionKind, ScopeKind, type ScopeTreeNode} from '../../entrypoints/formatter_actions/formatter_actions.js';
+export {
+  DefinitionKind,
+  ScopeKind,
+  type ScopeTreeNode,
+  type ScopeVariableMapping,
+} from '../../entrypoints/formatter_actions/formatter_actions.js';
 
 let formatterWorkerPoolInstance: FormatterWorkerPool|undefined;
 
@@ -134,8 +139,8 @@ export class FormatterWorkerPool {
     return this.runTask(FormatterActions.FormatterActions.FORMAT, parameters) as Promise<FormatterActions.FormatResult>;
   }
 
-  javaScriptSubstitute(expression: string, mapping: Array<Map<string, string|null>>): Promise<string> {
-    if (mapping.every(m => m.size === 0)) {
+  javaScriptSubstitute(expression: string, mapping: FormatterActions.ScopeVariableMapping[]): Promise<string> {
+    if (mapping.every(scope => scope.bindings.size === 0)) {
       return Promise.resolve(expression);
     }
     return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_SUBSTITUTE, {content: expression, mapping})

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -9,13 +9,25 @@ import * as Protocol from '../../generated/protocol.js';
 import type * as Bindings from '../bindings/bindings.js';
 import * as Formatter from '../formatter/formatter.js';
 
+/**
+ * The result of resolving a generated scope via the source map's mappings/names.
+ */
+interface ResolvedScope {
+  /** Generated name -> authored name, for generated names that we could map. */
+  variableMapping: Map<string, string>;
+  thisMapping: string|null;
+  /** All generated names declared by the scope, including ones that we couldn't map. */
+  generatedNames: string[];
+}
+
 interface CachedScopeMap {
   sourceMap: SDK.SourceMap.SourceMap|undefined;
-  mappingPromise: Promise<{variableMapping: Map<string, string>, thisMapping: string|null}>;
+  mappingPromise: Promise<ResolvedScope>;
 }
 
 const scopeToCachedIdentifiersMap = new WeakMap<Formatter.FormatterWorkerPool.ScopeTreeNode, CachedScopeMap>();
-const cachedMapByCallFrame = new WeakMap<SDK.DebuggerModel.CallFrame, Array<Map<string, string|null>>>();
+const cachedMapByCallFrame =
+    new WeakMap<SDK.DebuggerModel.CallFrame, Formatter.FormatterWorkerPool.ScopeVariableMapping[]>();
 
 export async function getTextFor(contentProvider: TextUtils.ContentProvider.ContentProvider):
     Promise<TextUtils.Text.Text|null> {
@@ -193,13 +205,13 @@ const enum Punctuation {
 const resolveDebuggerScope =
     async(scope: SDK.DebuggerModel.ScopeChainEntry,
           debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-        Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => {
+        Promise<ResolvedScope> => {
           if (!scope.callFrame()
                    .debuggerModel.target()
                    .targetManager()
                    .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
                    .get()) {
-            return {variableMapping: new Map(), thisMapping: null};
+            return {variableMapping: new Map(), thisMapping: null, generatedNames: []};
           }
           const script = scope.callFrame().script;
           const scopeChain = await findScopeChainForDebuggerScope(scope);
@@ -208,10 +220,10 @@ const resolveDebuggerScope =
 
 const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.FormatterWorkerPool.ScopeTreeNode[],
                            debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-    Promise<{variableMapping: Map<string, string>, thisMapping: string | null}> => {
+    Promise<ResolvedScope> => {
       const parsedScope = scopeChain[scopeChain.length - 1];
       if (!parsedScope) {
-        return {variableMapping: new Map<string, string>(), thisMapping: null};
+        return {variableMapping: new Map<string, string>(), thisMapping: null, generatedNames: []};
       }
       let cachedScopeMap = scopeToCachedIdentifiersMap.get(parsedScope);
       const sourceMap = script.sourceMap();
@@ -223,7 +235,7 @@ const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.Form
               let thisMapping = null;
 
               if (!sourceMap) {
-                return {variableMapping, thisMapping};
+                return {variableMapping, thisMapping, generatedNames: []};
               }
               // Extract as much as possible from SourceMap and resolve
               // missing identifier names from SourceMap ranges.
@@ -261,7 +273,7 @@ const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.Form
 
               const parsedVariables = await scopeIdentifiers(script, parsedScope, scopeChain.slice(0, -1));
               if (!parsedVariables) {
-                return {variableMapping, thisMapping};
+                return {variableMapping, thisMapping, generatedNames: []};
               }
               for (const id of parsedVariables.boundVariables) {
                 resolveEntry(id, sourceName => {
@@ -279,7 +291,8 @@ const resolveScope = async(script: SDK.Script.Script, scopeChain: Formatter.Form
                 });
               }
               await Promise.all(promises).then(getScopeResolvedForTest());
-              return {variableMapping, thisMapping};
+              const generatedNames = parsedVariables.boundVariables.map(id => id.name);
+              return {variableMapping, thisMapping, generatedNames};
             })();
         cachedScopeMap = {sourceMap, mappingPromise: identifiersPromise};
         scopeToCachedIdentifiersMap.set(parsedScope, {sourceMap, mappingPromise: identifiersPromise});
@@ -403,23 +416,39 @@ export const resolveScopeChain =
           return scopes.map(scope => new ScopeWithSourceMappedVariables(scope, thisObject, debuggerWorkspaceBinding));
         };
 
-function reverseScopeMapping(variableMapping: Map<string, string>): Map<string, string|null> {
-  const result = new Map<string, string|null>();
-  for (const [compiledName, originalName] of variableMapping) {
-    if (originalName && !result.has(originalName)) {
-      result.set(originalName, compiledName);
+/**
+ * Converts the generated name -> authored name mapping of a resolved scope into the
+ * authored name -> generated name form expected by `javaScriptSubstitute`.
+ */
+function toScopeVariableMapping({variableMapping, generatedNames}: ResolvedScope):
+    Formatter.FormatterWorkerPool.ScopeVariableMapping {
+  const bindings = new Map<string, string|null>();
+  for (const [generatedName, authoredName] of variableMapping) {
+    // Multiple generated names can map to the same authored name. We pick the first one. The worker still
+    // learns about the others via `generatedNames`, which it needs to detect shadowing of outer bindings.
+    if (authoredName && !bindings.has(authoredName)) {
+      bindings.set(authoredName, generatedName);
     }
   }
-  return result;
+  return {bindings, generatedNames};
+}
+
+/**
+ * Source map scopes don't tell us which generated names a generated range declares. The worker falls back
+ * to the free identifiers of the binding expressions in that case.
+ */
+function fromSourceMapScopes(mappedVariables: Array<Map<string, string|null>>):
+    Formatter.FormatterWorkerPool.ScopeVariableMapping[] {
+  return mappedVariables.map(bindings => ({bindings, generatedNames: []}));
 }
 
 /**
- * @returns An array of mappings (from inner-most to outer-most scope) of original name -> compiled name or binding expression.
+ * @returns An array of scopes (from inner-most to outer-most) with their original name -> compiled name or binding expression mappings.
  */
 export const allVariablesInCallFrame = async(
     callFrame: SDK.DebuggerModel.CallFrame,
     debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-    Promise<Array<Map<string, string|null>>> => {
+    Promise<Formatter.FormatterWorkerPool.ScopeVariableMapping[]> => {
       if (!callFrame.debuggerModel.target()
                .targetManager()
                .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
@@ -437,36 +466,37 @@ export const allVariablesInCallFrame = async(
         const mappedVariables =
             sourceMap?.resolveMappedVariablesAtPosition(callFrame.location(), callFrame.returnValue() !== null);
         if (mappedVariables) {
-          cachedMapByCallFrame.set(callFrame, mappedVariables);
-          return mappedVariables;
+          const result = fromSourceMapScopes(mappedVariables);
+          cachedMapByCallFrame.set(callFrame, result);
+          return result;
         }
       }
 
       const scopeChain = callFrame.scopeChain().filter(scope => !scope.empty());
-      const nameMappings =
+      const resolvedScopes =
           await Promise.all(scopeChain.map(scope => resolveDebuggerScope(scope, debuggerWorkspaceBinding)));
-      const reverseMapping = nameMappings.map(({variableMapping}) => reverseScopeMapping(variableMapping));
-      cachedMapByCallFrame.set(callFrame, reverseMapping);
-      return reverseMapping;
+      const result = resolvedScopes.map(toScopeVariableMapping);
+      cachedMapByCallFrame.set(callFrame, result);
+      return result;
     };
 
 /**
- * @returns An array of mappings (from inner-most to outer-most scope) of original name -> compiled name or binding expression.
+ * @returns An array of scopes (from inner-most to outer-most) with their original name -> compiled name or binding expression mappings.
  */
 export const allVariablesAtPosition =
     async(location: SDK.DebuggerModel.Location,
           debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-        Promise<Array<Map<string, string|null>>> => {
-          const reverseMapping: Array<Map<string, string|null>> = [];
+        Promise<Formatter.FormatterWorkerPool.ScopeVariableMapping[]> => {
+          const result: Formatter.FormatterWorkerPool.ScopeVariableMapping[] = [];
           const script = location.script();
           if (!script) {
-            return reverseMapping;
+            return result;
           }
           if (!script.debuggerModel.target()
                    .targetManager()
                    .settings.resolve(SDK.SDKSettings.jsSourceMapsEnabledSettingDescriptor)
                    .get()) {
-            return reverseMapping;
+            return result;
           }
 
           if (Root.Runtime.hostConfig.devToolsSourceMapScopesInSourcesPanel?.enabled) {
@@ -474,13 +504,13 @@ export const allVariablesAtPosition =
                 script.sourceMap() ?? await script.debuggerModel.sourceMapManager().sourceMapForClientPromise(script);
             const mappedVariables = sourceMap?.resolveMappedVariablesAtPosition(location);
             if (mappedVariables) {
-              return mappedVariables;
+              return fromSourceMapScopes(mappedVariables);
             }
           }
 
           const scopeTreeAndText = await computeScopeTree(script);
           if (!scopeTreeAndText) {
-            return reverseMapping;
+            return result;
           }
 
           const {scopeTree, text} = scopeTreeAndText;
@@ -489,11 +519,10 @@ export const allVariablesAtPosition =
           const scopeChain = findScopeChain(scopeTree, {start: locationOffset, end: locationOffset});
 
           while (scopeChain.length > 0) {
-            const {variableMapping} = await resolveScope(script, scopeChain, debuggerWorkspaceBinding);
-            reverseMapping.push(reverseScopeMapping(variableMapping));
+            result.push(toScopeVariableMapping(await resolveScope(script, scopeChain, debuggerWorkspaceBinding)));
             scopeChain.pop();
           }
-          return reverseMapping;
+          return result;
         };
 
 export const resolveThisObject = async(

package/front_end/models/source_map_scopes/ScopeChainModel.ts

@@ -3,10 +3,9 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
-import * as SDK from '../../core/sdk/sdk.js';
-import type * as Bindings from '../bindings/bindings.js';
+import type * as SDK from '../../core/sdk/sdk.js';
 
-import {resolveScopeChain} from './NamesResolver.js';
+import {Events as ScopeChainResolverEvents, type ScopeChainResolver} from './ScopeChainResolver.js';
 
 /**
  * This class is responsible for resolving / updating the scope chain for a specific {@link SDK.DebuggerModel.CallFrame}
@@ -18,57 +17,35 @@ import {resolveScopeChain} from './NamesResolver.js';
  *
  * Source maps can be enabled/disabled dynamically and debugger plugins can attach debug info after the fact.
  *
- * This class tracks all that and sends events with the latest scope chain for a specific call frame.
+ * The {@link ScopeChainResolver} tracks all that and invalidates its cache accordingly. This class
+ * sends events with the latest scope chain for a specific call frame.
  */
 export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
-  static readonly #cachedScopeChainByCallFrame =
-      new WeakMap<SDK.DebuggerModel.CallFrame, Promise<SDK.DebuggerModel.ScopeChainEntry[]>>();
-
   readonly #callFrame: SDK.DebuggerModel.CallFrame;
-  readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  readonly #scopeChainResolver: ScopeChainResolver;
 
   /** We use the `Throttler` here to make sure that `#boundUpdate` is not run multiple times simultanously */
   readonly #throttler = new Common.Throttler.Throttler(5);
   readonly #boundUpdate = this.#update.bind(this);
 
-  constructor(callFrame: SDK.DebuggerModel.CallFrame,
-              debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
+  constructor(callFrame: SDK.DebuggerModel.CallFrame, scopeChainResolver: ScopeChainResolver) {
     super();
     this.#callFrame = callFrame;
-    this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
-    this.#callFrame.debuggerModel.addEventListener(
-        SDK.DebuggerModel.Events.DebugInfoAttached, this.#debugInfoAttached, this);
-    this.#callFrame.debuggerModel.sourceMapManager().addEventListener(SDK.SourceMapManager.Events.SourceMapAttached,
-                                                                      this.#sourceMapChanged, this);
-    this.#callFrame.debuggerModel.sourceMapManager().addEventListener(SDK.SourceMapManager.Events.SourceMapDetached,
-                                                                      this.#sourceMapChanged, this);
+    this.#scopeChainResolver = scopeChainResolver;
+    this.#scopeChainResolver.addEventListener(ScopeChainResolverEvents.SCOPE_CHAIN_INVALIDATED,
+                                              this.#scopeChainInvalidated, this);
 
     void this.#throttler.schedule(this.#boundUpdate);
   }
 
   dispose(): void {
-    this.#callFrame.debuggerModel.removeEventListener(
-        SDK.DebuggerModel.Events.DebugInfoAttached, this.#debugInfoAttached, this);
-    this.#callFrame.debuggerModel.sourceMapManager().removeEventListener(SDK.SourceMapManager.Events.SourceMapAttached,
-                                                                         this.#sourceMapChanged, this);
-    this.#callFrame.debuggerModel.sourceMapManager().removeEventListener(SDK.SourceMapManager.Events.SourceMapDetached,
-                                                                         this.#sourceMapChanged, this);
+    this.#scopeChainResolver.removeEventListener(ScopeChainResolverEvents.SCOPE_CHAIN_INVALIDATED,
+                                                 this.#scopeChainInvalidated, this);
     this.listeners?.clear();
   }
 
-  static resolveScopeChain(callFrame: SDK.DebuggerModel.CallFrame,
-                           debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding):
-      Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
-    let cachedPromise = ScopeChainModel.#cachedScopeChainByCallFrame.get(callFrame);
-    if (!cachedPromise) {
-      cachedPromise = resolveScopeChain(callFrame, debuggerWorkspaceBinding);
-      ScopeChainModel.#cachedScopeChainByCallFrame.set(callFrame, cachedPromise);
-    }
-    return cachedPromise;
-  }
-
   resolveScopeChain(): Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
-    return ScopeChainModel.resolveScopeChain(this.#callFrame, this.#debuggerWorkspaceBinding);
+    return this.#scopeChainResolver.resolveScopeChain(this.#callFrame);
   }
 
   async #update(): Promise<void> {
@@ -76,17 +53,8 @@ export class ScopeChainModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     this.dispatchEventToListeners(Events.SCOPE_CHAIN_UPDATED, new ScopeChain(scopeChain));
   }
 
-  #debugInfoAttached(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
+  #scopeChainInvalidated(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
     if (event.data === this.#callFrame.script) {
-      ScopeChainModel.#cachedScopeChainByCallFrame.delete(this.#callFrame);
-      void this.#throttler.schedule(this.#boundUpdate);
-    }
-  }
-
-  #sourceMapChanged(event: Common.EventTarget
-                        .EventTargetEvent<{client: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap}>): void {
-    if (event.data.client === this.#callFrame.script) {
-      ScopeChainModel.#cachedScopeChainByCallFrame.delete(this.#callFrame);
       void this.#throttler.schedule(this.#boundUpdate);
     }
   }

package/front_end/models/source_map_scopes/ScopeChainResolver.ts

@@ -0,0 +1,101 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import type * as Bindings from '../bindings/bindings.js';
+
+import {resolveScopeChain} from './NamesResolver.js';
+
+/**
+ * Resolves and caches the scope chain for {@link SDK.DebuggerModel.CallFrame}s.
+ *
+ * There is one instance per `Universe`. Caching the resolved scope chain allows different consumers
+ * (e.g. the Scope view and the inline values in the editor) to share the exact same
+ * {@link SDK.DebuggerModel.ScopeChainEntry} and {@link SDK.RemoteObject.RemoteObject} instances for a
+ * given pause, without redundant CDP evaluations.
+ *
+ * The cache for a script is invalidated whenever debugging info (e.g. from a debugger language plugin)
+ * or a source map is attached to or detached from that script. The {@link Events.SCOPE_CHAIN_INVALIDATED}
+ * event is dispatched afterwards, so consumers can re-resolve the scope chain.
+ */
+export class ScopeChainResolver extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
+    SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
+  readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  readonly #cache = new WeakMap<SDK.Script.Script,
+                                WeakMap<SDK.DebuggerModel.CallFrame, Promise<SDK.DebuggerModel.ScopeChainEntry[]>>>();
+
+  constructor(targetManager: SDK.TargetManager.TargetManager,
+              debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding) {
+    super();
+    this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+    targetManager.observeModels(SDK.DebuggerModel.DebuggerModel, this);
+  }
+
+  /**
+   * @deprecated Pass the `ScopeChainResolver` of the `Universe` via constructor instead.
+   */
+  static instance(): ScopeChainResolver {
+    // TODO(crbug.com/458180550): Remove once all callers receive the instance via constructor.
+    return Root.DevToolsContext.globalInstance().get(ScopeChainResolver);
+  }
+
+  modelAdded(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
+    debuggerModel.addEventListener(SDK.DebuggerModel.Events.DebugInfoAttached, this.#debugInfoAttached, this);
+    debuggerModel.sourceMapManager().addEventListener(SDK.SourceMapManager.Events.SourceMapAttached,
+                                                      this.#sourceMapChanged, this);
+    debuggerModel.sourceMapManager().addEventListener(SDK.SourceMapManager.Events.SourceMapDetached,
+                                                      this.#sourceMapChanged, this);
+  }
+
+  modelRemoved(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
+    debuggerModel.removeEventListener(SDK.DebuggerModel.Events.DebugInfoAttached, this.#debugInfoAttached, this);
+    debuggerModel.sourceMapManager().removeEventListener(SDK.SourceMapManager.Events.SourceMapAttached,
+                                                         this.#sourceMapChanged, this);
+    debuggerModel.sourceMapManager().removeEventListener(SDK.SourceMapManager.Events.SourceMapDetached,
+                                                         this.#sourceMapChanged, this);
+  }
+
+  /**
+   * Returns the (cached) resolved scope chain for `callFrame`. Repeated calls return the same promise
+   * until the cache for the call frame's script is invalidated.
+   */
+  resolveScopeChain(callFrame: SDK.DebuggerModel.CallFrame): Promise<SDK.DebuggerModel.ScopeChainEntry[]> {
+    let cacheForScript = this.#cache.get(callFrame.script);
+    if (!cacheForScript) {
+      cacheForScript = new WeakMap();
+      this.#cache.set(callFrame.script, cacheForScript);
+    }
+    let cachedPromise = cacheForScript.get(callFrame);
+    if (!cachedPromise) {
+      cachedPromise = resolveScopeChain(callFrame, this.#debuggerWorkspaceBinding);
+      cacheForScript.set(callFrame, cachedPromise);
+    }
+    return cachedPromise;
+  }
+
+  #invalidate(script: SDK.Script.Script): void {
+    this.#cache.delete(script);
+    this.dispatchEventToListeners(Events.SCOPE_CHAIN_INVALIDATED, script);
+  }
+
+  #debugInfoAttached(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
+    this.#invalidate(event.data);
+  }
+
+  #sourceMapChanged(event: Common.EventTarget
+                        .EventTargetEvent<{client: SDK.Script.Script, sourceMap: SDK.SourceMap.SourceMap}>): void {
+    this.#invalidate(event.data.client);
+  }
+}
+
+export const enum Events {
+  SCOPE_CHAIN_INVALIDATED = 'ScopeChainInvalidated',
+}
+
+export interface EventTypes {
+  /** Dispatched with the script for which the cached scope chains have been invalidated. */
+  [Events.SCOPE_CHAIN_INVALIDATED]: SDK.Script.Script;
+}

package/front_end/models/source_map_scopes/source_map_scopes.ts

@@ -5,9 +5,11 @@
 import * as FunctionCodeResolver from './FunctionCodeResolver.js';
 import * as NamesResolver from './NamesResolver.js';
 import * as ScopeChainModel from './ScopeChainModel.js';
+import * as ScopeChainResolver from './ScopeChainResolver.js';
 
 export {
   FunctionCodeResolver,
   NamesResolver,
   ScopeChainModel,
+  ScopeChainResolver,
 };

package/front_end/panels/console/ConsolePrompt.ts

@@ -459,7 +459,8 @@ export class ConsolePrompt extends ConsolePromptBase {
         ?.evaluateCommandInConsole(executionContext, message, expression, useCommandLineAPI);
   }
 
-  private async substituteNames(expression: string, mapping: Array<Map<string, string|null>>): Promise<string> {
+  private async substituteNames(expression: string,
+                                mapping: Formatter.FormatterWorkerPool.ScopeVariableMapping[]): Promise<string> {
     try {
       return await Formatter.FormatterWorkerPool.formatterWorkerPool().javaScriptSubstitute(expression, mapping);
     } catch {

package/front_end/panels/sources/DebuggerPlugin.ts

@@ -1002,8 +1002,8 @@ export class DebuggerPlugin extends Plugin {
 
     const uiPositionToEditorOffset = (lineNumber: number, columnNumber: number): number|null =>
         this.editor?.toOffset(this.transformer.uiLocationToEditorLocation(lineNumber, columnNumber)) ?? null;
-    const scopeChain = await SourceMapScopes.ScopeChainModel.ScopeChainModel.resolveScopeChain(
-        callFrame, Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance());
+    const scopeChain =
+        await SourceMapScopes.ScopeChainResolver.ScopeChainResolver.instance().resolveScopeChain(callFrame);
     const localOriginalScope = scopeChain
                                    .find((s): s is SDK.SourceMapScopeChainEntry.SourceMapScopeChainEntry =>
                                              s instanceof SDK.SourceMapScopeChainEntry.SourceMapScopeChainEntry &&
@@ -2184,8 +2184,7 @@ export async function computeScopeMappings(
     resolvedScopeChain?: SDK.DebuggerModel.ScopeChainEntry[]): Promise<ScopeMapping[]> {
   const scopeMappings: ScopeMapping[] = [];
   const scopeChain = resolvedScopeChain ??
-      await SourceMapScopes.ScopeChainModel.ScopeChainModel.resolveScopeChain(
-          callFrame, Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance());
+      await SourceMapScopes.ScopeChainResolver.ScopeChainResolver.instance().resolveScopeChain(callFrame);
   const activeScopes =
       new Set(scopeChain.filter(s => s instanceof SDK.SourceMapScopeChainEntry.SourceMapScopeChainEntry)
                   .map(s => s.originalScope()));

package/front_end/panels/sources/ScopeChainSidebarPane.ts

@@ -31,7 +31,6 @@
 import * as i18n from '../../core/i18n/i18n.js';
 import type * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
-import * as Bindings from '../../models/bindings/bindings.js';
 import * as SourceMapScopes from '../../models/source_map_scopes/source_map_scopes.js';
 import * as StackTrace from '../../models/stack_trace/stack_trace.js';
 import * as ObjectUI from '../../ui/legacy/components/object_ui/object_ui.js';
@@ -214,8 +213,9 @@ export class ScopeChainSidebarPane extends UI.Widget.VBox implements UI.ContextF
     this.#linkifier.reset();
 
     if (callFrame) {
+      // TODO(crbug.com/458180550): Receive the ScopeChainResolver via constructor.
       const scopeChainModel = new SourceMapScopes.ScopeChainModel.ScopeChainModel(
-          callFrame.sdkFrame, Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance());
+          callFrame.sdkFrame, SourceMapScopes.ScopeChainResolver.ScopeChainResolver.instance());
       this.#scopeChainModel = scopeChainModel;
       this.#scopeChainModel.addEventListener(SourceMapScopes.ScopeChainModel.Events.SCOPE_CHAIN_UPDATED, event => {
         if (this.#scopeChainModel === scopeChainModel) {

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: Internal
 Version: N/A
-Revision: d4131488cec036cb5a8b1c69a9c252d54b540f29
+Revision: cd8ab87ab38bee0c301e4ba26302fd1c7e38377a
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/ui/legacy/README.md

@@ -73,11 +73,11 @@ UI.ActionRegistration.registerActionExtension({
   bindings: [
     {
       shortcut: 'Ctrl+E',
-      platform: UI.ActionRegistration.Platforms.WindowsLinux,
+      platform: UI.ActionRegistration.Platforms.WINDOWS_LINUX,
     },
     {
       shortcut: 'Meta+E',
-      platform: UI.ActionRegistration.Platforms.Mac,
+      platform: UI.ActionRegistration.Platforms.MAC,
     },
   ],
 });
@@ -87,7 +87,7 @@ UI.ActionRegistration.registerActionExtension({
 
 #### Context types
 The `contextTypes` property determines the context under which the action is available.
-A context is defined as set 'flavors' or classes, which usually represent views, that are added and removed to the context as the user interacts with the application (e.g when the user moves across views).
+A context is defined as set of 'flavors' or classes, which usually represent views, that are added and removed to the context as the user interacts with the application (e.g when the user moves across views).
 (See [`UI.Context`](./Context.js)).
 Therefore, an action can only be triggered when one of its respective context types is visible.
 These flavors can be retrieved invoking the method `flavors` inside the class `UI.Context.Context`.
@@ -97,10 +97,10 @@ In this case, the action will always be available, regardless of which context i
 
 #### Key bindings
 
-The `bindings` property defines a `platform` and a `keybindSets` properties along with the keyboard shortcut itself.
+The `bindings` property defines `platform` and `keybindSets` properties along with the `shortcut` property containing the actual keyboard shortcut.
 These two extra properties add more conditions (additional to the ones introduced by the `contextTypes` property discussed before) that need to be fulfilled to trigger a particular action.
 
-- `platform` refers to the OS on which DevTools is running and can be either `mac` or `windows,linux`.
+- `platform` refers to the OS on which DevTools is running and can be either `MAC`, `WINDOWS_LINUX` or `WINDOWS`. (See [`UI.ActionRegistration`](./ActionRegistration.ts)).
 - `keybindSets` refers to the selected shortcut preset, which can be changed in `settings -> shortcuts -> “Match shortcuts from preset”`.
 A key binding will be used when the selected preset matches any of the keybind sets declared by the binding.
 
@@ -125,16 +125,16 @@ UI.ActionRegistration.registerActionExtension({
   contextTypes: undefined,
   bindings: [
     {
-      platform: 'windows,linux',
+      platform: UI.ActionRegistration.Platforms.WINDOWS_LINUX,
       shortcut: 'Esc',
     },
   ],
 });
 ```
 
-These two key bindings both allocate the same key for the `windows, linux` platform (the first one is global across platforms) in the `ElementsPanel` context (the second one is global across context types) and both are global across keybind sets.
+These two key bindings both allocate the same key for the `WINDOWS_LINUX` platform (the first one is global across platforms) in the `ElementsPanel` context (the second one is global across context types) and both are global across keybind sets.
 
-If key bindings were declared such that **at least one** of the three variables (`platform, contextTypes` and `keybindSets`) doesn't overlap, then no duplication would occur.
+If key bindings were declared such that **at least one** of the three variables (`platform`, `contextTypes` and `keybindSets`) doesn't overlap, then no duplication would occur.
 For example, the following is **not** a form of duplication:
 
 ```ts
@@ -147,7 +147,7 @@ UI.ActionRegistration.registerActionExtension({
   bindings: [
     {
       shortcut: 'Esc',
-      keybindSets: ['devToolsDefault'],
+      keybindSets: [UI.ActionRegistration.KeybindSet.DEVTOOLS_DEFAULT],
     },
   ],
 });
@@ -160,12 +160,12 @@ UI.ActionRegistration.registerActionExtension({
   contextTypes: undefined,
   bindings: [
     {
-      platform: 'windows,linux',
+      platform: UI.ActionRegistration.Platforms.WINDOWS_LINUX,
       shortcut: 'Esc',
-      keybindSets: ['vsCode'],
+      keybindSets: [UI.ActionRegistration.KeybindSet.VS_CODE],
     },
   ],
 });
 ```
 
-In this case, they keybindings are declared for different keybind sets and thus do not result in duplcation.
+In this case, the keybindings are declared for different keybind sets and thus do not result in duplication.

package/package.json

@@ -91,5 +91,5 @@
     "yargs": "18.1.0",
     "yargs-unparser": "2.0.0"
   },
-  "version": "1.0.1704172"
+  "version": "1.0.1705227"
 }