chrome-devtools-mcp 0.0.2 → 0.2.0

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

@@ -0,0 +1,32 @@
+// Copyright 2023 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 Formatter from '../formatter/formatter.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+/** If a script failed to parse, we stash null in order to prevent unnecessary re-parsing */
+const scopeTrees = new WeakMap();
+/**
+ * Computes and caches the scope tree for `script`.
+ *
+ * We use {@link SDK.Script.Script} as a key to uniquely identify scripts.
+ * {@link SDK.Script.Script} boils down to "target" + "script ID". This
+ * duplicates work in case of identitical script running on multiple targets
+ * (e.g. workers).
+ */
+export function scopeTreeForScript(script) {
+    let promise = scopeTrees.get(script);
+    if (promise === undefined) {
+        promise = script.requestContentData().then(content => {
+            if (TextUtils.ContentData.ContentData.isError(content)) {
+                return null;
+            }
+            const sourceType = script.isModule ? 'module' : 'script';
+            return Formatter.FormatterWorkerPool.formatterWorkerPool()
+                .javaScriptScopeTree(content.text, sourceType)
+                .catch(() => null);
+        });
+        scopeTrees.set(script, promise);
+    }
+    // We intentionally return `null` here if the script already failed to parse once.
+    return promise;
+}

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

@@ -0,0 +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 NamesResolver from './NamesResolver.js';
+import * as ScopeChainModel from './ScopeChainModel.js';
+import * as ScopeTreeCache from './ScopeTreeCache.js';
+export { NamesResolver, ScopeChainModel, ScopeTreeCache, };

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

@@ -0,0 +1,4 @@
+// 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.
+export {};

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

@@ -0,0 +1,67 @@
+// 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 Common from '../../core/common/common.js';
+export class StackTraceImpl extends Common.ObjectWrapper.ObjectWrapper {
+    syncFragment;
+    asyncFragments;
+    constructor(syncFragment, asyncFragments) {
+        super();
+        this.syncFragment = syncFragment;
+        this.asyncFragments = asyncFragments;
+        syncFragment.stackTraces.add(this);
+        this.asyncFragments.forEach(asyncFragment => asyncFragment.fragment.stackTraces.add(this));
+    }
+}
+export class FragmentImpl {
+    node;
+    stackTraces = new Set();
+    /**
+     * Fragments are deduplicated based on the node.
+     *
+     * In turn, each fragment can be part of multiple stack traces.
+     */
+    static getOrCreate(node) {
+        if (!node.fragment) {
+            node.fragment = new FragmentImpl(node);
+        }
+        return node.fragment;
+    }
+    constructor(node) {
+        this.node = node;
+    }
+    get frames() {
+        const frames = [];
+        for (const node of this.node.getCallStack()) {
+            frames.push(...node.frames);
+        }
+        return frames;
+    }
+}
+export class AsyncFragmentImpl {
+    description;
+    fragment;
+    constructor(description, fragment) {
+        this.description = description;
+        this.fragment = fragment;
+    }
+    get frames() {
+        return this.fragment.frames;
+    }
+}
+export class FrameImpl {
+    url;
+    uiSourceCode;
+    name;
+    line;
+    column;
+    missingDebugInfo;
+    constructor(url, uiSourceCode, name, line, column, missingDebugInfo) {
+        this.url = url;
+        this.uiSourceCode = uiSourceCode;
+        this.name = name;
+        this.line = line;
+        this.column = column;
+        this.missingDebugInfo = missingDebugInfo;
+    }
+}

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

@@ -0,0 +1,97 @@
+// 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';
+// eslint-disable-next-line rulesdir/es-modules-import
+import * as StackTrace from './stack_trace.js';
+import { AsyncFragmentImpl, FragmentImpl, FrameImpl, StackTraceImpl } from './StackTraceImpl.js';
+import { Trie } from './Trie.js';
+/**
+ * The {@link StackTraceModel} is a thin wrapper around a fragment trie.
+ *
+ * We want to store stack trace fragments per target so a SDKModel is the natural choice.
+ */
+export class StackTraceModel extends SDK.SDKModel.SDKModel {
+    #trie = new Trie();
+    /** @returns the {@link StackTraceModel} for the target, or the model for the primaryPageTarget when passing null/undefined */
+    static #modelForTarget(target) {
+        const model = (target ?? SDK.TargetManager.TargetManager.instance().primaryPageTarget())?.model(StackTraceModel);
+        if (!model) {
+            throw new Error('Unable to find StackTraceModel');
+        }
+        return model;
+    }
+    async createFromProtocolRuntime(stackTrace, rawFramesToUIFrames) {
+        const translatePromises = [];
+        const fragment = this.#createFragment(stackTrace.callFrames);
+        translatePromises.push(this.#translateFragment(fragment, rawFramesToUIFrames));
+        const asyncFragments = [];
+        const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
+        if (debuggerModel) {
+            for await (const { stackTrace: asyncStackTrace, target } of debuggerModel.iterateAsyncParents(stackTrace)) {
+                const model = StackTraceModel.#modelForTarget(target);
+                const asyncFragment = model.#createFragment(asyncStackTrace.callFrames);
+                translatePromises.push(model.#translateFragment(asyncFragment, rawFramesToUIFrames));
+                asyncFragments.push(new AsyncFragmentImpl(asyncStackTrace.description ?? '', asyncFragment));
+            }
+        }
+        await Promise.all(translatePromises);
+        return new StackTraceImpl(fragment, asyncFragments);
+    }
+    /** Trigger re-translation of all fragments with the provide script in their call stack */
+    async scriptInfoChanged(script, translateRawFrames) {
+        const translatePromises = [];
+        let stackTracesToUpdate = new Set();
+        for (const fragment of this.#affectedFragments(script)) {
+            // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
+            // is re-translated as a side-effect.
+            // We just need to remember the stack traces of the skipped over fragments, so we can send the
+            // UPDATED event also to them.
+            if (fragment.node.children.length === 0) {
+                translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
+            }
+            stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
+        }
+        await Promise.all(translatePromises);
+        for (const stackTrace of stackTracesToUpdate) {
+            stackTrace.dispatchEventToListeners("UPDATED" /* StackTrace.StackTrace.Events.UPDATED */);
+        }
+    }
+    #createFragment(frames) {
+        return FragmentImpl.getOrCreate(this.#trie.insert(frames));
+    }
+    async #translateFragment(fragment, rawFramesToUIFrames) {
+        const rawFrames = fragment.node.getCallStack().map(node => node.rawFrame).toArray();
+        const uiFrames = await rawFramesToUIFrames(rawFrames, this.target());
+        console.assert(rawFrames.length === uiFrames.length, 'Broken rawFramesToUIFrames implementation');
+        let i = 0;
+        for (const node of fragment.node.getCallStack()) {
+            node.frames = uiFrames[i++].map(frame => new FrameImpl(frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo));
+        }
+    }
+    #affectedFragments(script) {
+        // 1. Collect branches with the matching script.
+        const affectedBranches = new Set();
+        this.#trie.walk(null, node => {
+            // scriptId has precedence, but if the frame does not have one, check the URL.
+            if (node.rawFrame.scriptId === script.scriptId ||
+                (!node.rawFrame.scriptId && node.rawFrame.url === script.sourceURL)) {
+                affectedBranches.add(node);
+                return false;
+            }
+            return true;
+        });
+        // 2. For each branch collect all the fragments.
+        const fragments = new Set();
+        for (const branch of affectedBranches) {
+            this.#trie.walk(branch, node => {
+                if (node.fragment) {
+                    fragments.add(node.fragment);
+                }
+                return true;
+            });
+        }
+        return fragments;
+    }
+}
+SDK.SDKModel.SDKModel.register(StackTraceModel, { capabilities: 0 /* SDK.Target.Capability.NONE */, autostart: false });

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

@@ -0,0 +1,113 @@
+// 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.
+export class FrameNode {
+    parent;
+    children = [];
+    rawFrame;
+    frames = [];
+    fragment;
+    constructor(rawFrame, parent) {
+        this.rawFrame = rawFrame;
+        this.parent = parent;
+    }
+    /**
+     * Produces the ancestor chain. Including `this` but excluding the `RootFrameNode`.
+     */
+    *getCallStack() {
+        // The `RootFrameNode` doesn't have an actual frame attached, that's why we check for `node.parent` instead of `node`.
+        for (let node = this; node.parent; node = node.parent) {
+            yield node;
+        }
+    }
+}
+/**
+ * Stores stack trace fragments in a trie, but does not own them/keep them alive.
+ */
+export class Trie {
+    #root = { parent: null, children: [] };
+    /**
+     * Most sources produce stack traces in "top-to-bottom" order, so that is what this method expects.
+     *
+     * @returns The {@link FrameNode} corresponding to the top-most stack frame.
+     */
+    insert(frames) {
+        if (frames.length === 0) {
+            throw new Error('Trie.insert called with an empty frames array.');
+        }
+        let currentNode = this.#root;
+        for (let i = frames.length - 1; i >= 0; --i) {
+            currentNode = this.#insert(currentNode, frames[i]);
+        }
+        return currentNode;
+    }
+    /**
+     * Inserts `rawFrame` into the children of the provided node if not already there.
+     *
+     * @returns the child node corresponding to `rawFrame`.
+     */
+    #insert(node, rawFrame) {
+        let i = 0;
+        for (; i < node.children.length; ++i) {
+            const maybeChild = node.children[i];
+            const child = maybeChild instanceof WeakRef ? maybeChild.deref() : maybeChild;
+            if (!child) {
+                continue;
+            }
+            const compareResult = compareRawFrames(child.rawFrame, rawFrame);
+            if (compareResult === 0) {
+                return child;
+            }
+            if (compareResult > 0) {
+                break;
+            }
+        }
+        const newNode = new FrameNode(rawFrame, node);
+        if (node.parent) {
+            node.children.splice(i, 0, newNode);
+        }
+        else {
+            node.children.splice(i, 0, new WeakRef(newNode));
+        }
+        return newNode;
+    }
+    /**
+     * Traverses the trie in pre-order.
+     *
+     * @param node Start at `node` or `null` to start with the children of the root.
+     * @param visit Called on each node in the trie. Return `true` if the visitor should descend into child nodes of the provided node.
+     */
+    walk(node, visit) {
+        const stack = node ? [node] : [...this.#root.children].map(ref => ref.deref()).filter(node => Boolean(node));
+        for (let node = stack.pop(); node; node = stack.pop()) {
+            const visitChildren = visit(node);
+            if (visitChildren) {
+                // Pushing the children in reverse means the "left-most" child is visited first (i.e. pre-order).
+                for (let i = node.children.length - 1; i >= 0; --i) {
+                    stack.push(node.children[i]);
+                }
+            }
+        }
+    }
+}
+/**
+ * @returns a number < 0, 0 or > 0, if the `a` is smaller then, equal or greater then `b`.
+ */
+export function compareRawFrames(a, b) {
+    const scriptIdCompare = (a.scriptId ?? '').localeCompare(b.scriptId ?? '');
+    if (scriptIdCompare !== 0) {
+        return scriptIdCompare;
+    }
+    const urlCompare = (a.url ?? '').localeCompare(b.url ?? '');
+    if (urlCompare !== 0) {
+        return urlCompare;
+    }
+    const nameCompare = (a.functionName ?? '').localeCompare(b.functionName ?? '');
+    if (nameCompare !== 0) {
+        return nameCompare;
+    }
+    if (a.lineNumber !== b.lineNumber) {
+        return a.lineNumber - b.lineNumber;
+    }
+    return a.columnNumber - b.columnNumber;
+}

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

@@ -0,0 +1,5 @@
+// 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 StackTrace from './StackTrace.js';
+export { StackTrace, };

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

@@ -0,0 +1,7 @@
+// 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 StackTraceImpl from './StackTraceImpl.js';
+import * as StackTraceModel from './StackTraceModel.js';
+import * as Trie from './Trie.js';
+export { StackTraceImpl, StackTraceModel, Trie, };

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

@@ -330,3 +330,26 @@ export const performSearchInSearchMatches = function (matches, query, caseSensit
     }
     return result;
 };
+/**
+ * Finds the longest overlapping string segment between the end of the first
+ * string and the beginning of the second string.
+ *
+ * @param s1 The first string (whose suffix will be checked).
+ * @param s2 The second string (whose prefix will be checked).
+ * @returns The overlapping string segment, or an empty string ("")
+ * if no overlap is found.
+ */
+export const getOverlap = function (s1, s2) {
+    const minLen = Math.min(s1.length, s2.length);
+    // Check from longest possible overlap down to 1
+    for (let n = minLen; n > 0; n--) {
+        // slice(-n) gets the last 'n' chars
+        const suffix = s1.slice(-n);
+        // substring(0, n) gets the first 'n' chars
+        const prefix = s2.substring(0, n);
+        if (suffix === prefix) {
+            return suffix;
+        }
+    }
+    return null;
+};

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

@@ -361,7 +361,7 @@ export class TraceProcessor extends EventTarget {
             let model;
             try {
                 options.logger?.start(`insights:${name}`);
-                model = insight.generateInsight(data, context);
+                model = insight.generateInsight(data, context, options.insightTimeFormatters);
                 model.frameId = context.frameId;
                 const navId = context.navigation?.args.data?.navigationId;
                 if (navId) {

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

@@ -642,7 +642,7 @@ export function extractSampleTraceId(event) {
     }
     return event.args?.sampleTraceId ?? event.args?.data?.sampleTraceId ?? null;
 }
-// This exactly matches EntryStyles.visibleTypes. See the runtime verification in maybeInitSylesMap.
+// This exactly matches Trace.Styles.visibleTypes. See the runtime verification in maybeInitStylesMap.
 // TODO(crbug.com/410884528)
 export const VISIBLE_TRACE_EVENT_TYPES = new Set([
     "AbortPostTaskCallback" /* Types.Events.Name.ABORT_POST_TASK_CALLBACK */,

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

@@ -153,10 +153,11 @@ function finalize(partialModel) {
         ...partialModel,
     };
 }
-export function generateInsight(data, context) {
+export function generateInsight(data, context, timeFormatters) {
     if (!context.navigation) {
         return finalize({});
     }
+    const millisToString = timeFormatters?.milli ?? i18n.TimeUtilities.millisToString;
     const documentRequest = data.NetworkRequests.byId.get(context.navigationId);
     if (!documentRequest) {
         return finalize({ warnings: [InsightWarning.NO_DOCUMENT_REQUEST] });
@@ -191,14 +192,14 @@ export function generateInsight(data, context) {
                 noRedirects: {
                     label: noRedirects ? i18nString(UIStrings.passingRedirects) : i18nString(UIStrings.failedRedirects, {
                         PH1: documentRequest.args.data.redirects.length,
-                        PH2: i18n.TimeUtilities.millisToString(redirectDuration),
+                        PH2: millisToString(redirectDuration),
                     }),
                     value: noRedirects
                 },
                 serverResponseIsFast: {
                     label: serverResponseIsFast ?
-                        i18nString(UIStrings.passingServerResponseTime, { PH1: i18n.TimeUtilities.millisToString(serverResponseTime) }) :
-                        i18nString(UIStrings.failedServerResponseTime, { PH1: i18n.TimeUtilities.millisToString(serverResponseTime) }),
+                        i18nString(UIStrings.passingServerResponseTime, { PH1: millisToString(serverResponseTime) }) :
+                        i18nString(UIStrings.failedServerResponseTime, { PH1: millisToString(serverResponseTime) }),
                     value: serverResponseIsFast
                 },
                 usesCompression: {

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

@@ -0,0 +1,199 @@
+// Copyright 2023 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 SourceMapScopes from '../source_map_scopes/source_map_scopes.js';
+import * as Trace from '../trace/trace.js';
+import * as Workspace from '../workspace/workspace.js';
+export class SourceMappingsUpdated extends Event {
+    static eventName = 'sourcemappingsupdated';
+    constructor() {
+        super(SourceMappingsUpdated.eventName, { composed: true, bubbles: true });
+    }
+}
+// The code location key is created as a concatenation of its fields.
+export const resolvedCodeLocationDataNames = new Map();
+export class SourceMapsResolver extends EventTarget {
+    executionContextNamesByOrigin = new Map();
+    #parsedTrace;
+    #entityMapper = null;
+    #isResolving = false;
+    // We need to gather up a list of all the DebuggerModels that we should
+    // listen to for source map attached events. For most pages this will be
+    // the debugger model for the primary page target, but if a trace has
+    // workers, we would also need to gather up the DebuggerModel instances for
+    // those workers too.
+    #debuggerModelsToListen = new Set();
+    constructor(parsedTrace, entityMapper) {
+        super();
+        this.#parsedTrace = parsedTrace;
+        this.#entityMapper = entityMapper ?? null;
+    }
+    static clearResolvedNodeNames() {
+        resolvedCodeLocationDataNames.clear();
+    }
+    static keyForCodeLocation(callFrame) {
+        return `${callFrame.url}$$$${callFrame.scriptId}$$$${callFrame.functionName}$$$${callFrame.lineNumber}$$$${callFrame.columnNumber}`;
+    }
+    /**
+     * For trace events containing a call frame / source location
+     * (f.e. a stack trace), attempts to obtain the resolved source
+     * location based on the those that have been resolved so far from
+     * listened source maps.
+     *
+     * Note that a single deployed URL can map to multiple authored URLs
+     * (f.e. if an app is bundled). Thus, beyond a URL we can use code
+     * location data like line and column numbers to obtain the specific
+     * authored code according to the source mappings.
+     *
+     * TODO(andoli): This can return incorrect scripts if the target page has been reloaded since the trace.
+     */
+    static resolvedCodeLocationForCallFrame(callFrame) {
+        const codeLocationKey = this.keyForCodeLocation(callFrame);
+        return resolvedCodeLocationDataNames.get(codeLocationKey) ?? null;
+    }
+    static resolvedCodeLocationForEntry(entry) {
+        let callFrame = null;
+        if (Trace.Types.Events.isProfileCall(entry)) {
+            callFrame = entry.callFrame;
+        }
+        else {
+            const topCallFrame = Trace.Helpers.Trace.getStackTraceTopCallFrameInEventPayload(entry);
+            if (!topCallFrame) {
+                return null;
+            }
+            callFrame = topCallFrame;
+        }
+        return SourceMapsResolver.resolvedCodeLocationForCallFrame(callFrame);
+    }
+    static resolvedURLForEntry(parsedTrace, entry) {
+        const resolvedCallFrameURL = SourceMapsResolver.resolvedCodeLocationForEntry(entry)?.devtoolsLocation?.uiSourceCode.url();
+        if (resolvedCallFrameURL) {
+            return resolvedCallFrameURL;
+        }
+        // If no source mapping was found for an entry's URL, then default
+        // to the URL value contained in the event itself, if any.
+        const url = Trace.Handlers.Helpers.getNonResolvedURL(entry, parsedTrace.data);
+        if (url) {
+            return Workspace.Workspace.WorkspaceImpl.instance().uiSourceCodeForURL(url)?.url() ?? url;
+        }
+        return null;
+    }
+    static storeResolvedCodeDataForCallFrame(callFrame, resolvedCodeLocationData) {
+        const keyForCallFrame = this.keyForCodeLocation(callFrame);
+        resolvedCodeLocationDataNames.set(keyForCallFrame, resolvedCodeLocationData);
+    }
+    async install() {
+        for (const threadToProfileMap of this.#parsedTrace.data.Samples.profilesInProcess.values()) {
+            for (const [tid, profile] of threadToProfileMap) {
+                const nodes = profile.parsedProfile.nodes();
+                if (!nodes || nodes.length === 0) {
+                    continue;
+                }
+                const target = this.#targetForThread(tid);
+                const debuggerModel = target?.model(SDK.DebuggerModel.DebuggerModel);
+                if (!debuggerModel) {
+                    continue;
+                }
+                for (const node of nodes) {
+                    const script = debuggerModel.scriptForId(String(node.callFrame.scriptId));
+                    const shouldListenToSourceMap = !script || script.sourceMapURL;
+                    if (!shouldListenToSourceMap) {
+                        continue;
+                    }
+                    this.#debuggerModelsToListen.add(debuggerModel);
+                }
+            }
+        }
+        for (const debuggerModel of this.#debuggerModelsToListen) {
+            debuggerModel.sourceMapManager().addEventListener(SDK.SourceMapManager.Events.SourceMapAttached, this.#onAttachedSourceMap, this);
+        }
+        this.#updateExtensionNames();
+        // Although we have added listeners for SourceMapAttached events, we also
+        // immediately try to resolve function names. This ensures we use any
+        // sourcemaps that were attached before we bound our event listener.
+        await this.#resolveMappingsForProfileNodes();
+    }
+    /**
+     * Removes the event listeners and stops tracking newly added sourcemaps.
+     * Should be called before destroying an instance of this class to avoid leaks
+     * with listeners.
+     */
+    uninstall() {
+        for (const debuggerModel of this.#debuggerModelsToListen) {
+            debuggerModel.sourceMapManager().removeEventListener(SDK.SourceMapManager.Events.SourceMapAttached, this.#onAttachedSourceMap, this);
+        }
+        this.#debuggerModelsToListen.clear();
+    }
+    async #resolveMappingsForProfileNodes() {
+        // Used to track if source mappings were updated when a source map
+        // is attach. If not, we do not notify the flamechart that mappings
+        // were updated, since that would trigger a rerender.
+        let updatedMappings = false;
+        for (const [, threadsInProcess] of this.#parsedTrace.data.Samples.profilesInProcess) {
+            for (const [tid, threadProfile] of threadsInProcess) {
+                const nodes = threadProfile.parsedProfile.nodes() ?? [];
+                const target = this.#targetForThread(tid);
+                if (!target) {
+                    continue;
+                }
+                for (const node of nodes) {
+                    const resolvedFunctionName = await SourceMapScopes.NamesResolver.resolveProfileFrameFunctionName(node.callFrame, target);
+                    updatedMappings ||= Boolean(resolvedFunctionName);
+                    node.setFunctionName(resolvedFunctionName);
+                    const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
+                    const script = debuggerModel?.scriptForId(node.scriptId) || null;
+                    const location = debuggerModel &&
+                        new SDK.DebuggerModel.Location(debuggerModel, node.callFrame.scriptId, node.callFrame.lineNumber, node.callFrame.columnNumber);
+                    const uiLocation = location &&
+                        await Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance().rawLocationToUILocation(location);
+                    updatedMappings ||= Boolean(uiLocation);
+                    if (uiLocation?.uiSourceCode.url() && this.#entityMapper) {
+                        // Update mappings for the related events of the entity.
+                        this.#entityMapper.updateSourceMapEntities(node.callFrame, uiLocation.uiSourceCode.url());
+                    }
+                    SourceMapsResolver.storeResolvedCodeDataForCallFrame(node.callFrame, { name: resolvedFunctionName, devtoolsLocation: uiLocation, script });
+                }
+            }
+        }
+        if (!updatedMappings) {
+            return;
+        }
+        this.dispatchEvent(new SourceMappingsUpdated());
+    }
+    #onAttachedSourceMap() {
+        // Exit if we are already resolving so that we batch requests; if pages
+        // have a lot of sourcemaps we can get a lot of events at once.
+        if (this.#isResolving) {
+            return;
+        }
+        this.#isResolving = true;
+        // Resolving names triggers a repaint of the flame chart. Instead of attempting to resolve
+        // names every time a source map is attached, wait for some time once the first source map is
+        // attached. This way we allow for other source maps to be parsed before attempting a name
+        // resolving using the available source maps. Otherwise the UI is blocked when the number
+        // of source maps is particularly large.
+        setTimeout(async () => {
+            this.#isResolving = false;
+            await this.#resolveMappingsForProfileNodes();
+        }, 500);
+    }
+    // Figure out the target for the node. If it is in a worker thread,
+    // that is the target, otherwise we use the primary page target.
+    #targetForThread(tid) {
+        const maybeWorkerId = this.#parsedTrace.data.Workers.workerIdByThread.get(tid);
+        if (maybeWorkerId) {
+            return SDK.TargetManager.TargetManager.instance().targetById(maybeWorkerId);
+        }
+        return SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+    }
+    #updateExtensionNames() {
+        for (const runtimeModel of SDK.TargetManager.TargetManager.instance().models(SDK.RuntimeModel.RuntimeModel)) {
+            for (const context of runtimeModel.executionContexts()) {
+                this.executionContextNamesByOrigin.set(context.origin, context.name);
+            }
+        }
+        this.#entityMapper?.updateExtensionEntitiesWithName(this.executionContextNamesByOrigin);
+    }
+}

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

@@ -0,0 +1,4 @@
+// Copyright 2025 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export * from './SourceMapsResolver.js';