@mcp-b/chrome-devtools-mcp 2.1.0 → 2.2.0

package/build/vendor/chrome-devtools-frontend/front_end/models/trace/handlers/RendererHandler.js

@@ -1,346 +0,0 @@
-// 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 Platform from '../../../core/platform/platform.js';
-import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-import { data as auctionWorkletsData } from './AuctionWorkletsHandler.js';
-import * as HandlerHelpers from './helpers.js';
-import { data as metaHandlerData } from './MetaHandler.js';
-import { data as networkRequestHandlerData } from './NetworkRequestsHandler.js';
-import { data as samplesHandlerData } from './SamplesHandler.js';
-/**
- * This handler builds the hierarchy of trace events and profile calls
- * on each thread on each process.
- *
- * Throughout the code, trace events and profile calls are referred to
- * as "entries", but note they are different types of data. Trace events
- * come directly from the backend and it's the type the engine commonly
- * refers to. Profile calls on the other hand are built in the frontend,
- * and, for compatibility purposes, typed as an extension to the trace
- * event type.
- */
-let processes = new Map();
-let entityMappings = {
-    eventsByEntity: new Map(),
-    entityByEvent: new Map(),
-    createdEntityCache: new Map(),
-    entityByUrlCache: new Map(),
-};
-// We track the compositor tile worker thread name events so that at the end we
-// can return these keyed by the process ID. These are used in the frontend to
-// show the user the rasterization thread(s) on the main frame as tracks.
-let compositorTileWorkers = Array();
-let entryToNode = new Map();
-let completeEventStack = [];
-let config = Types.Configuration.defaults();
-const makeRendererProcess = () => ({
-    url: null,
-    isOnMainFrame: false,
-    threads: new Map(),
-});
-const makeRendererThread = () => ({
-    name: null,
-    entries: [],
-    profileCalls: [],
-    layoutEvents: [],
-    recalcStyleEvents: [],
-});
-const getOrCreateRendererProcess = (processes, pid) => {
-    return Platform.MapUtilities.getWithDefault(processes, pid, makeRendererProcess);
-};
-const getOrCreateRendererThread = (process, tid) => {
-    return Platform.MapUtilities.getWithDefault(process.threads, tid, makeRendererThread);
-};
-export function handleUserConfig(userConfig) {
-    config = userConfig;
-}
-export function reset() {
-    processes = new Map();
-    entryToNode = new Map();
-    entityMappings = {
-        eventsByEntity: new Map(),
-        entityByEvent: new Map(),
-        createdEntityCache: new Map(),
-        entityByUrlCache: new Map(),
-    };
-    completeEventStack = [];
-    compositorTileWorkers = [];
-}
-export function handleEvent(event) {
-    if (Types.Events.isThreadName(event) && event.args.name?.startsWith('CompositorTileWorker')) {
-        compositorTileWorkers.push({
-            pid: event.pid,
-            tid: event.tid,
-        });
-    }
-    if (Types.Events.isBegin(event) || Types.Events.isEnd(event)) {
-        const process = getOrCreateRendererProcess(processes, event.pid);
-        const thread = getOrCreateRendererThread(process, event.tid);
-        const completeEvent = makeCompleteEvent(event);
-        if (!completeEvent) {
-            return;
-        }
-        thread.entries.push(completeEvent);
-        return;
-    }
-    if (Types.Events.isInstant(event) || Types.Events.isComplete(event)) {
-        const process = getOrCreateRendererProcess(processes, event.pid);
-        const thread = getOrCreateRendererThread(process, event.tid);
-        thread.entries.push(event);
-    }
-    if (Types.Events.isLayout(event)) {
-        const process = getOrCreateRendererProcess(processes, event.pid);
-        const thread = getOrCreateRendererThread(process, event.tid);
-        thread.layoutEvents.push(event);
-    }
-    if (Types.Events.isRecalcStyle(event)) {
-        const process = getOrCreateRendererProcess(processes, event.pid);
-        const thread = getOrCreateRendererThread(process, event.tid);
-        thread.recalcStyleEvents.push(event);
-    }
-}
-export async function finalize() {
-    const { mainFrameId, rendererProcessesByFrame, threadsInProcess } = metaHandlerData();
-    entityMappings = networkRequestHandlerData().entityMappings;
-    assignMeta(processes, mainFrameId, rendererProcessesByFrame, threadsInProcess);
-    sanitizeProcesses(processes);
-    buildHierarchy(processes);
-    sanitizeThreads(processes);
-}
-export function data() {
-    return {
-        processes,
-        compositorTileWorkers: gatherCompositorThreads(),
-        entryToNode,
-        entityMappings: {
-            entityByEvent: entityMappings.entityByEvent,
-            eventsByEntity: entityMappings.eventsByEntity,
-            createdEntityCache: entityMappings.createdEntityCache,
-            entityByUrlCache: entityMappings.entityByUrlCache,
-        },
-    };
-}
-function gatherCompositorThreads() {
-    const threadsByProcess = new Map();
-    for (const worker of compositorTileWorkers) {
-        const byProcess = threadsByProcess.get(worker.pid) || [];
-        byProcess.push(worker.tid);
-        threadsByProcess.set(worker.pid, byProcess);
-    }
-    return threadsByProcess;
-}
-/**
- * Steps through all the renderer processes we've located so far in the meta
- * handler, obtaining their URL, checking whether they are the main frame, and
- * collecting each one of their threads' name. This meta handler's data is
- * assigned to the renderer handler's data.
- */
-export function assignMeta(processes, mainFrameId, rendererProcessesByFrame, threadsInProcess) {
-    assignOrigin(processes, rendererProcessesByFrame);
-    assignIsMainFrame(processes, mainFrameId, rendererProcessesByFrame);
-    assignThreadName(processes, threadsInProcess);
-}
-/**
- * Assigns origins to all threads in all processes.
- * @see assignMeta
- */
-export function assignOrigin(processes, rendererProcessesByFrame) {
-    for (const renderProcessesByPid of rendererProcessesByFrame.values()) {
-        for (const [pid, processWindows] of renderProcessesByPid) {
-            for (const processInfo of processWindows.flat()) {
-                const process = getOrCreateRendererProcess(processes, pid);
-                // Sometimes a single process is responsible with rendering multiple
-                // frames at the same time. For example, see https://crbug.com/1334563.
-                // When this happens, we'd still like to assign a single url per process
-                // so: 1) use the first frame rendered by this process as the url source
-                // and 2) if the last url is "about:blank", use the next frame's url,
-                // data from about:blank is irrelevant.
-                if (process.url === null || process.url === 'about:blank') {
-                    // If we are here, it's because we care about this process and the URL. But before we store
-                    // it, we check if it is a valid URL by trying to create a URL object. If it isn't, we won't
-                    // set it, and this process will be filtered out later.
-                    try {
-                        new URL(processInfo.frame.url);
-                        process.url = processInfo.frame.url;
-                    }
-                    catch {
-                        process.url = null;
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * Assigns whether or not a thread is the main frame to all threads in all processes.
- * @see assignMeta
- */
-export function assignIsMainFrame(processes, mainFrameId, rendererProcessesByFrame) {
-    for (const [frameId, renderProcessesByPid] of rendererProcessesByFrame) {
-        for (const [pid] of renderProcessesByPid) {
-            const process = getOrCreateRendererProcess(processes, pid);
-            // We have this go in one direction; once a renderer has been flagged as
-            // being on the main frame, we don't unset it to false if were to show up
-            // in a subframe. Equally, if we already saw this renderer in a subframe,
-            // but it becomes the main frame, the flag would get updated.
-            if (frameId === mainFrameId) {
-                process.isOnMainFrame = true;
-            }
-        }
-    }
-}
-/**
- * Assigns the thread name to all threads in all processes.
- * @see assignMeta
- */
-export function assignThreadName(processes, threadsInProcess) {
-    for (const [pid, process] of processes) {
-        for (const [tid, threadInfo] of threadsInProcess.get(pid) ?? []) {
-            const thread = getOrCreateRendererThread(process, tid);
-            thread.name = threadInfo?.args.name ?? `${tid}`;
-        }
-    }
-}
-/**
- * Removes unneeded trace data opportunistically stored while handling events.
- * This currently does the following:
- *  - Deletes processes with an unknown origin.
- */
-export function sanitizeProcesses(processes) {
-    const auctionWorklets = auctionWorkletsData().worklets;
-    const metaData = metaHandlerData();
-    if (metaData.traceIsGeneric) {
-        return;
-    }
-    for (const [pid, process] of processes) {
-        // If the process had no url, or if it had a malformed url that could not be
-        // parsed for some reason, or if it's an "about:" origin, delete it.
-        // This is done because we don't really care about processes for which we
-        // can't provide actionable insights to the user (e.g. about:blank pages).
-        //
-        // There is one exception; AuctionWorklet processes get parsed in a
-        // separate handler, so at this point we check to see if the process has
-        // been found by the AuctionWorkletsHandler, and if so we update the URL.
-        // This ensures that we keep this process around and do not drop it due to
-        // the lack of a URL.
-        if (process.url === null) {
-            const maybeWorklet = auctionWorklets.get(pid);
-            if (maybeWorklet) {
-                process.url = maybeWorklet.host;
-            }
-            else {
-                processes.delete(pid);
-            }
-            continue;
-        }
-    }
-}
-/**
- * Removes unneeded trace data opportunistically stored while handling events.
- * This currently does the following:
- *  - Deletes threads with no roots.
- */
-export function sanitizeThreads(processes) {
-    for (const [, process] of processes) {
-        for (const [tid, thread] of process.threads) {
-            // If the thread has no roots, delete it. Otherwise, there's going to
-            // be space taken, even though nothing is rendered in the track manager.
-            if (!thread.tree?.roots.size) {
-                process.threads.delete(tid);
-            }
-        }
-    }
-}
-/**
- * Creates a hierarchical structure from the trace events. Each thread in each
- * process will contribute to their own individual hierarchy.
- *
- * The trace data comes in as a contiguous array of events, against which we
- * make a couple of assumptions:
- *
- *  1. Events are temporally-ordered in terms of start time (though they're
- *     not necessarily ordered as such in the data stream).
- *  2. If event B's start and end times are within event A's time boundaries
- *     we assume that A is the parent of B.
- *
- * Therefore we expect to reformulate something like:
- *
- * [ Task A ][ Task B ][ Task C ][ Task D ][ Task E ]
- *
- * Into something hierarchically-arranged like below:
- *
- * |------------- Task A -------------||-- Task E --|
- *  |-- Task B --||-- Task D --|
- *   |- Task C -|
- */
-export function buildHierarchy(processes, options) {
-    const samplesData = samplesHandlerData();
-    for (const [pid, process] of processes) {
-        for (const [tid, thread] of process.threads) {
-            if (!thread.entries.length) {
-                thread.tree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
-                continue;
-            }
-            // Step 1. Massage the data.
-            Helpers.Trace.sortTraceEventsInPlace(thread.entries);
-            // Step 2. Inject profile calls from samples
-            const samplesDataForThread = samplesData.profilesInProcess.get(pid)?.get(tid);
-            if (samplesDataForThread) {
-                const cpuProfile = samplesDataForThread.parsedProfile;
-                const samplesIntegrator = cpuProfile &&
-                    new Helpers.SamplesIntegrator.SamplesIntegrator(cpuProfile, samplesDataForThread.profileId, pid, tid, config);
-                const profileCalls = samplesIntegrator?.buildProfileCalls(thread.entries);
-                if (samplesIntegrator && profileCalls) {
-                    thread.entries = Helpers.Trace.mergeEventsInOrder(thread.entries, profileCalls);
-                    thread.profileCalls = profileCalls;
-                    // We'll also inject the instant JSSample events (in debug mode only)
-                    const jsSamples = samplesIntegrator.jsSampleEvents;
-                    if (jsSamples.length) {
-                        thread.entries = Helpers.Trace.mergeEventsInOrder(thread.entries, jsSamples);
-                    }
-                }
-            }
-            // Step 3. Build the tree.
-            const treeData = Helpers.TreeHelpers.treify(thread.entries, options);
-            thread.tree = treeData.tree;
-            // Update the entryToNode map with the entries from this thread
-            for (const [entry, node] of treeData.entryToNode) {
-                entryToNode.set(entry, node);
-                // Entity mapping is unrelated to the tree, but calling here as we need to call on every node anyway.
-                HandlerHelpers.addEventToEntityMapping(entry, entityMappings);
-            }
-        }
-    }
-}
-export function makeCompleteEvent(event) {
-    if (Types.Events.isEnd(event)) {
-        // Quietly ignore unbalanced close events, they're legit (we could
-        // have missed start one).
-        const beginEvent = completeEventStack.pop();
-        if (!beginEvent) {
-            return null;
-        }
-        if (beginEvent.name !== event.name || beginEvent.cat !== event.cat) {
-            console.error('Begin/End events mismatch at ' + beginEvent.ts + ' (' + beginEvent.name + ') vs. ' + event.ts + ' (' +
-                event.name + ')');
-            return null;
-        }
-        // Update the begin event's duration using the timestamp of the end
-        // event.
-        beginEvent.dur = Types.Timing.Micro(event.ts - beginEvent.ts);
-        return null;
-    }
-    // Create a synthetic event using the begin event, when we find the
-    // matching end event later we will update its duration.
-    const syntheticComplete = {
-        ...event,
-        ph: "X" /* Types.Events.Phase.COMPLETE */,
-        dur: Types.Timing.Micro(0),
-    };
-    completeEventStack.push(syntheticComplete);
-    return syntheticComplete;
-}
-export function deps() {
-    return ['Meta', 'Samples', 'AuctionWorklets', 'NetworkRequests'];
-}

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

@@ -1,260 +0,0 @@
-// 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 Platform from '../../../core/platform/platform.js';
-import * as CPUProfile from '../../cpu_profile/cpu_profile.js';
-import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-let profilesInProcess = new Map();
-let entryToNode = new Map();
-// The profile head, containing its metadata like its start
-// time, comes in a "Profile" event. The sample data comes in
-// "ProfileChunk" events. We match these ProfileChunks with their head
-// using process and profile ids. However, in order to integrate sample
-// data with trace data, we need the thread id that owns each profile.
-// This thread id is extracted from the head event.
-// For this reason, we have a preprocessed data structure, where events
-// 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 (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(chosenData.rawProfile);
-            const profileTree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
-            profileTree.maxDepth = profileModel.maxDepth;
-            const selectedProfileId = chosen.id;
-            const finalizedData = {
-                rawProfile: chosenData.rawProfile,
-                parsedProfile: profileModel,
-                profileCalls: [],
-                profileTree,
-                profileId: selectedProfileId,
-            };
-            const dataByThread = Platform.MapUtilities.getWithDefault(profilesInProcess, processId, () => new Map());
-            dataByThread.set(threadId, finalizedData);
-            // Only need to build pure JS ProfileCalls if we're parsing a CPU Profile, otherwise SamplesIntegrator does the work.
-            if (parseOptions.isCPUProfile) {
-                buildProfileCallsForCPUProfile();
-            }
-            function buildProfileCallsForCPUProfile() {
-                profileModel.forEachFrame(openFrameCallback, closeFrameCallback);
-                function openFrameCallback(depth, node, sampleIndex, timeStampMilliseconds) {
-                    if (threadId === undefined) {
-                        return;
-                    }
-                    const ts = Helpers.Timing.milliToMicro(Types.Timing.Milli(timeStampMilliseconds));
-                    const nodeId = node.id;
-                    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);
-                    entryToNode.set(profileCall, traceEntryNode);
-                    traceEntryNode.depth = depth;
-                    if (indexStack.length === 1) {
-                        // First call in the stack is a root call.
-                        finalizedData.profileTree?.roots.add(traceEntryNode);
-                    }
-                }
-                function closeFrameCallback(_depth, _node, _sampleIndex, _timeStampMillis, durMs, selfTimeMs) {
-                    const profileCallIndex = indexStack.pop();
-                    const profileCall = profileCallIndex !== undefined && finalizedData.profileCalls[profileCallIndex];
-                    if (!profileCall) {
-                        return;
-                    }
-                    const { callFrame, ts, pid, tid } = profileCall;
-                    const traceEntryNode = entryToNode.get(profileCall);
-                    if (callFrame === undefined || ts === undefined || pid === undefined || selectedProfileId === undefined ||
-                        tid === undefined || traceEntryNode === undefined) {
-                        return;
-                    }
-                    const dur = Helpers.Timing.milliToMicro(Types.Timing.Milli(durMs));
-                    const selfTime = Helpers.Timing.milliToMicro(Types.Timing.Milli(selfTimeMs));
-                    profileCall.dur = dur;
-                    traceEntryNode.selfTime = selfTime;
-                    const parentIndex = indexStack.at(-1);
-                    const parent = parentIndex !== undefined && finalizedData.profileCalls.at(parentIndex);
-                    const parentNode = parent && entryToNode.get(parent);
-                    if (!parentNode) {
-                        return;
-                    }
-                    traceEntryNode.parent = parentNode;
-                    parentNode.children.push(traceEntryNode);
-                }
-            }
-        }
-    }
-}
-export function reset() {
-    preprocessedData = new Map();
-    profilesInProcess = new Map();
-    entryToNode = new Map();
-}
-export function handleEvent(event) {
-    /**
-     * A fake trace event created to support CDP.Profiler.Profiles in the
-     * trace engine.
-     */
-    if (Types.Events.isSyntheticCpuProfile(event)) {
-        // At the moment we are attaching to a single node target so we
-        // should only get a single CPU profile. The values of the process
-        // id and thread id are not really important, so we use the data
-        // in the fake event. Should multi-thread CPU profiling be supported
-        // we could use these fields in the event to pass thread info.
-        const profileData = getOrCreatePreProcessedData(event.pid, event.id);
-        profileData.rawProfile = event.args.data.cpuProfile;
-        profileData.threadId = event.tid;
-        return;
-    }
-    if (Types.Events.isProfile(event)) {
-        // Do not use event.args.data.startTime as it is in CLOCK_MONOTONIC domain,
-        // but use profileEvent.ts which has been translated to Perfetto's clock
-        // domain. Also convert from ms to us.
-        // Note: events are collected on a different thread than what's sampled.
-        // The correct process and thread ids are specified by the profile.
-        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)) {
-        const profileData = getOrCreatePreProcessedData(event.pid, event.id);
-        const cdpProfile = profileData.rawProfile;
-        const nodesAndSamples = event.args?.data?.cpuProfile || { samples: [] };
-        const samples = nodesAndSamples?.samples || [];
-        const traceIds = event.args?.data?.cpuProfile?.trace_ids;
-        for (const n of nodesAndSamples?.nodes || []) {
-            const lineNumber = typeof n.callFrame.lineNumber === 'undefined' ? -1 : n.callFrame.lineNumber;
-            const columnNumber = typeof n.callFrame.columnNumber === 'undefined' ? -1 : n.callFrame.columnNumber;
-            const scriptId = String(n.callFrame.scriptId);
-            const url = n.callFrame.url || '';
-            const node = {
-                ...n,
-                callFrame: {
-                    ...n.callFrame,
-                    url,
-                    lineNumber,
-                    columnNumber,
-                    scriptId,
-                },
-            };
-            cdpProfile.nodes.push(node);
-        }
-        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) {
-                cdpProfile.traceIds[key] = traceIds[key];
-            }
-        }
-        if (cdpProfile.samples && cdpProfile.timeDeltas && cdpProfile.samples.length !== cdpProfile.timeDeltas.length) {
-            console.error('Failed to parse CPU profile.');
-            return;
-        }
-        if (!cdpProfile.endTime && cdpProfile.timeDeltas) {
-            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,
-        entryToNode,
-    };
-}
-function getOrCreatePreProcessedData(processId, profileId) {
-    const profileById = Platform.MapUtilities.getWithDefault(preprocessedData, processId, () => new Map());
-    return Platform.MapUtilities.getWithDefault(profileById, profileId, () => ({
-        rawProfile: {
-            startTime: 0,
-            endTime: 0,
-            nodes: [],
-            samples: [],
-            timeDeltas: [],
-            lines: [],
-            columns: [],
-        },
-        profileId,
-    }));
-}
-/**
- * Returns the name of a function for a given synthetic profile call.
- * We first look to find the ProfileNode representing this call, and use its
- * function name. This is preferred (and should always exist) because if we
- * resolve sourcemaps, we will update this name. If that name is not present,
- * we fall back to the function name that was in the callframe that we got
- * when parsing the profile's trace data.
- */
-export function getProfileCallFunctionName(data, entry) {
-    const profile = data.profilesInProcess.get(entry.pid)?.get(entry.tid);
-    const node = profile?.parsedProfile.nodeById(entry.nodeId);
-    if (node?.functionName) {
-        return node.functionName;
-    }
-    return entry.callFrame.functionName;
-}