chrome-devtools-mcp 0.10.1 → 0.11.0

package/build/node_modules/chrome-devtools-frontend/front_end/models/source_map_scopes/FunctionCodeResolver.js

@@ -0,0 +1,192 @@
+// Copyright 2025 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 SDK from '../../core/sdk/sdk.js';
+import * as Bindings from '../bindings/bindings.js';
+import * as Formatter from '../formatter/formatter.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+const inputCache = new WeakMap();
+async function prepareInput(uiSourceCode, content) {
+    const formattedContent = await format(uiSourceCode, content);
+    const text = new TextUtils.Text.Text(formattedContent ? formattedContent.formattedContent : content);
+    let performanceData = uiSourceCode.getDecorationData("performance" /* Workspace.UISourceCode.DecoratorType.PERFORMANCE */);
+    // Map profile data to the formatted view of the text.
+    if (formattedContent && performanceData) {
+        performanceData = Workspace.UISourceCode.createMappedProfileData(performanceData, (line, column) => {
+            return formattedContent.formattedMapping.originalToFormatted(line, column);
+        });
+    }
+    return { text, formattedContent, performanceData };
+}
+/** Formatting and parsing line endings for Text is expensive, so cache it. */
+async function prepareInputAndCache(uiSourceCode, content) {
+    let cachedPromise = inputCache.get(uiSourceCode);
+    if (cachedPromise) {
+        return await cachedPromise;
+    }
+    cachedPromise = prepareInput(uiSourceCode, content);
+    inputCache.set(uiSourceCode, cachedPromise);
+    return await cachedPromise;
+}
+function extractPerformanceDataByLine(textRange, performanceData) {
+    const { startLine, startColumn, endLine, endColumn } = textRange;
+    const byLine = new Array(endLine - startLine + 1).fill(0);
+    for (let line = startLine; line <= endLine; line++) {
+        const lineData = performanceData.get(line + 1);
+        if (!lineData) {
+            continue;
+        }
+        // Fast-path for when the entire line's data is relevant.
+        if (line !== startLine && line !== endLine) {
+            byLine[line - startLine] = lineData.values().reduce((acc, cur) => acc + cur);
+            continue;
+        }
+        const column0 = line === startLine ? startColumn + 1 : 0;
+        const column1 = line === endLine ? endColumn + 1 : Number.POSITIVE_INFINITY;
+        let totalData = 0;
+        for (const [column, data] of lineData) {
+            if (column >= column0 && column <= column1) {
+                totalData += data;
+            }
+        }
+        byLine[line - startLine] = totalData;
+    }
+    return byLine.map(data => Math.round(data * 10) / 10);
+}
+function createFunctionCode(inputData, functionBounds, options) {
+    let { startLine, startColumn, endLine, endColumn } = functionBounds.range;
+    if (inputData.formattedContent) {
+        const startMapped = inputData.formattedContent.formattedMapping.originalToFormatted(startLine, startColumn);
+        startLine = startMapped[0];
+        startColumn = startMapped[1];
+        const endMapped = inputData.formattedContent.formattedMapping.originalToFormatted(endLine, endColumn);
+        endLine = endMapped[0];
+        endColumn = endMapped[1];
+    }
+    const text = inputData.text;
+    const content = text.value();
+    // Define two ranges - the first is just the function bounds, the second includes
+    // that plus some surrounding context as dictated by the options.
+    const range = new TextUtils.TextRange.TextRange(startLine, startColumn, endLine, endColumn);
+    const functionStartOffset = text.offsetFromPosition(startLine, startColumn);
+    const functionEndOffset = text.offsetFromPosition(endLine, endColumn);
+    let contextStartOffset = 0;
+    if (options?.contextLength !== undefined) {
+        const contextLength = options.contextLength;
+        contextStartOffset = Math.max(contextStartOffset, functionStartOffset - contextLength);
+    }
+    if (options?.contextLineLength !== undefined) {
+        const contextLineLength = options.contextLineLength;
+        const position = text.offsetFromPosition(Math.max(startLine - contextLineLength, 0), 0);
+        contextStartOffset = Math.max(contextStartOffset, position);
+    }
+    let contextEndOffset = content.length;
+    if (options?.contextLength !== undefined) {
+        const contextLength = options.contextLength;
+        contextEndOffset = Math.min(contextEndOffset, functionEndOffset + contextLength);
+    }
+    if (options?.contextLineLength !== undefined) {
+        const contextLineLength = options.contextLineLength;
+        const position = text.offsetFromPosition(Math.min(endLine + contextLineLength, text.lineCount() - 1), Number.POSITIVE_INFINITY);
+        contextEndOffset = Math.min(contextEndOffset, position);
+    }
+    const contextStart = text.positionFromOffset(contextStartOffset);
+    const contextEnd = text.positionFromOffset(contextEndOffset);
+    const rangeWithContext = new TextUtils.TextRange.TextRange(contextStart.lineNumber, contextStart.columnNumber, contextEnd.lineNumber, contextEnd.columnNumber);
+    // Grab substrings for the function range, and for the context range.
+    const code = content.substring(functionStartOffset, functionEndOffset);
+    const before = content.substring(contextStartOffset, functionStartOffset);
+    const after = content.substring(functionEndOffset, contextEndOffset);
+    let codeWithContext;
+    if (options?.appendProfileData && inputData.performanceData) {
+        const performanceDataByLine = extractPerformanceDataByLine(range, inputData.performanceData);
+        const lines = performanceDataByLine.map((data, i) => {
+            let line = text.lineAt(startLine + i);
+            const isLastLine = i === performanceDataByLine.length - 1;
+            if (i === 0) {
+                if (isLastLine) {
+                    line = line.substring(startColumn, endColumn);
+                }
+                else {
+                    line = line.substring(startColumn);
+                }
+            }
+            else if (isLastLine) {
+                line = line.substring(0, endColumn);
+            }
+            if (isLastLine) {
+                // Don't ever annotate the last line - it could make the rest of the code on
+                // that line get commented out.
+                data = 0;
+            }
+            return data ? `${line} // ${data} ms` : line;
+        });
+        const annotatedCode = lines.join('\n');
+        codeWithContext = before + `<FUNCTION_START>${annotatedCode}<FUNCTION_END>` + after;
+    }
+    else {
+        codeWithContext = before + `<FUNCTION_START>${code}<FUNCTION_END>` + after;
+    }
+    return {
+        functionBounds,
+        text,
+        code,
+        range,
+        codeWithContext,
+        rangeWithContext,
+    };
+}
+/**
+ * The input location may be a source mapped location or a raw location.
+ */
+export async function getFunctionCodeFromLocation(target, url, line, column, options) {
+    const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
+    if (!debuggerModel) {
+        throw new Error('missing debugger model');
+    }
+    let uiSourceCode;
+    const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
+    const projects = debuggerWorkspaceBinding.workspace.projectsForType(Workspace.Workspace.projectTypes.Network);
+    for (const project of projects) {
+        uiSourceCode = project.uiSourceCodeForURL(url);
+        if (uiSourceCode) {
+            break;
+        }
+    }
+    if (!uiSourceCode) {
+        return null;
+    }
+    const rawLocations = await debuggerWorkspaceBinding.uiLocationToRawLocations(uiSourceCode, line, column);
+    const rawLocation = rawLocations.at(-1);
+    if (!rawLocation) {
+        return null;
+    }
+    return await getFunctionCodeFromRawLocation(rawLocation, options);
+}
+async function format(uiSourceCode, content) {
+    const contentType = uiSourceCode.contentType();
+    const shouldFormat = !contentType.isFromSourceMap() && (contentType.isDocument() || contentType.isScript()) &&
+        TextUtils.TextUtils.isMinified(content);
+    if (!shouldFormat) {
+        return null;
+    }
+    return await Formatter.ScriptFormatter.formatScriptContent(contentType.canonicalMimeType(), content, '\t');
+}
+/**
+ * Returns a {@link FunctionCode} for the given raw location.
+ */
+export async function getFunctionCodeFromRawLocation(rawLocation, options) {
+    const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
+    const functionBounds = await debuggerWorkspaceBinding.functionBoundsAtRawLocation(rawLocation);
+    if (!functionBounds) {
+        return null;
+    }
+    await functionBounds.uiSourceCode.requestContentData();
+    const content = functionBounds.uiSourceCode.content();
+    if (!content) {
+        return null;
+    }
+    const inputData = await prepareInputAndCache(functionBounds.uiSourceCode, content);
+    return createFunctionCode(inputData, functionBounds, options);
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/source_map_scopes/source_map_scopes.js

@@ -1,6 +1,7 @@
 // Copyright 2022 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 FunctionCodeResolver from './FunctionCodeResolver.js';
 import * as NamesResolver from './NamesResolver.js';
 import * as ScopeChainModel from './ScopeChainModel.js';
-export { NamesResolver, ScopeChainModel, };
+export { FunctionCodeResolver, NamesResolver, ScopeChainModel, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/Processor.js

@@ -351,9 +351,12 @@ export class TraceProcessor extends EventTarget {
     }
     #computeInsightSet(data, context) {
         const logger = context.options.logger;
+        if (!this.#insights) {
+            this.#insights = new Map();
+        }
         let id, urlString, navigation;
         if (context.navigation) {
-            id = context.navigationId;
+            id = `NAVIGATION_${this.#insights.size}`;
             urlString = data.Meta.finalDisplayUrlByNavigationId.get(context.navigationId) ?? data.Meta.mainFrameURL;
             navigation = context.navigation;
         }
@@ -421,9 +424,6 @@ export class TraceProcessor extends EventTarget {
             bounds: context.bounds,
             model: insightSetModel,
         };
-        if (!this.#insights) {
-            this.#insights = new Map();
-        }
         this.#insights.set(insightSet.id, insightSet);
         this.sortInsightSet(insightSet, context.options.metadata ?? null);
     }

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/Styles.js

@@ -428,7 +428,7 @@ const UIStrings = {
     /**
      * @description Event category in the Performance panel for time spent to perform Garbage Collection for C++: https://chromium.googlesource.com/v8/v8/+/main/include/cppgc/README.md
      */
-    cppGc: 'CPP GC',
+    cppGc: 'C++ GC',
     /**
      * @description Event category in the Performance panel for time spent to perform encryption
      */

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/SamplesHandler.js

@@ -17,23 +17,66 @@ let entryToNode = new Map();
 // are matched by profile id, which we then finish processing to export
 // events matched by thread id.
 let preprocessedData = new Map();
+/**
+ * Profile source selection priority when multiple profiles exist for the same thread.
+ *
+ * Profile sources and their typical scenarios:
+ * - 'Internal': Browser-initiated profiling performance panel traces.
+ *   This is the profiling mechanism when users click "Record" in the Devtools UI.
+ * - 'Inspector': User-initiated via console.profile()/profileEnd() calls.
+ *   Represents explicit developer intent to profile specific code.
+ * - 'SelfProfiling': Page-initiated via JS Self-Profiling API.
+ *    Lower signal vs the two above; treated as fallback.
+ *
+ * Selection strategy:
+ * - CPU Profile mode: Prefer 'Inspector' (explicit user request).
+ * - Performance trace: Prefer 'Internal' (integrated timeline context), then 'Inspector'.
+ * - Sources not in the priority list (including 'SelfProfiling') act as fallbacks.
+ *   When no priority source matches, the first candidate profile is selected.
+ */
+const PROFILE_SOURCES_BY_PRIORITY = {
+    cpuProfile: ['Inspector'],
+    performanceTrace: ['Internal', 'Inspector'],
+};
 function parseCPUProfileData(parseOptions) {
+    const priorityList = parseOptions.isCPUProfile ? PROFILE_SOURCES_BY_PRIORITY.cpuProfile : PROFILE_SOURCES_BY_PRIORITY.performanceTrace;
     for (const [processId, profiles] of preprocessedData) {
+        const profilesByThread = new Map();
         for (const [profileId, preProcessedData] of profiles) {
             const threadId = preProcessedData.threadId;
-            if (!preProcessedData.rawProfile.nodes.length || threadId === undefined) {
+            if (threadId === undefined) {
+                continue;
+            }
+            const listForThread = Platform.MapUtilities.getWithDefault(profilesByThread, threadId, () => []);
+            listForThread.push({ id: profileId, data: preProcessedData });
+        }
+        for (const [threadId, candidates] of profilesByThread) {
+            if (!candidates.length) {
+                continue;
+            }
+            let chosen = candidates[0];
+            for (const source of priorityList) {
+                const match = candidates.find(p => p.data.source === source);
+                if (match) {
+                    chosen = match;
+                    break;
+                }
+            }
+            const chosenData = chosen.data;
+            if (!chosenData.rawProfile.nodes.length) {
                 continue;
             }
             const indexStack = [];
-            const profileModel = new CPUProfile.CPUProfileDataModel.CPUProfileDataModel(preProcessedData.rawProfile);
+            const profileModel = new CPUProfile.CPUProfileDataModel.CPUProfileDataModel(chosenData.rawProfile);
             const profileTree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
             profileTree.maxDepth = profileModel.maxDepth;
+            const selectedProfileId = chosen.id;
             const finalizedData = {
-                rawProfile: preProcessedData.rawProfile,
+                rawProfile: chosenData.rawProfile,
                 parsedProfile: profileModel,
                 profileCalls: [],
                 profileTree,
-                profileId,
+                profileId: selectedProfileId,
             };
             const dataByThread = Platform.MapUtilities.getWithDefault(profilesInProcess, processId, () => new Map());
             dataByThread.set(threadId, finalizedData);
@@ -49,7 +92,7 @@ function parseCPUProfileData(parseOptions) {
                     }
                     const ts = Helpers.Timing.milliToMicro(Types.Timing.Milli(timeStampMilliseconds));
                     const nodeId = node.id;
-                    const profileCall = Helpers.Trace.makeProfileCall(node, profileId, sampleIndex, ts, processId, threadId);
+                    const profileCall = Helpers.Trace.makeProfileCall(node, selectedProfileId, sampleIndex, ts, processId, threadId);
                     finalizedData.profileCalls.push(profileCall);
                     indexStack.push(finalizedData.profileCalls.length - 1);
                     const traceEntryNode = Helpers.TreeHelpers.makeEmptyTraceEntryNode(profileCall, nodeId);
@@ -68,7 +111,7 @@ function parseCPUProfileData(parseOptions) {
                     }
                     const { callFrame, ts, pid, tid } = profileCall;
                     const traceEntryNode = entryToNode.get(profileCall);
-                    if (callFrame === undefined || ts === undefined || pid === undefined || profileId === undefined ||
+                    if (callFrame === undefined || ts === undefined || pid === undefined || selectedProfileId === undefined ||
                         tid === undefined || traceEntryNode === undefined) {
                         return;
                     }
@@ -119,6 +162,7 @@ export function handleEvent(event) {
         const profileData = getOrCreatePreProcessedData(event.pid, event.id);
         profileData.rawProfile.startTime = event.ts;
         profileData.threadId = event.tid;
+        assignProfileSourceIfKnown(profileData, event.args?.data?.source);
         return;
     }
     if (Types.Events.isProfileChunk(event)) {
@@ -146,9 +190,11 @@ export function handleEvent(event) {
         }
         const timeDeltas = event.args.data?.timeDeltas || [];
         const lines = event.args.data?.lines || Array(samples.length).fill(0);
+        const columns = event.args.data?.columns || Array(samples.length).fill(0);
         cdpProfile.samples?.push(...samples);
         cdpProfile.timeDeltas?.push(...timeDeltas);
         cdpProfile.lines?.push(...lines);
+        cdpProfile.columns?.push(...columns);
         if (traceIds) {
             cdpProfile.traceIds ??= {};
             for (const key in traceIds) {
@@ -163,12 +209,18 @@ export function handleEvent(event) {
             const timeDeltas = cdpProfile.timeDeltas;
             cdpProfile.endTime = timeDeltas.reduce((x, y) => x + y, cdpProfile.startTime);
         }
+        assignProfileSourceIfKnown(profileData, event.args?.data?.source);
         return;
     }
 }
 export async function finalize(parseOptions = {}) {
     parseCPUProfileData(parseOptions);
 }
+function assignProfileSourceIfKnown(profileData, source) {
+    if (Types.Events.VALID_PROFILE_SOURCES.includes(source)) {
+        profileData.source = source;
+    }
+}
 export function data() {
     return {
         profilesInProcess,
@@ -185,6 +237,7 @@ function getOrCreatePreProcessedData(processId, profileId) {
             samples: [],
             timeDeltas: [],
             lines: [],
+            columns: [],
         },
         profileId,
     }));

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/handlers/ScriptsHandler.js

@@ -7,11 +7,13 @@ import * as Types from '../types/types.js';
 import { data as metaHandlerData } from './MetaHandler.js';
 import { data as networkRequestsHandlerData } from './NetworkRequestsHandler.js';
 let scriptById = new Map();
+let frameIdByIsolate = new Map();
 export function deps() {
     return ['Meta', 'NetworkRequests'];
 }
 export function reset() {
     scriptById = new Map();
+    frameIdByIsolate = new Map();
 }
 export function handleEvent(event) {
     const getOrMakeScript = (isolate, scriptIdAsNumber) => {
@@ -29,6 +31,9 @@ export function handleEvent(event) {
     if (Types.Events.isRundownScript(event)) {
         const { isolate, scriptId, url, sourceUrl, sourceMapUrl, sourceMapUrlElided } = event.args.data;
         const script = getOrMakeScript(isolate, scriptId);
+        if (!script.frame) {
+            script.frame = frameIdByIsolate.get(String(isolate)) ?? '';
+        }
         script.url = url;
         script.ts = event.ts;
         if (sourceUrl) {
@@ -59,6 +64,25 @@ export function handleEvent(event) {
         script.content = (script.content ?? '') + sourceText;
         return;
     }
+    // Setup frameIdByIsolate, which is used only in the case that we are missing
+    // rundown events for a script. We won't get a frame association from the rundown
+    // events if the recording started only after the script was first compiled. In
+    // that scenario, derive the frame via the isolate / FunctionCall events.
+    // TODO: ideally, we put the frame on ScriptCatchup event. So much easier. This approach has some
+    // issues.
+    if (Types.Events.isFunctionCall(event) && event.args.data?.isolate && event.args.data.frame) {
+        const { isolate, frame } = event.args.data;
+        const existingValue = frameIdByIsolate.get(isolate);
+        if (existingValue !== frame) {
+            frameIdByIsolate.set(isolate, frame);
+            // Update the scripts we discovered but without knowing their frame.
+            for (const script of scriptById.values()) {
+                if (!script.frame && script.isolate === isolate) {
+                    script.frame = frame;
+                }
+            }
+        }
+    }
 }
 function findFrame(meta, frameId) {
     for (const frames of meta.frameByProcessId?.values()) {

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/helpers/Trace.js

@@ -502,6 +502,16 @@ export function getStackTraceTopCallFrameInEventPayload(event) {
         }
     }
 }
+export function rawCallFrameForEntry(entry) {
+    if (Types.Events.isProfileCall(entry)) {
+        return entry.callFrame;
+    }
+    const topCallFrame = getStackTraceTopCallFrameInEventPayload(entry);
+    if (topCallFrame) {
+        return topCallFrame;
+    }
+    return null;
+}
 /**
  * Given a 1-based call frame creates a 0-based one.
  */

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/types/TraceEvents.js

@@ -19,6 +19,7 @@ export function objectIsCallFrame(object) {
         ('lineNumber' in object && typeof object.lineNumber === 'number') &&
         ('url' in object && typeof object.url === 'string');
 }
+export const VALID_PROFILE_SOURCES = ['Inspector', 'SelfProfiling', 'Internal'];
 export function isRunTask(event) {
     return event.name === "RunTask" /* Name.RUN_TASK */ && event.ph === "X" /* Phase.COMPLETE */;
 }

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace_source_maps_resolver/SourceMapsResolver.js

@@ -81,6 +81,29 @@ export class SourceMapsResolver extends EventTarget {
         }
         return null;
     }
+    static codeLocationForEntry(parsedTrace, entry) {
+        const uiLocation = _a.resolvedCodeLocationForEntry(entry)?.devtoolsLocation;
+        if (uiLocation) {
+            return { url: uiLocation.uiSourceCode.url(), line: uiLocation.lineNumber, column: uiLocation.columnNumber };
+        }
+        // If no source mapping was found for an entry's URL, then default
+        // to the frame contained in the event itself, if any.
+        const rawCallFrame = Trace.Helpers.Trace.rawCallFrameForEntry(entry);
+        if (rawCallFrame) {
+            const line = rawCallFrame.lineNumber >= 0 ? rawCallFrame.lineNumber : undefined;
+            const column = rawCallFrame.columnNumber >= 0 ? rawCallFrame.columnNumber : undefined;
+            return { url: rawCallFrame.url, line, column };
+        }
+        // Lastly, look for just a url.
+        let url = Trace.Handlers.Helpers.getNonResolvedURL(entry, parsedTrace.data);
+        if (url) {
+            url = Workspace.Workspace.WorkspaceImpl.instance().uiSourceCodeForURL(url)?.url() ?? url;
+        }
+        if (url) {
+            return { url };
+        }
+        return null;
+    }
     static storeResolvedCodeDataForCallFrame(callFrame, resolvedCodeLocationData) {
         const keyForCallFrame = this.keyForCodeLocation(callFrame);
         resolvedCodeLocationDataNames.set(keyForCallFrame, resolvedCodeLocationData);

package/build/node_modules/chrome-devtools-frontend/front_end/models/workspace/IgnoreListManager.js

@@ -4,6 +4,7 @@
 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 { projectTypes } from './WorkspaceImpl.js';
 const UIStrings = {
@@ -34,45 +35,38 @@ const UIStrings = {
 };
 const str_ = i18n.i18n.registerUIStrings('models/workspace/IgnoreListManager.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-let ignoreListManagerInstance;
 export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
-    #listeners;
-    #isIgnoreListedURLCache;
-    #contentScriptExecutionContexts;
-    constructor() {
+    #settings;
+    #targetManager;
+    #listeners = new Set();
+    #isIgnoreListedURLCache = new Map();
+    #contentScriptExecutionContexts = new Set();
+    constructor(settings, targetManager) {
         super();
-        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.GlobalObjectCleared, this.clearCacheIfNeeded.bind(this), this);
-        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextCreated, this.onExecutionContextCreated, this, { scoped: true });
-        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextDestroyed, this.onExecutionContextDestroyed, this, { scoped: true });
-        Common.Settings.Settings.instance()
-            .moduleSetting('skip-stack-frames-pattern')
+        this.#settings = settings;
+        this.#targetManager = targetManager;
+        this.#targetManager.addModelListener(SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.GlobalObjectCleared, this.clearCacheIfNeeded.bind(this), this);
+        this.#targetManager.addModelListener(SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextCreated, this.onExecutionContextCreated, this, { scoped: true });
+        this.#targetManager.addModelListener(SDK.RuntimeModel.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextDestroyed, this.onExecutionContextDestroyed, this, { scoped: true });
+        this.#settings.moduleSetting('skip-stack-frames-pattern').addChangeListener(this.patternChanged.bind(this));
+        this.#settings.moduleSetting('skip-content-scripts').addChangeListener(this.patternChanged.bind(this));
+        this.#settings.moduleSetting('automatically-ignore-list-known-third-party-scripts')
             .addChangeListener(this.patternChanged.bind(this));
-        Common.Settings.Settings.instance()
-            .moduleSetting('skip-content-scripts')
-            .addChangeListener(this.patternChanged.bind(this));
-        Common.Settings.Settings.instance()
-            .moduleSetting('automatically-ignore-list-known-third-party-scripts')
-            .addChangeListener(this.patternChanged.bind(this));
-        Common.Settings.Settings.instance()
-            .moduleSetting('enable-ignore-listing')
-            .addChangeListener(this.patternChanged.bind(this));
-        Common.Settings.Settings.instance()
-            .moduleSetting('skip-anonymous-scripts')
-            .addChangeListener(this.patternChanged.bind(this));
-        this.#listeners = new Set();
-        this.#isIgnoreListedURLCache = new Map();
-        this.#contentScriptExecutionContexts = new Set();
-        SDK.TargetManager.TargetManager.instance().observeModels(SDK.DebuggerModel.DebuggerModel, this);
+        this.#settings.moduleSetting('enable-ignore-listing').addChangeListener(this.patternChanged.bind(this));
+        this.#settings.moduleSetting('skip-anonymous-scripts').addChangeListener(this.patternChanged.bind(this));
+        this.#targetManager.observeModels(SDK.DebuggerModel.DebuggerModel, this);
     }
-    static instance(opts = { forceNew: null }) {
+    static instance(opts = {
+        forceNew: null,
+    }) {
         const { forceNew } = opts;
-        if (!ignoreListManagerInstance || forceNew) {
-            ignoreListManagerInstance = new IgnoreListManager();
+        if (forceNew) {
+            Root.DevToolsContext.globalInstance().set(IgnoreListManager, new IgnoreListManager(opts.settings ?? Common.Settings.Settings.instance(), opts.targetManager ?? SDK.TargetManager.TargetManager.instance()));
         }
-        return ignoreListManagerInstance;
+        return Root.DevToolsContext.globalInstance().get(IgnoreListManager);
     }
     static removeInstance() {
-        ignoreListManagerInstance = undefined;
+        Root.DevToolsContext.globalInstance().delete(IgnoreListManager);
     }
     addChangeListener(listener) {
         this.#listeners.add(listener);
@@ -99,7 +93,7 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
         if (this.isContentScript(event.data)) {
             this.#contentScriptExecutionContexts.add(event.data.uniqueId);
             if (this.skipContentScripts) {
-                for (const debuggerModel of SDK.TargetManager.TargetManager.instance().models(SDK.DebuggerModel.DebuggerModel)) {
+                for (const debuggerModel of this.#targetManager.models(SDK.DebuggerModel.DebuggerModel)) {
                     void this.updateIgnoredExecutionContexts(debuggerModel);
                 }
             }
@@ -109,7 +103,7 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
         if (this.isContentScript(event.data)) {
             this.#contentScriptExecutionContexts.delete(event.data.uniqueId);
             if (this.skipContentScripts) {
-                for (const debuggerModel of SDK.TargetManager.TargetManager.instance().models(SDK.DebuggerModel.DebuggerModel)) {
+                for (const debuggerModel of this.#targetManager.models(SDK.DebuggerModel.DebuggerModel)) {
                     void this.updateIgnoredExecutionContexts(debuggerModel);
                 }
             }
@@ -121,7 +115,7 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
         }
     }
     getSkipStackFramesPatternSetting() {
-        return Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern');
+        return this.#settings.moduleSetting('skip-stack-frames-pattern');
     }
     setIgnoreListPatterns(debuggerModel) {
         const regexPatterns = this.enableIgnoreListing ? this.getSkipStackFramesPatternSetting().getAsArray() : [];
@@ -201,7 +195,7 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
     }
     async updateScriptRanges(script, sourceMap) {
         let hasIgnoreListedMappings = false;
-        if (!IgnoreListManager.instance().isUserIgnoreListedURL(script.sourceURL, { isContentScript: script.isContentScript() })) {
+        if (!this.isUserIgnoreListedURL(script.sourceURL, { isContentScript: script.isContentScript() })) {
             hasIgnoreListedMappings =
                 sourceMap?.sourceURLs().some(url => this.isUserIgnoreListedURL(url, { isKnownThirdParty: sourceMap.hasIgnoreListHint(url) })) ??
                     false;
@@ -253,48 +247,47 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
         this.unIgnoreListURL(this.uiSourceCodeURL(uiSourceCode), this.getGeneralRulesForUISourceCode(uiSourceCode));
     }
     get enableIgnoreListing() {
-        return Common.Settings.Settings.instance().moduleSetting('enable-ignore-listing').get();
+        return this.#settings.moduleSetting('enable-ignore-listing').get();
     }
     set enableIgnoreListing(value) {
-        Common.Settings.Settings.instance().moduleSetting('enable-ignore-listing').set(value);
+        this.#settings.moduleSetting('enable-ignore-listing').set(value);
     }
     get skipContentScripts() {
-        return this.enableIgnoreListing && Common.Settings.Settings.instance().moduleSetting('skip-content-scripts').get();
+        return this.enableIgnoreListing && this.#settings.moduleSetting('skip-content-scripts').get();
     }
     get skipAnonymousScripts() {
-        return this.enableIgnoreListing &&
-            Common.Settings.Settings.instance().moduleSetting('skip-anonymous-scripts').get();
+        return this.enableIgnoreListing && this.#settings.moduleSetting('skip-anonymous-scripts').get();
     }
     get automaticallyIgnoreListKnownThirdPartyScripts() {
         return this.enableIgnoreListing &&
-            Common.Settings.Settings.instance().moduleSetting('automatically-ignore-list-known-third-party-scripts').get();
+            this.#settings.moduleSetting('automatically-ignore-list-known-third-party-scripts').get();
     }
     ignoreListContentScripts() {
         if (!this.enableIgnoreListing) {
             this.enableIgnoreListing = true;
         }
-        Common.Settings.Settings.instance().moduleSetting('skip-content-scripts').set(true);
+        this.#settings.moduleSetting('skip-content-scripts').set(true);
     }
     unIgnoreListContentScripts() {
-        Common.Settings.Settings.instance().moduleSetting('skip-content-scripts').set(false);
+        this.#settings.moduleSetting('skip-content-scripts').set(false);
     }
     ignoreListAnonymousScripts() {
         if (!this.enableIgnoreListing) {
             this.enableIgnoreListing = true;
         }
-        Common.Settings.Settings.instance().moduleSetting('skip-anonymous-scripts').set(true);
+        this.#settings.moduleSetting('skip-anonymous-scripts').set(true);
     }
     unIgnoreListAnonymousScripts() {
-        Common.Settings.Settings.instance().moduleSetting('skip-anonymous-scripts').set(false);
+        this.#settings.moduleSetting('skip-anonymous-scripts').set(false);
     }
     ignoreListThirdParty() {
         if (!this.enableIgnoreListing) {
             this.enableIgnoreListing = true;
         }
-        Common.Settings.Settings.instance().moduleSetting('automatically-ignore-list-known-third-party-scripts').set(true);
+        this.#settings.moduleSetting('automatically-ignore-list-known-third-party-scripts').set(true);
     }
     unIgnoreListThirdParty() {
-        Common.Settings.Settings.instance().moduleSetting('automatically-ignore-list-known-third-party-scripts').set(false);
+        this.#settings.moduleSetting('automatically-ignore-list-known-third-party-scripts').set(false);
     }
     ignoreListURL(url) {
         const regexValue = this.urlToRegExpString(url);
@@ -372,7 +365,7 @@ export class IgnoreListManager extends Common.ObjectWrapper.ObjectWrapper {
     async patternChanged() {
         this.#isIgnoreListedURLCache.clear();
         const promises = [];
-        for (const debuggerModel of SDK.TargetManager.TargetManager.instance().models(SDK.DebuggerModel.DebuggerModel)) {
+        for (const debuggerModel of this.#targetManager.models(SDK.DebuggerModel.DebuggerModel)) {
             promises.push(this.setIgnoreListPatterns(debuggerModel));
             const sourceMapManager = debuggerModel.sourceMapManager();
             for (const script of debuggerModel.scripts()) {