ideamans-chrome-devtools-mcp 0.11.2

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

@@ -0,0 +1,349 @@
+// 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.
+/**
+ * This handler stores page load metrics, including web vitals,
+ * and exports them in the shape of a map with the following shape:
+ * Map(FrameId -> Map(navigationID -> metrics) )
+ *
+ * It also exports all markers in a trace in an array.
+ *
+ * Some metrics are taken directly from a page load events (AKA markers) like DCL.
+ * Others require processing multiple events to be determined, like CLS and TBT.
+ */
+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 metaHandlerData } from './MetaHandler.js';
+/**
+ * This represents the metric scores for all navigations, for all frames in a trace.
+ * Given a frame id, the map points to another map from navigation id to metric scores.
+ * The metric scores include the event related to the metric as well as the data regarding
+ * the score itself.
+ */
+let metricScoresByFrameId = new Map();
+/**
+ * Page load events with no associated duration that happened in the
+ * main frame.
+ */
+let allMarkerEvents = [];
+export function reset() {
+    metricScoresByFrameId = new Map();
+    pageLoadEventsArray = [];
+    allMarkerEvents = [];
+    selectedLCPCandidateEvents = new Set();
+}
+let pageLoadEventsArray = [];
+// Once we've found the LCP events in the trace we want to fetch their DOM Node
+// from the backend. We could do this by parsing through our Map of frame =>
+// navigation => metric, but it's easier to keep a set of LCP events. As we
+// parse the trace, any time we store an LCP candidate as the potential LCP
+// event, we store the event here. If we later find a new candidate in the
+// trace, we store that and delete the prior event. When we've parsed the
+// entire trace this set will contain all the LCP events that were used - e.g.
+// the candidates that were the actual LCP events.
+let selectedLCPCandidateEvents = new Set();
+export function handleEvent(event) {
+    if (!Types.Events.eventIsPageLoadEvent(event)) {
+        return;
+    }
+    pageLoadEventsArray.push(event);
+}
+function storePageLoadMetricAgainstNavigationId(navigation, event) {
+    const navigationId = navigation.args.data?.navigationId;
+    if (!navigationId) {
+        throw new Error('Navigation event unexpectedly had no navigation ID.');
+    }
+    const frameId = getFrameIdForPageLoadEvent(event);
+    const { rendererProcessesByFrame } = metaHandlerData();
+    // If either of these pieces of data do not exist, the most likely
+    // explanation is that the page load metric we found is for a frame/process
+    // combo that the MetaHandler discarded. This typically happens if we get a
+    // navigation event with an empty URL. Therefore, we will silently return and
+    // drop this metric. If we didn't care about the navigation, we certainly do
+    // not need to care about metrics for that navigation.
+    const rendererProcessesInFrame = rendererProcessesByFrame.get(frameId);
+    if (!rendererProcessesInFrame) {
+        return;
+    }
+    const processData = rendererProcessesInFrame.get(event.pid);
+    if (!processData) {
+        return;
+    }
+    if (Types.Events.isNavigationStart(event)) {
+        return;
+    }
+    if (Types.Events.isFirstContentfulPaint(event)) {
+        const fcpTime = Types.Timing.Micro(event.ts - navigation.ts);
+        const classification = scoreClassificationForFirstContentfulPaint(fcpTime);
+        const metricScore = { event, metricName: "FCP" /* MetricName.FCP */, classification, navigation, timing: fcpTime };
+        storeMetricScore(frameId, navigationId, metricScore);
+        return;
+    }
+    if (Types.Events.isFirstPaint(event)) {
+        const paintTime = Types.Timing.Micro(event.ts - navigation.ts);
+        const classification = "unclassified" /* ScoreClassification.UNCLASSIFIED */;
+        const metricScore = { event, metricName: "FP" /* MetricName.FP */, classification, navigation, timing: paintTime };
+        storeMetricScore(frameId, navigationId, metricScore);
+        return;
+    }
+    if (Types.Events.isMarkDOMContent(event)) {
+        const dclTime = Types.Timing.Micro(event.ts - navigation.ts);
+        const metricScore = {
+            event,
+            metricName: "DCL" /* MetricName.DCL */,
+            classification: scoreClassificationForDOMContentLoaded(dclTime),
+            navigation,
+            timing: dclTime,
+        };
+        storeMetricScore(frameId, navigationId, metricScore);
+        return;
+    }
+    if (Types.Events.isInteractiveTime(event)) {
+        const ttiValue = Types.Timing.Micro(event.ts - navigation.ts);
+        const tti = {
+            event,
+            metricName: "TTI" /* MetricName.TTI */,
+            classification: scoreClassificationForTimeToInteractive(ttiValue),
+            navigation,
+            timing: ttiValue,
+        };
+        storeMetricScore(frameId, navigationId, tti);
+        const tbtValue = Helpers.Timing.milliToMicro(Types.Timing.Milli(event.args.args.total_blocking_time_ms));
+        const tbt = {
+            event,
+            metricName: "TBT" /* MetricName.TBT */,
+            classification: scoreClassificationForTotalBlockingTime(tbtValue),
+            navigation,
+            timing: tbtValue,
+        };
+        storeMetricScore(frameId, navigationId, tbt);
+        return;
+    }
+    if (Types.Events.isMarkLoad(event)) {
+        const loadTime = Types.Timing.Micro(event.ts - navigation.ts);
+        const metricScore = {
+            event,
+            metricName: "L" /* MetricName.L */,
+            classification: "unclassified" /* ScoreClassification.UNCLASSIFIED */,
+            navigation,
+            timing: loadTime,
+        };
+        storeMetricScore(frameId, navigationId, metricScore);
+        return;
+    }
+    if (Types.Events.isLargestContentfulPaintCandidate(event)) {
+        const candidateIndex = event.args.data?.candidateIndex;
+        if (!candidateIndex) {
+            throw new Error('Largest Contentful Paint unexpectedly had no candidateIndex.');
+        }
+        const lcpTime = Types.Timing.Micro(event.ts - navigation.ts);
+        const lcp = {
+            event,
+            metricName: "LCP" /* MetricName.LCP */,
+            classification: scoreClassificationForLargestContentfulPaint(lcpTime),
+            navigation,
+            timing: lcpTime,
+        };
+        const metricsByNavigation = Platform.MapUtilities.getWithDefault(metricScoresByFrameId, frameId, () => new Map());
+        const metrics = Platform.MapUtilities.getWithDefault(metricsByNavigation, navigationId, () => new Map());
+        const lastLCPCandidate = metrics.get("LCP" /* MetricName.LCP */);
+        if (lastLCPCandidate === undefined) {
+            selectedLCPCandidateEvents.add(lcp.event);
+            storeMetricScore(frameId, navigationId, lcp);
+            return;
+        }
+        const lastLCPCandidateEvent = lastLCPCandidate.event;
+        if (!Types.Events.isLargestContentfulPaintCandidate(lastLCPCandidateEvent)) {
+            return;
+        }
+        const lastCandidateIndex = lastLCPCandidateEvent.args.data?.candidateIndex;
+        if (!lastCandidateIndex) {
+            // lastCandidateIndex cannot be undefined because we don't store candidates with
+            // with an undefined candidateIndex value. This check is only to make TypeScript
+            // treat the field as not undefined below.
+            return;
+        }
+        if (lastCandidateIndex < candidateIndex) {
+            selectedLCPCandidateEvents.delete(lastLCPCandidateEvent);
+            selectedLCPCandidateEvents.add(lcp.event);
+            storeMetricScore(frameId, navigationId, lcp);
+        }
+        return;
+    }
+    if (Types.Events.isLayoutShift(event)) {
+        return;
+    }
+    return Platform.assertNever(event, `Unexpected event type: ${event}`);
+}
+function storeMetricScore(frameId, navigationId, metricScore) {
+    const metricsByNavigation = Platform.MapUtilities.getWithDefault(metricScoresByFrameId, frameId, () => new Map());
+    const metrics = Platform.MapUtilities.getWithDefault(metricsByNavigation, navigationId, () => new Map());
+    // If an entry with that metric name is present, delete it so that the new entry that
+    // will replace it is added at the end of the map. This way we guarantee the map entries
+    // are ordered in ASC manner by timestamp.
+    metrics.delete(metricScore.metricName);
+    metrics.set(metricScore.metricName, metricScore);
+}
+export function getFrameIdForPageLoadEvent(event) {
+    if (Types.Events.isFirstContentfulPaint(event) || Types.Events.isInteractiveTime(event) ||
+        Types.Events.isLargestContentfulPaintCandidate(event) || Types.Events.isNavigationStart(event) ||
+        Types.Events.isLayoutShift(event) || Types.Events.isFirstPaint(event)) {
+        return event.args.frame;
+    }
+    if (Types.Events.isMarkDOMContent(event) || Types.Events.isMarkLoad(event)) {
+        const frameId = event.args.data?.frame;
+        if (!frameId) {
+            throw new Error('MarkDOMContent unexpectedly had no frame ID.');
+        }
+        return frameId;
+    }
+    Platform.assertNever(event, `Unexpected event type: ${event}`);
+}
+function getNavigationForPageLoadEvent(event) {
+    if (Types.Events.isFirstContentfulPaint(event) || Types.Events.isLargestContentfulPaintCandidate(event) ||
+        Types.Events.isFirstPaint(event)) {
+        const navigationId = event.args.data?.navigationId;
+        if (!navigationId) {
+            throw new Error('Trace event unexpectedly had no navigation ID.');
+        }
+        const { navigationsByNavigationId } = metaHandlerData();
+        const navigation = navigationsByNavigationId.get(navigationId);
+        if (!navigation) {
+            // This event's navigation has been filtered out by the meta handler as a noise event.
+            return null;
+        }
+        return navigation;
+    }
+    if (Types.Events.isMarkDOMContent(event) || Types.Events.isInteractiveTime(event) ||
+        Types.Events.isLayoutShift(event) || Types.Events.isMarkLoad(event)) {
+        const frameId = getFrameIdForPageLoadEvent(event);
+        const { navigationsByFrameId } = metaHandlerData();
+        return Helpers.Trace.getNavigationForTraceEvent(event, frameId, navigationsByFrameId);
+    }
+    if (Types.Events.isNavigationStart(event)) {
+        // We don't want to compute metrics of the navigation relative to itself, so we'll avoid avoid all that.
+        return null;
+    }
+    return Platform.assertNever(event, `Unexpected event type: ${event}`);
+}
+/**
+ * Classifications sourced from
+ * https://web.dev/fcp/
+ */
+export function scoreClassificationForFirstContentfulPaint(fcpScoreInMicroseconds) {
+    const FCP_GOOD_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(1.8));
+    const FCP_MEDIUM_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(3.0));
+    let scoreClassification = "bad" /* ScoreClassification.BAD */;
+    if (fcpScoreInMicroseconds <= FCP_MEDIUM_TIMING) {
+        scoreClassification = "ok" /* ScoreClassification.OK */;
+    }
+    if (fcpScoreInMicroseconds <= FCP_GOOD_TIMING) {
+        scoreClassification = "good" /* ScoreClassification.GOOD */;
+    }
+    return scoreClassification;
+}
+/**
+ * Classifications sourced from
+ * https://web.dev/interactive/#how-lighthouse-determines-your-tti-score
+ */
+export function scoreClassificationForTimeToInteractive(ttiTimeInMicroseconds) {
+    const TTI_GOOD_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(3.8));
+    const TTI_MEDIUM_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(7.3));
+    let scoreClassification = "bad" /* ScoreClassification.BAD */;
+    if (ttiTimeInMicroseconds <= TTI_MEDIUM_TIMING) {
+        scoreClassification = "ok" /* ScoreClassification.OK */;
+    }
+    if (ttiTimeInMicroseconds <= TTI_GOOD_TIMING) {
+        scoreClassification = "good" /* ScoreClassification.GOOD */;
+    }
+    return scoreClassification;
+}
+/**
+ * Classifications sourced from
+ * https://web.dev/lcp/#what-is-lcp
+ */
+export function scoreClassificationForLargestContentfulPaint(lcpTimeInMicroseconds) {
+    const LCP_GOOD_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(2.5));
+    const LCP_MEDIUM_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(4));
+    let scoreClassification = "bad" /* ScoreClassification.BAD */;
+    if (lcpTimeInMicroseconds <= LCP_MEDIUM_TIMING) {
+        scoreClassification = "ok" /* ScoreClassification.OK */;
+    }
+    if (lcpTimeInMicroseconds <= LCP_GOOD_TIMING) {
+        scoreClassification = "good" /* ScoreClassification.GOOD */;
+    }
+    return scoreClassification;
+}
+/**
+ * DCL does not have a classification.
+ */
+export function scoreClassificationForDOMContentLoaded(_dclTimeInMicroseconds) {
+    return "unclassified" /* ScoreClassification.UNCLASSIFIED */;
+}
+/**
+ * Classifications sourced from
+ * https://web.dev/lighthouse-total-blocking-#time/
+ */
+export function scoreClassificationForTotalBlockingTime(tbtTimeInMicroseconds) {
+    const TBT_GOOD_TIMING = Helpers.Timing.milliToMicro(Types.Timing.Milli(200));
+    const TBT_MEDIUM_TIMING = Helpers.Timing.milliToMicro(Types.Timing.Milli(600));
+    let scoreClassification = "bad" /* ScoreClassification.BAD */;
+    if (tbtTimeInMicroseconds <= TBT_MEDIUM_TIMING) {
+        scoreClassification = "ok" /* ScoreClassification.OK */;
+    }
+    if (tbtTimeInMicroseconds <= TBT_GOOD_TIMING) {
+        scoreClassification = "good" /* ScoreClassification.GOOD */;
+    }
+    return scoreClassification;
+}
+/**
+ * Gets all the Largest Contentful Paint scores of all the frames in the
+ * trace.
+ */
+function gatherFinalLCPEvents() {
+    const allFinalLCPEvents = [];
+    const dataForAllFrames = [...metricScoresByFrameId.values()];
+    const dataForAllNavigations = dataForAllFrames.flatMap(frameData => [...frameData.values()]);
+    for (let i = 0; i < dataForAllNavigations.length; i++) {
+        const navigationData = dataForAllNavigations[i];
+        const lcpInNavigation = navigationData.get("LCP" /* MetricName.LCP */);
+        if (!lcpInNavigation?.event) {
+            continue;
+        }
+        allFinalLCPEvents.push(lcpInNavigation.event);
+    }
+    return allFinalLCPEvents;
+}
+export async function finalize() {
+    pageLoadEventsArray.sort((a, b) => a.ts - b.ts);
+    for (const pageLoadEvent of pageLoadEventsArray) {
+        const navigation = getNavigationForPageLoadEvent(pageLoadEvent);
+        if (navigation) {
+            // Event's navigation was not filtered out as noise.
+            storePageLoadMetricAgainstNavigationId(navigation, pageLoadEvent);
+        }
+    }
+    // NOTE: if you are looking for the TBT calculation, it has temporarily been
+    // removed. See crbug.com/1424335 for details.
+    const allFinalLCPEvents = gatherFinalLCPEvents();
+    const mainFrame = metaHandlerData().mainFrameId;
+    // Filter out LCP candidates to use only definitive LCP values
+    const allEventsButLCP = pageLoadEventsArray.filter(event => !Types.Events.isLargestContentfulPaintCandidate(event));
+    const markerEvents = [...allFinalLCPEvents, ...allEventsButLCP].filter(Types.Events.isMarkerEvent);
+    // Filter by main frame and sort.
+    allMarkerEvents =
+        markerEvents.filter(event => getFrameIdForPageLoadEvent(event) === mainFrame).sort((a, b) => a.ts - b.ts);
+}
+export function data() {
+    return {
+        metricScoresByFrameId,
+        allMarkerEvents,
+    };
+}
+export function deps() {
+    return ['Meta'];
+}
+export function metricIsLCP(metric) {
+    return metric.metricName === "LCP" /* MetricName.LCP */;
+}

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

@@ -0,0 +1,346 @@
+// 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'];
+}