chrome-devtools-mcp 0.11.0 → 0.12.1

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

@@ -1,349 +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.
-/**
- * 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

@@ -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'];
-}