devtools-tracing 1.1.1 → 1.2.0

package/lib/front_end/models/trace/insights/RenderBlocking.ts

@@ -1,257 +0,0 @@
-// Copyright 2024 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 i18n from '../../../core/i18n/i18n.js';
-import * as Protocol from '../../../generated/protocol.js';
-import * as Handlers from '../handlers/handlers.js';
-import * as Helpers from '../helpers/helpers.js';
-import type * as Lantern from '../lantern/lantern.js';
-import type * as Types from '../types/types.js';
-
-import {
-  InsightCategory,
-  InsightKeys,
-  type InsightModel,
-  type InsightSetContext,
-  type InsightSetContextWithNavigation,
-  InsightWarning,
-  type LanternContext,
-  type PartialInsightModel,
-} from './types.js';
-
-export const UIStrings = {
-  /**
-   * @description Title of an insight that provides the user with the list of network requests that blocked and therefore slowed down the page rendering and becoming visible to the user.
-   */
-  title: 'Render blocking requests',
-  /**
-   * @description Text to describe that there are requests blocking rendering, which may affect LCP.
-   */
-  description: 'Requests are blocking the page\'s initial render, which may delay LCP. ' +
-      '[Deferring or inlining](https://developer.chrome.com/docs/performance/insights/render-blocking) ' +
-      'can move these network requests out of the critical path.',
-  /**
-   * @description Label to describe a network request (that happens to be render-blocking).
-   */
-  renderBlockingRequest: 'Request',
-  /**
-   * @description Label used for a time duration.
-   */
-  duration: 'Duration',
-  /**
-   * @description Text status indicating that no requests blocked the initial render of a navigation
-   */
-  noRenderBlocking: 'No render blocking requests for this navigation',
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/RenderBlocking.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export function isRenderBlockingInsight(insight: InsightModel): insight is RenderBlockingInsightModel {
-  return insight.insightKey === 'RenderBlocking';
-}
-
-export type RenderBlockingInsightModel = InsightModel<typeof UIStrings, {
-  renderBlockingRequests: Types.Events.SyntheticNetworkRequest[],
-  requestIdToWastedMs?: Map<string, number>,
-}>;
-
-// Because of the way we detect blocking stylesheets, asynchronously loaded
-// CSS with link[rel=preload] and an onload handler (see https://github.com/filamentgroup/loadCSS)
-// can be falsely flagged as blocking. Therefore, ignore stylesheets that loaded fast enough
-// to possibly be non-blocking (and they have minimal impact anyway).
-const MINIMUM_WASTED_MS = 50;
-
-/**
- * Given a simulation's nodeTimings, return an object with the nodes/timing keyed by network URL
- */
-function getNodesAndTimingByRequestId(nodeTimings: Lantern.Simulation.Result['nodeTimings']):
-    Map<string, {node: Lantern.Graph.Node, nodeTiming: Lantern.Types.Simulation.NodeTiming}> {
-  const requestIdToNode =
-      new Map<string, {node: Lantern.Graph.Node, nodeTiming: Lantern.Types.Simulation.NodeTiming}>();
-
-  for (const [node, nodeTiming] of nodeTimings) {
-    if (node.type !== 'network') {
-      continue;
-    }
-
-    requestIdToNode.set(node.request.requestId, {node, nodeTiming});
-  }
-
-  return requestIdToNode;
-}
-
-function estimateSavingsWithGraphs(deferredIds: Set<string>, lanternContext: LanternContext): Types.Timing.Milli {
-  const simulator = lanternContext.simulator;
-  const fcpGraph = lanternContext.metrics.firstContentfulPaint.optimisticGraph;
-  const {nodeTimings} = lanternContext.simulator.simulate(fcpGraph);
-  const adjustedNodeTimings = new Map(nodeTimings);
-
-  const totalChildNetworkBytes = 0;
-  const minimalFCPGraph = fcpGraph.cloneWithRelationships(node => {
-    // If a node can be deferred, exclude it from the new FCP graph
-    const canDeferRequest = deferredIds.has(node.id);
-    return !canDeferRequest;
-  });
-
-  if (minimalFCPGraph.type !== 'network') {
-    throw new Error('minimalFCPGraph not a NetworkNode');
-  }
-
-  // Recalculate the "before" time based on our adjusted node timings.
-  const estimateBeforeInline = Math.max(...Array.from(
-      Array.from(adjustedNodeTimings).map(timing => timing[1].endTime),
-      ));
-
-  // Add the inlined bytes to the HTML response
-  const originalTransferSize = minimalFCPGraph.request.transferSize;
-  const safeTransferSize = originalTransferSize || 0;
-  minimalFCPGraph.request.transferSize = safeTransferSize + totalChildNetworkBytes;
-  const estimateAfterInline = simulator.simulate(minimalFCPGraph).timeInMs;
-  minimalFCPGraph.request.transferSize = originalTransferSize;
-  return Math.round(Math.max(estimateBeforeInline - estimateAfterInline, 0)) as Types.Timing.Milli;
-}
-
-function hasImageLCP(data: Handlers.Types.HandlerData, context: InsightSetContextWithNavigation): boolean {
-  return data.LargestImagePaint.lcpRequestByNavigationId.has(context.navigationId);
-}
-
-function computeSavings(
-    data: Handlers.Types.HandlerData, context: InsightSetContextWithNavigation,
-    renderBlockingRequests: Types.Events.SyntheticNetworkRequest[]):
-    Pick<RenderBlockingInsightModel, 'metricSavings'|'requestIdToWastedMs'>|undefined {
-  if (!context.lantern) {
-    return;
-  }
-
-  const nodesAndTimingsByRequestId =
-      getNodesAndTimingByRequestId(context.lantern.metrics.firstContentfulPaint.optimisticEstimate.nodeTimings);
-
-  const metricSavings = {FCP: 0 as Types.Timing.Milli, LCP: 0 as Types.Timing.Milli};
-  const requestIdToWastedMs = new Map<string, number>();
-  const deferredNodeIds = new Set<string>();
-  for (const request of renderBlockingRequests) {
-    const nodeAndTiming = nodesAndTimingsByRequestId.get(request.args.data.requestId);
-    if (!nodeAndTiming) {
-      continue;
-    }
-
-    const {node, nodeTiming} = nodeAndTiming;
-
-    // Mark this node and all its dependents as deferrable
-    node.traverse(node => deferredNodeIds.add(node.id));
-
-    // "wastedMs" is the download time of the network request, responseReceived - requestSent
-    const wastedMs = Math.round(nodeTiming.duration);
-    if (wastedMs < MINIMUM_WASTED_MS) {
-      continue;
-    }
-
-    requestIdToWastedMs.set(node.id, wastedMs);
-  }
-
-  if (requestIdToWastedMs.size) {
-    metricSavings.FCP = estimateSavingsWithGraphs(deferredNodeIds, context.lantern);
-
-    // In most cases, render blocking resources only affect LCP if LCP isn't an image.
-    if (!hasImageLCP(data, context)) {
-      metricSavings.LCP = metricSavings.FCP;
-    }
-  }
-
-  return {metricSavings, requestIdToWastedMs};
-}
-
-function finalize(partialModel: PartialInsightModel<RenderBlockingInsightModel>): RenderBlockingInsightModel {
-  return {
-    insightKey: InsightKeys.RENDER_BLOCKING,
-    strings: UIStrings,
-    title: i18nString(UIStrings.title),
-    description: i18nString(UIStrings.description),
-    docs: 'https://developer.chrome.com/docs/performance/insights/render-blocking',
-    category: InsightCategory.LCP,
-    state: partialModel.renderBlockingRequests.length > 0 ? 'fail' : 'pass',
-    ...partialModel,
-  };
-}
-
-export function generateInsight(
-    data: Handlers.Types.HandlerData, context: InsightSetContext): RenderBlockingInsightModel {
-  if (!context.navigation) {
-    return finalize({
-      renderBlockingRequests: [],
-    });
-  }
-
-  const firstPaintTs = data.PageLoadMetrics.metricScoresByFrameId.get(context.frameId)
-                           ?.get(context.navigationId)
-                           ?.get(Handlers.ModelHandlers.PageLoadMetrics.MetricName.FP)
-                           ?.event?.ts;
-  if (!firstPaintTs) {
-    return finalize({
-      renderBlockingRequests: [],
-      warnings: [InsightWarning.NO_FP],
-    });
-  }
-
-  let renderBlockingRequests: Types.Events.SyntheticNetworkRequest[] = [];
-  for (const req of data.NetworkRequests.byTime) {
-    if (req.args.data.frame !== context.frameId) {
-      continue;
-    }
-
-    if (!Helpers.Network.isSyntheticNetworkRequestEventRenderBlocking(req)) {
-      continue;
-    }
-
-    if (req.args.data.syntheticData.finishTime > firstPaintTs) {
-      continue;
-    }
-
-    // If a request is marked `in_body_parser_blocking` it should only be considered render blocking if it is a
-    // high enough priority. Some requests (e.g. scripts) are not marked as high priority if they are fetched
-    // after a non-preloaded image. (See "early" definition in https://web.dev/articles/fetch-priority)
-    //
-    // There are edge cases and exceptions (e.g. priority hints) but this gives us the best approximation
-    // of render blocking resources in the document body.
-    if (req.args.data.renderBlocking === 'in_body_parser_blocking') {
-      const priority = req.args.data.priority;
-      const isScript = req.args.data.resourceType === Protocol.Network.ResourceType.Script;
-      const isBlockingScript = isScript && priority === Protocol.Network.ResourcePriority.High;
-      if (priority !== Protocol.Network.ResourcePriority.VeryHigh && !isBlockingScript) {
-        continue;
-      }
-    }
-
-    const navigation = Helpers.Trace.getNavigationForTraceEvent(req, context.frameId, data.Meta.navigationsByFrameId);
-    if (navigation === context.navigation) {
-      renderBlockingRequests.push(req);
-    }
-  }
-
-  const savings = computeSavings(data, context, renderBlockingRequests);
-
-  // Sort by request duration for insights.
-  renderBlockingRequests = renderBlockingRequests.sort((a, b) => {
-    return b.dur - a.dur;
-  });
-
-  return finalize({
-    relatedEvents: renderBlockingRequests,
-    renderBlockingRequests,
-    ...savings,
-  });
-}
-
-export function createOverlayForRequest(request: Types.Events.SyntheticNetworkRequest): Types.Overlays.EntryOutline {
-  return {
-    type: 'ENTRY_OUTLINE',
-    entry: request,
-    outlineReason: 'ERROR',
-  };
-}
-
-export function createOverlays(model: RenderBlockingInsightModel): Types.Overlays.Overlay[] {
-  return model.renderBlockingRequests.map(request => createOverlayForRequest(request));
-}

package/lib/front_end/models/trace/insights/SlowCSSSelector.ts

@@ -1,175 +0,0 @@
-// Copyright 2024 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 i18n from '../../../core/i18n/i18n.js';
-import type * as Handlers from '../handlers/handlers.js';
-import type {SelectorStatsData} from '../handlers/SelectorStatsHandler.js';
-import * as Helpers from '../helpers/helpers.js';
-import {type SelectorTiming, SelectorTimingsKey} from '../types/TraceEvents.js';
-import * as Types from '../types/types.js';
-
-import {
-  InsightCategory,
-  InsightKeys,
-  type InsightModel,
-  type InsightSetContext,
-  type PartialInsightModel,
-} from './types.js';
-
-export const UIStrings = {
-  /**
-   * @description Title of an insight that provides details about slow CSS selectors.
-   */
-  title: 'CSS Selector costs',
-
-  /**
-   * @description Text to describe how to improve the performance of CSS selectors.
-   */
-  description:
-      'If Recalculate Style costs remain high, selector optimization can reduce them. [Optimize the selectors](https://developer.chrome.com/docs/performance/insights/slow-css-selector) with both high elapsed time and high slow-path %. Simpler selectors, fewer selectors, a smaller DOM, and a shallower DOM will all reduce matching costs.',
-  /**
-   * @description Column name for count of elements that the engine attempted to match against a style rule
-   */
-  matchAttempts: 'Match attempts',
-  /**
-   * @description Column name for count of elements that matched a style rule
-   */
-  matchCount: 'Match count',
-  /**
-   * @description Column name for elapsed time spent computing a style rule
-   */
-  elapsed: 'Elapsed time',
-  /**
-   * @description Column name for the selectors that took the longest amount of time/effort.
-   */
-  topSelectors: 'Top selectors',
-  /**
-   * @description Column name for a total sum.
-   */
-  total: 'Total',
-  /**
-   * @description Text status indicating that no CSS selector data was found.
-   */
-  enableSelectorData:
-      'No CSS selector data was found. CSS selector stats need to be enabled in the performance panel settings.',
-  /**
-   * @description top CSS selector when ranked by elapsed time in ms
-   */
-  topSelectorElapsedTime: 'Top selector elapsed time',
-  /**
-   * @description top CSS selector when ranked by match attempt
-   */
-  topSelectorMatchAttempt: 'Top selector match attempt',
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/SlowCSSSelector.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-const slowCSSSelectorThreshold = 500;  // 500us threshold for slow selectors
-
-export type SlowCSSSelectorInsightModel = InsightModel<typeof UIStrings, {
-  totalElapsedMs: Types.Timing.Milli,
-  totalMatchAttempts: number,
-  totalMatchCount: number,
-  topSelectorElapsedMs: Types.Events.SelectorTiming | null,
-  topSelectorMatchAttempts: Types.Events.SelectorTiming | null,
-}>;
-
-function aggregateSelectorStats(data: SelectorStatsData, context: InsightSetContext): SelectorTiming[] {
-  const selectorMap = new Map<String, SelectorTiming>();
-
-  for (const [event, value] of data.dataForRecalcStyleEvent) {
-    if (event.args.beginData?.frame !== context.frameId) {
-      continue;
-    }
-    if (!Helpers.Timing.eventIsInBounds(event, context.bounds)) {
-      continue;
-    }
-    for (const timing of value.timings) {
-      const key = timing[SelectorTimingsKey.Selector] + '_' + timing[SelectorTimingsKey.StyleSheetId];
-      const findTiming = selectorMap.get(key);
-      if (findTiming !== undefined) {
-        findTiming[SelectorTimingsKey.Elapsed] += timing[SelectorTimingsKey.Elapsed];
-        findTiming[SelectorTimingsKey.FastRejectCount] += timing[SelectorTimingsKey.FastRejectCount];
-        findTiming[SelectorTimingsKey.MatchAttempts] += timing[SelectorTimingsKey.MatchAttempts];
-        findTiming[SelectorTimingsKey.MatchCount] += timing[SelectorTimingsKey.MatchCount];
-      } else {
-        selectorMap.set(key, {...timing});
-      }
-    }
-  }
-
-  return [...selectorMap.values()];
-}
-
-function finalize(partialModel: PartialInsightModel<SlowCSSSelectorInsightModel>): SlowCSSSelectorInsightModel {
-  return {
-    insightKey: InsightKeys.SLOW_CSS_SELECTOR,
-    strings: UIStrings,
-    title: i18nString(UIStrings.title),
-    description: i18nString(UIStrings.description),
-    docs: 'https://developer.chrome.com/docs/performance/insights/slow-css-selector',
-    category: InsightCategory.ALL,
-    state: partialModel.topSelectorElapsedMs && partialModel.topSelectorMatchAttempts ? 'informative' : 'pass',
-    ...partialModel,
-  };
-}
-
-export function isSlowCSSSelectorInsight(model: InsightModel): model is SlowCSSSelectorInsightModel {
-  return model.insightKey === InsightKeys.SLOW_CSS_SELECTOR;
-}
-
-export function generateInsight(
-    data: Handlers.Types.HandlerData, context: InsightSetContext): SlowCSSSelectorInsightModel {
-  const selectorStatsData = data.SelectorStats;
-
-  if (!selectorStatsData) {
-    throw new Error('no selector stats data');
-  }
-
-  const selectorTimings = aggregateSelectorStats(selectorStatsData, context);
-
-  let totalElapsedUs = 0;
-  let totalMatchAttempts = 0;
-  let totalMatchCount = 0;
-
-  selectorTimings.map(timing => {
-    totalElapsedUs += timing[SelectorTimingsKey.Elapsed];
-    totalMatchAttempts += timing[SelectorTimingsKey.MatchAttempts];
-    totalMatchCount += timing[SelectorTimingsKey.MatchCount];
-  });
-
-  let topSelectorElapsedMs: SelectorTiming|null = null;
-  let topSelectorMatchAttempts: SelectorTiming|null = null;
-
-  if (selectorTimings.length > 0) {
-    // find the selector with most elapsed time
-    topSelectorElapsedMs = selectorTimings.reduce((a, b) => {
-      return a[SelectorTimingsKey.Elapsed] > b[SelectorTimingsKey.Elapsed] ? a : b;
-    });
-
-    // check if the slowest selector is slow enough to trigger insights info
-    if (topSelectorElapsedMs && topSelectorElapsedMs[SelectorTimingsKey.Elapsed] < slowCSSSelectorThreshold) {
-      topSelectorElapsedMs = null;
-    }
-
-    // find the selector with most match attempts
-    topSelectorMatchAttempts = selectorTimings.reduce((a, b) => {
-      return a[SelectorTimingsKey.MatchAttempts] > b[SelectorTimingsKey.MatchAttempts] ? a : b;
-    });
-  }
-
-  return finalize({
-    // TODO: should we identify RecalcStyle events as linked to this insight?
-    relatedEvents: [],
-    totalElapsedMs: Types.Timing.Milli(totalElapsedUs / 1000.0),
-    totalMatchAttempts,
-    totalMatchCount,
-    topSelectorElapsedMs,
-    topSelectorMatchAttempts,
-  });
-}
-
-export function createOverlays(_: SlowCSSSelectorInsightModel): Types.Overlays.Overlay[] {
-  return [];
-}

package/lib/front_end/models/trace/insights/Statistics.ts

@@ -1,101 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Lifted from Lighthouse: https://github.com/GoogleChrome/lighthouse/blob/36cac182a6c637b1671c57326d7c0241633d0076/shared/statistics.js
-
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// The exact double values for the max and min scores possible in each range.
-const MIN_PASSING_SCORE = 0.90000000000000002220446049250313080847263336181640625;
-const MAX_AVERAGE_SCORE = 0.899999999999999911182158029987476766109466552734375;
-const MIN_AVERAGE_SCORE = 0.5;
-const MAX_FAILING_SCORE = 0.499999999999999944488848768742172978818416595458984375;
-
-/**
- * Approximates the Gauss error function, the probability that a random variable
- * from the standard normal distribution lies within [-x, x]. Moved from
- * traceviewer.b.math.erf, based on Abramowitz and Stegun, formula 7.1.26.
- */
-function erf(x: number): number {
-  // erf(-x) = -erf(x);
-  const sign = Math.sign(x);
-  x = Math.abs(x);
-
-  const a1 = 0.254829592;
-  const a2 = -0.284496736;
-  const a3 = 1.421413741;
-  const a4 = -1.453152027;
-  const a5 = 1.061405429;
-  const p = 0.3275911;
-  const t = 1 / (1 + p * x);
-  const y = t * (a1 + t * (a2 + t * (a3 + t * (a4 + t * a5))));
-  return sign * (1 - y * Math.exp(-x * x));
-}
-
-/**
- * Returns the score (1 - percentile) of `value` in a log-normal distribution
- * specified by the `median` value, at which the score will be 0.5, and a 10th
- * percentile value, at which the score will be 0.9. The score represents the
- * amount of the distribution greater than `value`. All values should be in the
- * same units (e.g. milliseconds). See
- *   https://www.desmos.com/calculator/o98tbeyt1t
- * for an interactive view of the relationship between these parameters and the
- * typical parameterization (location and shape) of the log-normal distribution.
- */
-export function getLogNormalScore({median, p10}: {median: number, p10: number}, value: number): number {
-  // Required for the log-normal distribution.
-  if (median <= 0) {
-    throw new Error('median must be greater than zero');
-  }
-  if (p10 <= 0) {
-    throw new Error('p10 must be greater than zero');
-  }
-  // Not strictly required, but if p10 > median, it flips around and becomes the p90 point.
-  if (p10 >= median) {
-    throw new Error('p10 must be less than the median');
-  }
-
-  // Non-positive values aren't in the distribution, so always 1.
-  if (value <= 0) {
-    return 1;
-  }
-
-  // Closest double to `erfc-1(1/5)`.
-  const INVERSE_ERFC_ONE_FIFTH = 0.9061938024368232;
-
-  // Shape (σ) is `|log(p10/median) / (sqrt(2)*erfc^-1(1/5))|` and
-  // standardizedX is `1/2 erfc(log(value/median) / (sqrt(2)*σ))`, so simplify a bit.
-  const xRatio = Math.max(Number.MIN_VALUE, value / median);  // value and median are > 0, so is ratio.
-  const xLogRatio = Math.log(xRatio);
-  const p10Ratio = Math.max(Number.MIN_VALUE, p10 / median);  // p10 and median are > 0, so is ratio.
-  const p10LogRatio = -Math.log(p10Ratio);                    // negate to keep σ positive.
-  const standardizedX = xLogRatio * INVERSE_ERFC_ONE_FIFTH / p10LogRatio;
-  const complementaryPercentile = (1 - erf(standardizedX)) / 2;
-
-  // Clamp to avoid floating-point out-of-bounds issues and keep score in expected range.
-  let score;
-  if (value <= p10) {
-    // Passing. Clamp to [0.9, 1].
-    score = Math.max(MIN_PASSING_SCORE, Math.min(1, complementaryPercentile));
-  } else if (value <= median) {
-    // Average. Clamp to [0.5, 0.9).
-    score = Math.max(MIN_AVERAGE_SCORE, Math.min(MAX_AVERAGE_SCORE, complementaryPercentile));
-  } else {
-    // Failing. Clamp to [0, 0.5).
-    score = Math.max(0, Math.min(MAX_FAILING_SCORE, complementaryPercentile));
-  }
-  return score;
-}
-
-/**
- * Interpolates the y value at a point x on the line defined by (x0, y0) and (x1, y1)
- */
-export function linearInterpolation(x0: number, y0: number, x1: number, y1: number, x: number): number {
-  const slope = (y1 - y0) / (x1 - x0);
-  return y0 + (x - x0) * slope;
-}

package/lib/front_end/models/trace/insights/ThirdParties.ts

@@ -1,130 +0,0 @@
-// Copyright 2024 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 i18n from '../../../core/i18n/i18n.js';
-import * as ThirdPartyWeb from '../../../third_party/third-party-web/third-party-web.js';
-import * as Extras from '../extras/extras.js';
-import * as Handlers from '../handlers/handlers.js';
-import type * as Types from '../types/types.js';
-
-import {
-  InsightCategory,
-  InsightKeys,
-  type InsightModel,
-  type InsightSetContext,
-  type PartialInsightModel,
-} from './types.js';
-
-export const UIStrings = {
-  /** Title of an insight that provides details about the code on a web page that the user doesn't control (referred to as "third-party code"). */
-  title: '3rd parties',
-  /**
-   * @description Description of a DevTools insight that identifies the code on the page that the user doesn't control.
-   * This is displayed after a user expands the section to see more. No character length limits.
-   */
-  description: '3rd party code can significantly impact load performance. ' +
-      '[Reduce and defer loading of 3rd party code](https://developer.chrome.com/docs/performance/insights/third-parties) to prioritize your page\'s content.',
-  /** Label for a table column that displays the name of a third-party provider. */
-  columnThirdParty: '3rd party',
-  /** Label for a column in a data table; entries will be the download size of a web resource in kilobytes. */
-  columnTransferSize: 'Transfer size',
-  /** Label for a table column that displays how much time each row spent running on the main thread, entries will be the number of milliseconds spent. */
-  columnMainThreadTime: 'Main thread time',
-  /**
-   * @description Text block indicating that no third party content was detected on the page
-   */
-  noThirdParties: 'No third parties found',
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/ThirdParties.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export type ThirdPartiesInsightModel = InsightModel<typeof UIStrings, {
-  /** The entity for this navigation's URL. Any other entity is from a third party. */
-  entitySummaries: Extras.ThirdParties.EntitySummary[],
-  firstPartyEntity?: Extras.ThirdParties.Entity,
-}>;
-
-function getRelatedEvents(
-    summaries: Extras.ThirdParties.EntitySummary[],
-    firstPartyEntity: Extras.ThirdParties.Entity|undefined): Types.Events.Event[] {
-  const relatedEvents = [];
-  for (const summary of summaries) {
-    if (summary.entity !== firstPartyEntity) {
-      relatedEvents.push(...summary.relatedEvents);
-    }
-  }
-
-  return relatedEvents;
-}
-
-function finalize(partialModel: PartialInsightModel<ThirdPartiesInsightModel>): ThirdPartiesInsightModel {
-  return {
-    insightKey: InsightKeys.THIRD_PARTIES,
-    strings: UIStrings,
-    title: i18nString(UIStrings.title),
-    description: i18nString(UIStrings.description),
-    docs: 'https://developer.chrome.com/docs/performance/insights/third-parties',
-    category: InsightCategory.ALL,
-    state: partialModel.entitySummaries.find(summary => summary.entity !== partialModel.firstPartyEntity) ?
-        'informative' :
-        'pass',
-    ...partialModel,
-  };
-}
-
-export function isThirdPartyInsight(model: InsightModel): model is ThirdPartiesInsightModel {
-  return model.insightKey === InsightKeys.THIRD_PARTIES;
-}
-
-export function generateInsight(
-    data: Handlers.Types.HandlerData, context: InsightSetContext): ThirdPartiesInsightModel {
-  const entitySummaries = Extras.ThirdParties.summarizeByThirdParty(data as Handlers.Types.HandlerData, context.bounds);
-
-  const firstPartyUrl = context.navigation?.args.data?.documentLoaderURL ?? data.Meta.mainFrameURL;
-  const firstPartyEntity = ThirdPartyWeb.ThirdPartyWeb.getEntity(firstPartyUrl) ||
-      Handlers.Helpers.makeUpEntity(data.Renderer.entityMappings.createdEntityCache, firstPartyUrl);
-
-  return finalize({
-    relatedEvents: getRelatedEvents(entitySummaries, firstPartyEntity),
-    firstPartyEntity,
-    entitySummaries,
-  });
-}
-
-export function createOverlaysForSummary(summary: Extras.ThirdParties.EntitySummary): Types.Overlays.Overlay[] {
-  const overlays = [];
-  for (const event of summary.relatedEvents) {
-    // The events found for a third party can be vast, as they gather every
-    // single main thread task along with everything else on the page. If the
-    // main thread is busy with large icicles, we can easily create tens of
-    // thousands of overlays. Therefore, only create overlays for events of at least 1ms.
-    if (event.dur === undefined || event.dur < 1_000) {
-      continue;
-    }
-
-    const overlay: Types.Overlays.Overlay = {
-      type: 'ENTRY_OUTLINE',
-      entry: event,
-      outlineReason: 'INFO',
-    };
-    overlays.push(overlay);
-  }
-  return overlays;
-}
-
-export function createOverlays(model: ThirdPartiesInsightModel): Types.Overlays.Overlay[] {
-  const overlays: Types.Overlays.Overlay[] = [];
-  const summaries = model.entitySummaries ?? [];
-  for (const summary of summaries) {
-    if (summary.entity === model.firstPartyEntity) {
-      continue;
-    }
-
-    const summaryOverlays = createOverlaysForSummary(summary);
-    overlays.push(...summaryOverlays);
-  }
-
-  return overlays;
-}