chrome-devtools-frontend 1.0.1675430 → 1.0.1676824

package/front_end/models/ai_assistance/tools/SelectTraceEventByKey.ts

@@ -0,0 +1,90 @@
+// 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 Host from '../../../core/host/host.js';
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
+
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const UIStringsNotTranslate = {
+  selectingTraceEvent: 'Selecting trace event',
+} as const;
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface SelectTraceEventByKeyArgs extends ToolArgs {
+  eventKey: string;
+}
+
+export class SelectTraceEventByKeyTool implements DataTool<SelectTraceEventByKeyArgs, string, BaseToolCapability> {
+  readonly name = ToolName.SELECT_TRACE_EVENT_BY_KEY;
+  readonly description = 'Selects and reveals a specific event by its key in the Performance panel Flamechart.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof SelectTraceEventByKeyArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for selecting a trace event.',
+    nullable: false,
+    properties: {
+      eventKey: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'The key of the event to select.',
+        nullable: false,
+      },
+    },
+    required: ['eventKey'],
+  };
+
+  displayInfoFromArgs(params: SelectTraceEventByKeyArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString(UIStringsNotTranslate.selectingTraceEvent),
+      action: `selectTraceEventByKey('${params.eventKey}')`,
+    };
+  }
+
+  async handler(
+      params: SelectTraceEventByKeyArgs,
+      capabilities: BaseToolCapability,
+      ): Promise<DataHandlerResult<string>> {
+    const conversationContext = capabilities.conversationContext;
+    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+      return {error: 'Performance trace context is not available.'};
+    }
+
+    const focus = conversationContext.getItem();
+    const event = focus.lookupEvent(params.eventKey);
+    if (!event) {
+      return {error: `Could not find event with key "${params.eventKey}".`};
+    }
+
+    const revealable = new SDK.TraceObject.RevealableEvent(event);
+    try {
+      await Common.Revealer.reveal(revealable);
+    } catch {
+      // A failed reveal should not block returning the selected event context.
+    }
+
+    return {
+      result: 'Event selected',
+      widgets: [{
+        name: 'TIMELINE_EVENT_SUMMARY',
+        data: {
+          event,
+          parsedTrace: focus.parsedTrace,
+        },
+      }],
+    };
+  }
+}

package/front_end/models/ai_assistance/tools/Tool.ts

@@ -140,13 +140,18 @@ export interface PerformanceRecordingCapability {
  * Used by the agent to pass a complete context to any tool type-safely.
  */
 export type AllToolsCapabilities = BaseToolCapability&PageExecutionCapability&StyleMutationCapability&TargetCapability&
-    OriginLockCapability&LighthouseCapability&PerformanceRecordingCapability;
+    OriginLockCapability&LighthouseCapability&PerformanceRecordingCapability&ServerLoggingCapability;
 
 /**
  * Base argument type for AI Tools.
  */
 export type ToolArgs = Record<string, unknown>;
 
+// The maximum size (in bytes) of a function execution result.
+// Approximately 16k tokens at ~4 characters per token, designed to limit
+// result sizes to prevent overloading the LLM's context window.
+export const MAX_FUNCTION_RESULT_BYTE_LENGTH = 16384 * 4;
+
 export const enum ToolName {
   EXECUTE_JAVASCRIPT = 'executeJavaScript',
   GET_STYLES = 'getStyles',
@@ -156,6 +161,13 @@ export const enum ToolName {
   RESOLVE_DEVTOOLS_NODE_PATH = 'resolveDevtoolsNodePath',
   GET_ELEMENT_ACCESSIBILITY_DETAILS = 'getElementAccessibilityDetails',
   RECORD_PERFORMANCE_TRACE = 'recordPerformanceTrace',
+  LIST_PAGE_ORIGINS = 'listPageOrigins',
+  GET_TRACE_EVENT_BY_KEY = 'getTraceEventByKey',
+  SELECT_TRACE_EVENT_BY_KEY = 'selectTraceEventByKey',
+  LIST_SOURCES = 'listSources',
+  GET_SOURCE_CONTENT = 'getSourceContent',
+  GET_TRACE_MAIN_THREAD_SUMMARY = 'getTraceMainThreadSummary',
+  GET_TRACE_NETWORK_SUMMARY = 'getTraceNetworkSummary',
 }
 
 /**
@@ -180,6 +192,7 @@ export interface BaseTool<ArgsType extends ToolArgs = ToolArgs> {
       ) => {
     title?: string, thought?: string, action?: string, suggestions?: [string, ...string[]],
   };
+  readonly annotations?: ToolAnnotation[];
 }
 
 /**
@@ -242,3 +255,11 @@ export type Tool<
     ReturnType = unknown,
     CapabilitiesType extends BaseToolCapability = BaseToolCapability,
     > = DataTool<ArgsType, ReturnType, CapabilitiesType>|ContextTool<ArgsType, ReturnType, CapabilitiesType>;
+
+export interface ServerLoggingCapability {
+  setLoggingEnabled(enabled: boolean): void;
+}
+
+export const enum ToolAnnotation {
+  REDACT_FROM_HISTORY = 'redact-from-history',
+}

package/front_end/models/ai_assistance/tools/ToolRegistry.ts

@@ -6,10 +6,17 @@ import {ExecuteJavaScriptTool} from './ExecuteJavaScript.js';
 import {GetElementAccessibilityDetailsTool} from './GetElementAccessibilityDetails.js';
 import {GetLighthouseAuditsTool} from './GetLighthouseAudits.js';
 import {GetNetworkRequestDetailsTool} from './GetNetworkRequestDetails.js';
+import {GetSourceContentTool} from './GetSourceContent.js';
 import {GetStylesTool} from './GetStyles.js';
+import {GetTraceEventByKeyTool} from './GetTraceEventByKey.js';
+import {GetTraceMainThreadSummaryTool} from './GetTraceMainThreadSummary.js';
+import {GetTraceNetworkSummaryTool} from './GetTraceNetworkSummary.js';
 import {ListNetworkRequestsTool} from './ListNetworkRequests.js';
+import {ListPageOriginsTool} from './ListPageOrigins.js';
+import {ListSourcesTool} from './ListSources.js';
 import {RecordPerformanceTraceTool} from './RecordPerformanceTrace.js';
 import {ResolveDevtoolsNodePathTool} from './ResolveDevtoolsNodePath.js';
+import {SelectTraceEventByKeyTool} from './SelectTraceEventByKey.js';
 import {type AllToolsCapabilities, type Tool, type ToolArgs, ToolName} from './Tool.js';
 
 /**
@@ -29,6 +36,13 @@ export const TOOLS = {
   [ToolName.RESOLVE_DEVTOOLS_NODE_PATH]: new ResolveDevtoolsNodePathTool(),
   [ToolName.GET_ELEMENT_ACCESSIBILITY_DETAILS]: new GetElementAccessibilityDetailsTool(),
   [ToolName.RECORD_PERFORMANCE_TRACE]: new RecordPerformanceTraceTool(),
+  [ToolName.LIST_PAGE_ORIGINS]: new ListPageOriginsTool(),
+  [ToolName.GET_TRACE_EVENT_BY_KEY]: new GetTraceEventByKeyTool(),
+  [ToolName.SELECT_TRACE_EVENT_BY_KEY]: new SelectTraceEventByKeyTool(),
+  [ToolName.LIST_SOURCES]: new ListSourcesTool(),
+  [ToolName.GET_SOURCE_CONTENT]: new GetSourceContentTool(),
+  [ToolName.GET_TRACE_MAIN_THREAD_SUMMARY]: new GetTraceMainThreadSummaryTool(),
+  [ToolName.GET_TRACE_NETWORK_SUMMARY]: new GetTraceNetworkSummaryTool(),
 };
 
 /**

package/front_end/models/bindings/CSSWorkspaceBinding.ts

@@ -143,6 +143,10 @@ export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<S
     }
     return rawLocations;
   }
+
+  sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    return SASSSourceMapping.sourceMapURLsForUISourceCode(uiSourceCode);
+  }
 }
 
 export interface SourceMapping {

package/front_end/models/bindings/CompilerScriptMapping.ts

@@ -577,6 +577,10 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     return scripts;
   }
 
+  sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    return [...this.#uiSourceCodeToSourceMaps.get(uiSourceCode)].map(sourceMap => sourceMap.url());
+  }
+
   private sourceMapAttachedForTest(_sourceMap: SDK.SourceMap.SourceMap): void {
   }
 

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -463,6 +463,14 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     return [...scripts];
   }
 
+  sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.UrlString[] {
+    const urls = new Set<Platform.DevToolsPath.UrlString>();
+    for (const modelData of this.#debuggerModelToData.values()) {
+      modelData.compilerMapping.sourceMapURLsForUISourceCode(uiSourceCode).forEach(url => urls.add(url));
+    }
+    return [...urls];
+  }
+
   supportsConditionalBreakpoints(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
     const scripts = this.pluginManager.scriptsForUISourceCode(uiSourceCode);
     return scripts.every(script => script.isJavaScript());

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -3,12 +3,9 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
-import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
-import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../../core/text_utils/text_utils.js';
-import * as Protocol from '../../generated/protocol.js';
 import * as Formatter from '../formatter/formatter.js';
 import * as Workspace from '../workspace/workspace.js';
 
@@ -17,21 +14,6 @@ import {type DebuggerSourceMapping, DebuggerWorkspaceBinding} from './DebuggerWo
 import {NetworkProject} from './NetworkProject.js';
 import {metadataForURL} from './ResourceUtils.js';
 
-const UIStrings = {
-  /**
-   * @description Error text displayed in the Console panel when editing a live script fails. LiveEdit is the name of the feature for editing code that is already running.
-   * @example {warning} PH1
-   */
-  liveEditFailed: '`LiveEdit` failed: {PH1}',
-  /**
-   * @description Error text displayed in the Console panel when compiling a live-edited script fails. LiveEdit is the name of the feature for editing code that is already running.
-   * @example {connection lost} PH1
-   */
-  liveEditCompileFailed: '`LiveEdit` compile failed: {PH1}',
-} as const;
-const str_ = i18n.i18n.registerUIStrings('models/bindings/ResourceScriptMapping.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
 export class ResourceScriptMapping implements DebuggerSourceMapping {
   readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
   #workspace: Workspace.Workspace.WorkspaceImpl;
@@ -96,9 +78,6 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     if (!scriptFile) {
       return null;
     }
-    if ((scriptFile.hasDivergedFromVM() && !scriptFile.isMergingToVM()) || scriptFile.isDivergingFromVM()) {
-      return null;
-    }
     if (scriptFile.script !== script) {
       return null;
     }
@@ -205,8 +184,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
   }
 
   private addScript(script: SDK.Script.Script): void {
-    // Ignore live edit scripts here.
-    if (script.isLiveEdit() || script.isBreakpointCondition) {
+    if (script.isBreakpointCondition) {
       return;
     }
 
@@ -272,10 +250,6 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
       if (!uiSourceCode) {
         continue;
       }
-      const scriptFile = this.#uiSourceCodeToScriptFile.get(uiSourceCode);
-      if (scriptFile) {
-        scriptFile.dispose();
-      }
 
       this.#uiSourceCodeToScriptFile.delete(uiSourceCode);
       this.#scriptToUISourceCode.delete(script);
@@ -325,177 +299,17 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
   }
 }
 
-export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<ResourceScriptFile.EventTypes> {
+export class ResourceScriptFile {
   readonly #resourceScriptMapping: ResourceScriptMapping;
   readonly uiSourceCode: Workspace.UISourceCode.UISourceCode;
   readonly script: SDK.Script.Script|null;
-  #scriptSource?: string|null;
-  #isDivergingFromVM?: boolean;
-  #hasDivergedFromVM?: boolean;
-  #isMergingToVM?: boolean;
-  #updateMutex = new Common.Mutex.Mutex();
+
   constructor(
       resourceScriptMapping: ResourceScriptMapping, uiSourceCode: Workspace.UISourceCode.UISourceCode,
       script: SDK.Script.Script) {
-    super();
     this.#resourceScriptMapping = resourceScriptMapping;
     this.uiSourceCode = uiSourceCode;
     this.script = this.uiSourceCode.contentType().isScript() ? script : null;
-
-    this.uiSourceCode.addEventListener(Workspace.UISourceCode.Events.WorkingCopyChanged, this.workingCopyChanged, this);
-    this.uiSourceCode.addEventListener(
-        Workspace.UISourceCode.Events.WorkingCopyCommitted, this.workingCopyCommitted, this);
-  }
-
-  private isDiverged(): boolean {
-    if (this.uiSourceCode.isDirty()) {
-      return true;
-    }
-    if (!this.script) {
-      return false;
-    }
-    if (typeof this.#scriptSource === 'undefined' || this.#scriptSource === null) {
-      return false;
-    }
-    const workingCopy = this.uiSourceCode.workingCopy();
-    if (!workingCopy) {
-      return false;
-    }
-
-    // Match ignoring sourceURL.
-    if (!workingCopy.startsWith(this.#scriptSource.trimEnd())) {
-      return true;
-    }
-    const suffix = this.uiSourceCode.workingCopy().substr(this.#scriptSource.length);
-    return Boolean(suffix.length) && !suffix.match(SDK.Script.sourceURLRegex);
-  }
-
-  private workingCopyChanged(): void {
-    void this.update();
-  }
-
-  private workingCopyCommitted(): void {
-    // This feature flag is for turning down live edit. If it's not present, we keep the feature enabled.
-    if (Root.Runtime.hostConfig.devToolsLiveEdit?.enabled === false) {
-      return;
-    }
-
-    if (this.uiSourceCode.project().canSetFileContent()) {
-      return;
-    }
-    if (!this.script) {
-      return;
-    }
-
-    const source = this.uiSourceCode.workingCopy();
-    void this.script.editSource(source).then(({status, exceptionDetails}) => {
-      void this.scriptSourceWasSet(source, status, exceptionDetails);
-    });
-  }
-
-  async scriptSourceWasSet(
-      source: string, status: Protocol.Debugger.SetScriptSourceResponseStatus,
-      exceptionDetails?: Protocol.Runtime.ExceptionDetails): Promise<void> {
-    if (status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
-      this.#scriptSource = source;
-    }
-    await this.update();
-
-    if (status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
-      return;
-    }
-
-    if (!exceptionDetails) {
-      // TODO(crbug.com/1334484): Instead of to the console, report these errors in an "info bar" at the bottom
-      //                          of the text editor, similar to e.g. source mapping errors.
-      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
-      Common.Console.Console.instance().addMessage(
-          i18nString(UIStrings.liveEditFailed, {PH1: getErrorText(status)}), Common.Console.MessageLevel.WARNING);
-      return;
-    }
-    const messageText = i18nString(UIStrings.liveEditCompileFailed, {PH1: exceptionDetails.text});
-    this.uiSourceCode.addLineMessage(
-        Workspace.UISourceCode.Message.Level.ERROR, messageText, exceptionDetails.lineNumber,
-        exceptionDetails.columnNumber);
-
-    function getErrorText(status: Protocol.Debugger.SetScriptSourceResponseStatus): string {
-      switch (status) {
-        case Protocol.Debugger.SetScriptSourceResponseStatus.BlockedByActiveFunction:
-          return 'Functions that are on the stack (currently being executed) can’t be edited';
-        case Protocol.Debugger.SetScriptSourceResponseStatus.BlockedByActiveGenerator:
-          return 'Async functions/generators that are active can’t be edited';
-        case Protocol.Debugger.SetScriptSourceResponseStatus.BlockedByTopLevelEsModuleChange:
-          return 'The top level of JavaScript modules can’t be edited';
-        case Protocol.Debugger.SetScriptSourceResponseStatus.CompileError:
-        case Protocol.Debugger.SetScriptSourceResponseStatus.Ok:
-          throw new Error('Compile errors and Ok status must not be reported on the console');
-      }
-    }
-  }
-
-  private async update(): Promise<void> {
-    // Do not interleave "divergeFromVM" with "mergeToVM" calls.
-    const release = await this.#updateMutex.acquire();
-    const diverged = this.isDiverged();
-    if (diverged && !this.#hasDivergedFromVM) {
-      await this.divergeFromVM();
-    } else if (!diverged && this.#hasDivergedFromVM) {
-      await this.mergeToVM();
-    }
-    release();
-  }
-
-  private async divergeFromVM(): Promise<void> {
-    if (this.script) {
-      this.#isDivergingFromVM = true;
-      await this.#resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.script);
-      this.#isDivergingFromVM = undefined;
-      this.#hasDivergedFromVM = true;
-      this.dispatchEventToListeners(ResourceScriptFile.Events.DID_DIVERGE_FROM_VM);
-    }
-  }
-
-  private async mergeToVM(): Promise<void> {
-    if (this.script) {
-      this.#hasDivergedFromVM = undefined;
-      this.#isMergingToVM = true;
-      await this.#resourceScriptMapping.debuggerWorkspaceBinding.updateLocations(this.script);
-      this.#isMergingToVM = undefined;
-      this.dispatchEventToListeners(ResourceScriptFile.Events.DID_MERGE_TO_VM);
-    }
-  }
-
-  hasDivergedFromVM(): boolean {
-    return Boolean(this.#hasDivergedFromVM);
-  }
-
-  isDivergingFromVM(): boolean {
-    return Boolean(this.#isDivergingFromVM);
-  }
-
-  isMergingToVM(): boolean {
-    return Boolean(this.#isMergingToVM);
-  }
-
-  checkMapping(): void {
-    if (!this.script || typeof this.#scriptSource !== 'undefined') {
-      this.mappingCheckedForTest();
-      return;
-    }
-    void this.script.requestContentData().then(content => {
-      this.#scriptSource = TextUtils.ContentData.ContentData.textOr(content, null);
-      void this.update().then(() => this.mappingCheckedForTest());
-    });
-  }
-
-  private mappingCheckedForTest(): void {
-  }
-
-  dispose(): void {
-    this.uiSourceCode.removeEventListener(
-        Workspace.UISourceCode.Events.WorkingCopyChanged, this.workingCopyChanged, this);
-    this.uiSourceCode.removeEventListener(
-        Workspace.UISourceCode.Events.WorkingCopyCommitted, this.workingCopyCommitted, this);
   }
 
   addSourceMapURL(sourceMapURL: Platform.DevToolsPath.UrlString): void {
@@ -527,15 +341,3 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
     return sources && 'missingSymbolFiles' in sources ? sources.missingSymbolFiles : null;
   }
 }
-
-export namespace ResourceScriptFile {
-  export const enum Events {
-    DID_MERGE_TO_VM = 'DidMergeToVM',
-    DID_DIVERGE_FROM_VM = 'DidDivergeFromVM',
-  }
-
-  export interface EventTypes {
-    [Events.DID_MERGE_TO_VM]: void;
-    [Events.DID_DIVERGE_FROM_VM]: void;
-  }
-}

package/front_end/models/bindings/SASSSourceMapping.ts

@@ -140,6 +140,12 @@ export class SASSSourceMapping implements SourceMapping {
     return [];
   }
 
+  static sourceMapURLsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode):
+      Platform.DevToolsPath.UrlString[] {
+    const binding = uiSourceCodeToBinding.get(uiSourceCode);
+    return binding?.getReferringSourceMaps().map(sourceMap => sourceMap.url()) ?? [];
+  }
+
   dispose(): void {
     Common.EventTarget.removeEventListeners(this.#eventListeners);
     this.#project.dispose();

package/front_end/models/breakpoints/BreakpointManager.ts

@@ -8,7 +8,7 @@ import {assertNotNullOrUndefined} from '../../core/platform/platform.js';
 import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as TextUtils from '../../core/text_utils/text_utils.js';
-import * as Protocol from '../../generated/protocol.js';
+import type * as Protocol from '../../generated/protocol.js';
 import * as Bindings from '../bindings/bindings.js';
 import * as Formatter from '../formatter/formatter.js';
 import * as SourceMapScopes from '../source_map_scopes/source_map_scopes.js';
@@ -608,7 +608,6 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
 
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.DebuggerWasEnabled, this.#onDebuggerEnabled, this);
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.DebuggerWasDisabled, this.#onDebuggerDisabled, this);
-    debuggerModel.addEventListener(SDK.DebuggerModel.Events.ScriptSourceWasEdited, this.#onScriptWasEdited, this);
   }
 
   modelRemoved(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
@@ -622,7 +621,6 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
   #removeDebuggerModelListeners(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
     debuggerModel.removeEventListener(SDK.DebuggerModel.Events.DebuggerWasEnabled, this.#onDebuggerEnabled, this);
     debuggerModel.removeEventListener(SDK.DebuggerModel.Events.DebuggerWasDisabled, this.#onDebuggerDisabled, this);
-    debuggerModel.removeEventListener(SDK.DebuggerModel.Events.ScriptSourceWasEdited, this.#onScriptWasEdited, this);
   }
 
   #onDebuggerEnabled(event: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.DebuggerModel>): void {
@@ -639,29 +637,6 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
     model?.cleanUpAfterDebuggerIsGone();
   }
 
-  async #onScriptWasEdited(
-      event: Common.EventTarget
-          .EventTargetEvent<{script: SDK.Script.Script, status: Protocol.Debugger.SetScriptSourceResponseStatus}>):
-      Promise<void> {
-    const {source: debuggerModel, data: {script, status}} = event;
-    if (status !== Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
-      return;
-    }
-
-    // V8 throws away breakpoints on all functions in a live edited script. Here we attempt to re-set them again at the
-    // same position. This is because we don't know what was edited and how the breakpoint should move, e.g. if the file
-    // was originally changed on the filesystem (via workspace).
-    // If the live edit originated in DevTools (in CodeMirror), then the `DebuggerPlugin` will remove the breakpoint
-    // wholesale and re-apply based on the diff.
-
-    console.assert(debuggerModel instanceof SDK.DebuggerModel.DebuggerModel);
-    const model = this.#modelBreakpoints.get(debuggerModel as SDK.DebuggerModel.DebuggerModel);
-    if (model?.wasSetIn(script.scriptId)) {
-      await model.resetBreakpoint();
-      void this.#updateModel(model);
-    }
-  }
-
   modelBreakpoint(debuggerModel: SDK.DebuggerModel.DebuggerModel): ModelBreakpoint|undefined {
     return this.#modelBreakpoints.get(debuggerModel);
   }
@@ -966,11 +941,6 @@ export class ModelBreakpoint {
   #cancelCallback = false;
   #currentState: Breakpoint.State|null = null;
   #breakpointIds: Protocol.Debugger.BreakpointId[] = [];
-  /**
-   * We track all the script IDs this ModelBreakpoint was actually set in. This allows us
-   * to properly reset this ModelBreakpoint after a script was live edited.
-   */
-  #resolvedScriptIds = new Set<Protocol.Runtime.ScriptId>();
 
   constructor(
       debuggerModel: SDK.DebuggerModel.DebuggerModel, breakpoint: Breakpoint,
@@ -991,7 +961,6 @@ export class ModelBreakpoint {
 
     this.#uiLocations.clear();
     this.#liveLocations.disposeAll();
-    this.#resolvedScriptIds.clear();
   }
 
   async scheduleUpdateInDebugger(): Promise<ScheduleUpdateResult> {
@@ -1021,16 +990,6 @@ export class ModelBreakpoint {
     return result;
   }
 
-  private scriptDiverged(): boolean {
-    for (const uiSourceCode of this.#breakpoint.getUiSourceCodes()) {
-      const scriptFile = this.#debuggerWorkspaceBinding.scriptFile(uiSourceCode, this.#debuggerModel);
-      if (scriptFile?.hasDivergedFromVM()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   async #updateInDebugger(): Promise<DebuggerUpdateResult> {
     if (this.#debuggerModel.target().isDisposed()) {
       this.cleanUpAfterDebuggerIsGone();
@@ -1042,7 +1001,7 @@ export class ModelBreakpoint {
 
     // Calculate the new state.
     let newState: Breakpoint.State|null = null;
-    if (!this.#breakpoint.getIsRemoved() && this.#breakpoint.enabled() && !this.scriptDiverged()) {
+    if (!this.#breakpoint.getIsRemoved() && this.#breakpoint.enabled()) {
       let debuggerLocations: SDK.DebuggerModel.Location[] = [];
       for (const uiSourceCode of this.#breakpoint.getUiSourceCodes()) {
         const {lineNumber: uiLineNumber, columnNumber: uiColumnNumber} =
@@ -1226,7 +1185,6 @@ export class ModelBreakpoint {
   }
 
   private async addResolvedLocation(location: SDK.DebuggerModel.Location): Promise<ResolveLocationResult> {
-    this.#resolvedScriptIds.add(location.scriptId);
     const uiLocation = await this.#debuggerWorkspaceBinding.rawLocationToUILocation(location);
     if (!uiLocation) {
       return ResolveLocationResult.OK;
@@ -1249,11 +1207,6 @@ export class ModelBreakpoint {
       this.didRemoveFromDebugger();
     }
   }
-
-  /** @returns true, iff this `ModelBreakpoint` was set (at some point) in `scriptId` */
-  wasSetIn(scriptId: Protocol.Runtime.ScriptId): boolean {
-    return this.#resolvedScriptIds.has(scriptId);
-  }
 }
 
 /**

package/front_end/models/heap_snapshot/HeapSnapshotModel.ts

@@ -335,6 +335,15 @@ export interface NativeContextSizes {
   noAttributionSize: number;
 }
 
+export interface RetainedByContextSummary {
+  contextCount: number;
+  retainedByContextSize: number;
+  retainedByContextCount: number;
+  notRetainedByContextSize: number;
+  notRetainedByContextCount: number;
+  totalSize: number;
+}
+
 export const enum DOMLinkState {
   UNKNOWN = 0,
   ATTACHED = 1,
@@ -353,3 +362,21 @@ export interface ObjectInfo {
   edgeCount: number;
   retainerCount: number;
 }
+
+export interface HeapQueryOptions {
+  className?: string;
+  propertyName?: string;
+  nodeType?: string;
+  minRetainedSize?: number;
+  maxRetainedSize?: number;
+  minSelfSize?: number;
+  maxSelfSize?: number;
+  isDetached?: boolean;
+  sortBy?: 'retainedSize'|'selfSize'|'id';
+}
+
+export interface HeapEdgesQueryOptions {
+  sortBy?: 'retainedSize'|'selfSize'|'name';
+  minRetainedSize?: number;
+  excludePrimitives?: boolean;
+}

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -280,6 +280,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('getNativeContextSizes');
   }
 
+  getRetainedByContextSummary(): Promise<HeapSnapshotModel.RetainedByContextSummary> {
+    return this.callMethodPromise('getRetainedByContextSummary');
+  }
+
   aggregatesWithFilter(filter: HeapSnapshotModel.NodeFilter):
       Promise<Record<string, HeapSnapshotModel.AggregatedInfo>> {
     return this.callMethodPromise('aggregatesWithFilter', filter);
@@ -312,8 +316,8 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('getObjectInfo', nodeIndex);
   }
 
-  createEdgesProvider(nodeIndex: number): HeapSnapshotProviderProxy {
-    return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
+  createEdgesProvider(nodeIndex: number, options?: HeapSnapshotModel.HeapEdgesQueryOptions): HeapSnapshotProviderProxy {
+    return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex, options);
   }
 
   createRetainingEdgesProvider(nodeIndex: number): HeapSnapshotProviderProxy {
@@ -336,6 +340,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callFactoryMethod('createNodesProviderForClass', HeapSnapshotProviderProxy, classKey, nodeFilter);
   }
 
+  queryObjects(queryOptions: HeapSnapshotModel.HeapQueryOptions): HeapSnapshotProviderProxy {
+    return this.callFactoryMethod('queryObjects', HeapSnapshotProviderProxy, queryOptions);
+  }
+
   allocationTracesTops(): Promise<HeapSnapshotModel.SerializedAllocationNode[]> {
     return this.callMethodPromise('allocationTracesTops');
   }