@paulirish/trace_engine 0.0.8 → 0.0.10

package/models/trace/handlers/LayoutShiftsHandler.js

@@ -0,0 +1,270 @@
+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";
+import { ScoreClassification } from "./PageLoadMetricsHandler.js";
+import { HandlerState } from "./types.js";
+export const MAX_CLUSTER_DURATION = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(5e3));
+export const MAX_SHIFT_TIME_DELTA = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(1e3));
+const layoutShiftEvents = [];
+const layoutInvalidationEvents = [];
+const scheduleStyleInvalidationEvents = [];
+const styleRecalcInvalidationEvents = [];
+const backendNodeIds = /* @__PURE__ */ new Set();
+const prePaintEvents = [];
+let sessionMaxScore = 0;
+let clsWindowID = -1;
+const clusters = [];
+const scoreRecords = [];
+let handlerState = HandlerState.UNINITIALIZED;
+export function initialize() {
+  if (handlerState !== HandlerState.UNINITIALIZED) {
+    throw new Error("LayoutShifts Handler was not reset");
+  }
+  handlerState = HandlerState.INITIALIZED;
+}
+export function reset() {
+  handlerState = HandlerState.UNINITIALIZED;
+  layoutShiftEvents.length = 0;
+  layoutInvalidationEvents.length = 0;
+  scheduleStyleInvalidationEvents.length = 0;
+  styleRecalcInvalidationEvents.length = 0;
+  prePaintEvents.length = 0;
+  backendNodeIds.clear();
+  clusters.length = 0;
+  sessionMaxScore = 0;
+  scoreRecords.length = 0;
+  clsWindowID = -1;
+}
+export function handleEvent(event) {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("Handler is not initialized");
+  }
+  if (Types.TraceEvents.isTraceEventLayoutShift(event) && !event.args.data?.had_recent_input) {
+    layoutShiftEvents.push(event);
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventLayoutInvalidationTracking(event)) {
+    layoutInvalidationEvents.push(event);
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventScheduleStyleInvalidationTracking(event)) {
+    scheduleStyleInvalidationEvents.push(event);
+  }
+  if (Types.TraceEvents.isTraceEventStyleRecalcInvalidationTracking(event)) {
+    styleRecalcInvalidationEvents.push(event);
+  }
+  if (Types.TraceEvents.isTraceEventPrePaint(event)) {
+    prePaintEvents.push(event);
+    return;
+  }
+}
+function traceWindowFromTime(time) {
+  return {
+    min: time,
+    max: time,
+    range: Types.Timing.MicroSeconds(0)
+  };
+}
+function updateTraceWindowMax(traceWindow, newMax) {
+  traceWindow.max = newMax;
+  traceWindow.range = Types.Timing.MicroSeconds(traceWindow.max - traceWindow.min);
+}
+function buildScoreRecords() {
+  const { traceBounds } = metaHandlerData();
+  scoreRecords.push({ ts: traceBounds.min, score: 0 });
+  for (const cluster of clusters) {
+    let clusterScore = 0;
+    if (cluster.events[0].args.data) {
+      scoreRecords.push({ ts: cluster.clusterWindow.min, score: cluster.events[0].args.data.weighted_score_delta });
+    }
+    for (let i = 0; i < cluster.events.length; i++) {
+      const event = cluster.events[i];
+      if (!event.args.data) {
+        continue;
+      }
+      clusterScore += event.args.data.weighted_score_delta;
+      scoreRecords.push({ ts: event.ts, score: clusterScore });
+    }
+    scoreRecords.push({ ts: cluster.clusterWindow.max, score: 0 });
+  }
+}
+function collectNodes() {
+  backendNodeIds.clear();
+  for (const layoutShift of layoutShiftEvents) {
+    if (!layoutShift.args.data?.impacted_nodes) {
+      continue;
+    }
+    for (const node of layoutShift.args.data.impacted_nodes) {
+      backendNodeIds.add(node.node_id);
+    }
+  }
+  for (const layoutInvalidation of layoutInvalidationEvents) {
+    if (!layoutInvalidation.args.data?.nodeId) {
+      continue;
+    }
+    backendNodeIds.add(layoutInvalidation.args.data.nodeId);
+  }
+  for (const scheduleStyleInvalidation of scheduleStyleInvalidationEvents) {
+    if (!scheduleStyleInvalidation.args.data?.nodeId) {
+      continue;
+    }
+    backendNodeIds.add(scheduleStyleInvalidation.args.data.nodeId);
+  }
+}
+export async function finalize() {
+  layoutShiftEvents.sort((a, b) => a.ts - b.ts);
+  prePaintEvents.sort((a, b) => a.ts - b.ts);
+  layoutInvalidationEvents.sort((a, b) => a.ts - b.ts);
+  await buildLayoutShiftsClusters();
+  buildScoreRecords();
+  collectNodes();
+  handlerState = HandlerState.FINALIZED;
+}
+async function buildLayoutShiftsClusters() {
+  const { navigationsByFrameId, mainFrameId, traceBounds } = metaHandlerData();
+  const navigations = navigationsByFrameId.get(mainFrameId) || [];
+  if (layoutShiftEvents.length === 0) {
+    return;
+  }
+  let firstShiftTime = layoutShiftEvents[0].ts;
+  let lastShiftTime = layoutShiftEvents[0].ts;
+  let lastShiftNavigation = null;
+  for (const event of layoutShiftEvents) {
+    const clusterDurationExceeded = event.ts - firstShiftTime > MAX_CLUSTER_DURATION;
+    const maxTimeDeltaSinceLastShiftExceeded = event.ts - lastShiftTime > MAX_SHIFT_TIME_DELTA;
+    const currentShiftNavigation = Platform.ArrayUtilities.nearestIndexFromEnd(navigations, (nav) => nav.ts < event.ts);
+    const hasNavigated = lastShiftNavigation !== currentShiftNavigation && currentShiftNavigation !== null;
+    if (clusterDurationExceeded || maxTimeDeltaSinceLastShiftExceeded || hasNavigated || !clusters.length) {
+      const clusterStartTime = event.ts;
+      const endTimeByMaxSessionDuration = clusterDurationExceeded ? firstShiftTime + MAX_CLUSTER_DURATION : Infinity;
+      const endTimeByMaxShiftGap = maxTimeDeltaSinceLastShiftExceeded ? lastShiftTime + MAX_SHIFT_TIME_DELTA : Infinity;
+      const endTimeByNavigation = hasNavigated ? navigations[currentShiftNavigation].ts : Infinity;
+      const previousClusterEndTime = Math.min(endTimeByMaxSessionDuration, endTimeByMaxShiftGap, endTimeByNavigation);
+      if (clusters.length > 0) {
+        const currentCluster2 = clusters[clusters.length - 1];
+        updateTraceWindowMax(currentCluster2.clusterWindow, Types.Timing.MicroSeconds(previousClusterEndTime));
+      }
+      clusters.push({
+        events: [],
+        clusterWindow: traceWindowFromTime(clusterStartTime),
+        clusterCumulativeScore: 0,
+        scoreWindows: {
+          good: traceWindowFromTime(clusterStartTime),
+          needsImprovement: null,
+          bad: null
+        }
+      });
+      firstShiftTime = clusterStartTime;
+    }
+    const currentCluster = clusters[clusters.length - 1];
+    const timeFromNavigation = currentShiftNavigation !== null ? Types.Timing.MicroSeconds(event.ts - navigations[currentShiftNavigation].ts) : void 0;
+    currentCluster.clusterCumulativeScore += event.args.data ? event.args.data.weighted_score_delta : 0;
+    if (!event.args.data) {
+      continue;
+    }
+    const shift = {
+      ...event,
+      args: {
+        frame: event.args.frame,
+        data: {
+          ...event.args.data,
+          rawEvent: event
+        }
+      },
+      parsedData: {
+        timeFromNavigation,
+        cumulativeWeightedScoreInWindow: currentCluster.clusterCumulativeScore,
+        sessionWindowData: { cumulativeWindowScore: 0, id: clusters.length }
+      }
+    };
+    currentCluster.events.push(shift);
+    updateTraceWindowMax(currentCluster.clusterWindow, event.ts);
+    lastShiftTime = event.ts;
+    lastShiftNavigation = currentShiftNavigation;
+  }
+  for (const cluster of clusters) {
+    let weightedScore = 0;
+    let windowID = -1;
+    if (cluster === clusters[clusters.length - 1]) {
+      const clusterEndByMaxDuration = MAX_CLUSTER_DURATION + cluster.clusterWindow.min;
+      const clusterEndByMaxGap = cluster.clusterWindow.max + MAX_SHIFT_TIME_DELTA;
+      const nextNavigationIndex = Platform.ArrayUtilities.nearestIndexFromBeginning(navigations, (nav) => nav.ts > cluster.clusterWindow.max);
+      const nextNavigationTime = nextNavigationIndex ? navigations[nextNavigationIndex].ts : Infinity;
+      const clusterEnd = Math.min(clusterEndByMaxDuration, clusterEndByMaxGap, traceBounds.max, nextNavigationTime);
+      updateTraceWindowMax(cluster.clusterWindow, Types.Timing.MicroSeconds(clusterEnd));
+    }
+    for (const shift of cluster.events) {
+      weightedScore += shift.args.data ? shift.args.data.weighted_score_delta : 0;
+      windowID = shift.parsedData.sessionWindowData.id;
+      const ts = shift.ts;
+      shift.parsedData.sessionWindowData.cumulativeWindowScore = cluster.clusterCumulativeScore;
+      if (weightedScore < LayoutShiftsThreshold.NEEDS_IMPROVEMENT) {
+        updateTraceWindowMax(cluster.scoreWindows.good, ts);
+      } else if (weightedScore >= LayoutShiftsThreshold.NEEDS_IMPROVEMENT && weightedScore < LayoutShiftsThreshold.BAD) {
+        if (!cluster.scoreWindows.needsImprovement) {
+          updateTraceWindowMax(cluster.scoreWindows.good, Types.Timing.MicroSeconds(ts - 1));
+          cluster.scoreWindows.needsImprovement = traceWindowFromTime(ts);
+        }
+        updateTraceWindowMax(cluster.scoreWindows.needsImprovement, ts);
+      } else if (weightedScore >= LayoutShiftsThreshold.BAD) {
+        if (!cluster.scoreWindows.bad) {
+          if (cluster.scoreWindows.needsImprovement) {
+            updateTraceWindowMax(cluster.scoreWindows.needsImprovement, Types.Timing.MicroSeconds(ts - 1));
+          } else {
+            updateTraceWindowMax(cluster.scoreWindows.good, Types.Timing.MicroSeconds(ts - 1));
+          }
+          cluster.scoreWindows.bad = traceWindowFromTime(shift.ts);
+        }
+        updateTraceWindowMax(cluster.scoreWindows.bad, ts);
+      }
+      if (cluster.scoreWindows.bad) {
+        updateTraceWindowMax(cluster.scoreWindows.bad, cluster.clusterWindow.max);
+      } else if (cluster.scoreWindows.needsImprovement) {
+        updateTraceWindowMax(cluster.scoreWindows.needsImprovement, cluster.clusterWindow.max);
+      } else {
+        updateTraceWindowMax(cluster.scoreWindows.good, cluster.clusterWindow.max);
+      }
+    }
+    if (weightedScore > sessionMaxScore) {
+      clsWindowID = windowID;
+      sessionMaxScore = weightedScore;
+    }
+  }
+}
+export function data() {
+  if (handlerState !== HandlerState.FINALIZED) {
+    throw new Error("Layout Shifts Handler is not finalized");
+  }
+  return {
+    clusters: [...clusters],
+    sessionMaxScore,
+    clsWindowID,
+    prePaintEvents: [...prePaintEvents],
+    layoutInvalidationEvents: [...layoutInvalidationEvents],
+    scheduleStyleInvalidationEvents: [...scheduleStyleInvalidationEvents],
+    styleRecalcInvalidationEvents: [],
+    scoreRecords: [...scoreRecords],
+    backendNodeIds: [...backendNodeIds]
+  };
+}
+export function deps() {
+  return ["Screenshots", "Meta"];
+}
+export function stateForLayoutShiftScore(score) {
+  let state = ScoreClassification.GOOD;
+  if (score >= LayoutShiftsThreshold.NEEDS_IMPROVEMENT) {
+    state = ScoreClassification.OK;
+  }
+  if (score >= LayoutShiftsThreshold.BAD) {
+    state = ScoreClassification.BAD;
+  }
+  return state;
+}
+export var LayoutShiftsThreshold = /* @__PURE__ */ ((LayoutShiftsThreshold2) => {
+  LayoutShiftsThreshold2[LayoutShiftsThreshold2["GOOD"] = 0] = "GOOD";
+  LayoutShiftsThreshold2[LayoutShiftsThreshold2["NEEDS_IMPROVEMENT"] = 0.1] = "NEEDS_IMPROVEMENT";
+  LayoutShiftsThreshold2[LayoutShiftsThreshold2["BAD"] = 0.25] = "BAD";
+  return LayoutShiftsThreshold2;
+})(LayoutShiftsThreshold || {});
+//# sourceMappingURL=LayoutShiftsHandler.js.map

package/models/trace/handlers/LayoutShiftsHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/LayoutShiftsHandler.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Platform from '../../../core/platform/platform.js';\nimport type * as Protocol from '../../../generated/protocol.js';\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {data as metaHandlerData} from './MetaHandler.js';\nimport {ScoreClassification} from './PageLoadMetricsHandler.js';\nimport {HandlerState, type TraceEventHandlerName} from './types.js';\n\n// We start with a score of zero and step through all Layout Shift records from\n// all renderers. Each record not only tells us which renderer it is, but also\n// the unweighted and weighted scores. The unweighted score is the score we would\n// get if the renderer were the only one in the viewport. The weighted score, on\n// the other hand, accounts for how much of the viewport that particular render\n// takes up when the shift happened. An ad frame in the corner of the viewport\n// that shifts is considered less disruptive, therefore, than if it were taking\n// up the whole viewport.\n//\n// Next, we step through all the records from all renderers and add the weighted\n// score to a running total across all of the renderers. We create a new \"cluster\"\n// and reset the running total when:\n//\n// 1. We observe a outermost frame navigation, or\n// 2. When there's a gap between records of > 1s, or\n// 3. When there's more than 5 seconds of continuous layout shifting.\n//\n// Note that for it to be Cumulative Layout Shift in the sense described in the\n// documentation we would need to guarantee that we are tracking from navigation\n// to unload. However, we don't make any such guarantees here (since a developer\n// can record and stop when they please), so we support the cluster approach,\n// and we can give them a score, but it is effectively a \"session\" score, a\n// score for the given recording, and almost certainly not the\n// navigation-to-unload CLS score.\n\ninterface LayoutShifts {\n  clusters: LayoutShiftCluster[];\n  sessionMaxScore: number;\n  // The session window which contains the SessionMaxScore\n  clsWindowID: number;\n  // We use these to calculate root causes for a given LayoutShift\n  prePaintEvents: Types.TraceEvents.TraceEventPrePaint[];\n  layoutInvalidationEvents: Types.TraceEvents.TraceEventLayoutInvalidationTracking[];\n  scheduleStyleInvalidationEvents: Types.TraceEvents.TraceEventScheduleStyleInvalidationTracking[];\n  styleRecalcInvalidationEvents: Types.TraceEvents.TraceEventStyleRecalcInvalidationTracking[];\n  scoreRecords: ScoreRecord[];\n  backendNodeIds: Protocol.DOM.BackendNodeId[];\n}\n\n// This represents the maximum #time we will allow a cluster to go before we\n// reset it.\nexport const MAX_CLUSTER_DURATION = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(5000));\n\n// This represents the maximum #time we will allow between layout shift events\n// before considering it to be the start of a new cluster.\nexport const MAX_SHIFT_TIME_DELTA = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(1000));\n\n// Layout shifts are reported globally to the developer, irrespective of which\n// frame they originated in. However, each process does have its own individual\n// CLS score, so we need to segment by process. This means Layout Shifts from\n// sites with one process (no subframes, or subframes from the same origin)\n// will be reported together. In the case of multiple renderers (frames across\n// different origins), we offer the developer the ability to switch renderer in\n// the UI.\nconst layoutShiftEvents: Types.TraceEvents.TraceEventLayoutShift[] = [];\n\n// These events denote potential node resizings. We store them to link captured\n// layout shifts to the resizing of unsized elements.\nconst layoutInvalidationEvents: Types.TraceEvents.TraceEventLayoutInvalidationTracking[] = [];\nconst scheduleStyleInvalidationEvents: Types.TraceEvents.TraceEventScheduleStyleInvalidationTracking[] = [];\nconst styleRecalcInvalidationEvents: Types.TraceEvents.TraceEventStyleRecalcInvalidationTracking[] = [];\n\nconst backendNodeIds = new Set<Protocol.DOM.BackendNodeId>();\n\n// Layout shifts happen during PrePaint as part of the rendering lifecycle.\n// We determine if a LayoutInvalidation event is a potential root cause of a layout\n// shift if the next PrePaint after the LayoutInvalidation is the parent\n// node of such shift.\nconst prePaintEvents: Types.TraceEvents.TraceEventPrePaint[] = [];\n\nlet sessionMaxScore = 0;\n\nlet clsWindowID = -1;\n\nconst clusters: LayoutShiftCluster[] = [];\n\n// Represents a point in time in which a  LS score change\n// was recorded.\ntype ScoreRecord = {\n  ts: number,\n  score: number,\n};\n\n// The complete timeline of LS score changes in a trace.\n// Includes drops to 0 when session windows end.\nconst scoreRecords: ScoreRecord[] = [];\n\nlet handlerState = HandlerState.UNINITIALIZED;\n\nexport function initialize(): void {\n  if (handlerState !== HandlerState.UNINITIALIZED) {\n    throw new Error('LayoutShifts Handler was not reset');\n  }\n  handlerState = HandlerState.INITIALIZED;\n}\n\nexport function reset(): void {\n  handlerState = HandlerState.UNINITIALIZED;\n  layoutShiftEvents.length = 0;\n  layoutInvalidationEvents.length = 0;\n  scheduleStyleInvalidationEvents.length = 0;\n  styleRecalcInvalidationEvents.length = 0;\n  prePaintEvents.length = 0;\n  backendNodeIds.clear();\n  clusters.length = 0;\n  sessionMaxScore = 0;\n  scoreRecords.length = 0;\n  clsWindowID = -1;\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('Handler is not initialized');\n  }\n\n  if (Types.TraceEvents.isTraceEventLayoutShift(event) && !event.args.data?.had_recent_input) {\n    layoutShiftEvents.push(event);\n    return;\n  }\n  if (Types.TraceEvents.isTraceEventLayoutInvalidationTracking(event)) {\n    layoutInvalidationEvents.push(event);\n    return;\n  }\n  if (Types.TraceEvents.isTraceEventScheduleStyleInvalidationTracking(event)) {\n    scheduleStyleInvalidationEvents.push(event);\n  }\n  if (Types.TraceEvents.isTraceEventStyleRecalcInvalidationTracking(event)) {\n    styleRecalcInvalidationEvents.push(event);\n  }\n  if (Types.TraceEvents.isTraceEventPrePaint(event)) {\n    prePaintEvents.push(event);\n    return;\n  }\n}\n\nfunction traceWindowFromTime(time: Types.Timing.MicroSeconds): Types.Timing.TraceWindowMicroSeconds {\n  return {\n    min: time,\n    max: time,\n    range: Types.Timing.MicroSeconds(0),\n  };\n}\n\nfunction updateTraceWindowMax(\n    traceWindow: Types.Timing.TraceWindowMicroSeconds, newMax: Types.Timing.MicroSeconds): void {\n  traceWindow.max = newMax;\n  traceWindow.range = Types.Timing.MicroSeconds(traceWindow.max - traceWindow.min);\n}\n\nfunction buildScoreRecords(): void {\n  const {traceBounds} = metaHandlerData();\n  scoreRecords.push({ts: traceBounds.min, score: 0});\n\n  for (const cluster of clusters) {\n    let clusterScore = 0;\n    if (cluster.events[0].args.data) {\n      scoreRecords.push({ts: cluster.clusterWindow.min, score: cluster.events[0].args.data.weighted_score_delta});\n    }\n    for (let i = 0; i < cluster.events.length; i++) {\n      const event = cluster.events[i];\n      if (!event.args.data) {\n        continue;\n      }\n      clusterScore += event.args.data.weighted_score_delta;\n      scoreRecords.push({ts: event.ts, score: clusterScore});\n    }\n    scoreRecords.push({ts: cluster.clusterWindow.max, score: 0});\n  }\n}\n\n/**\n * Collects backend node ids coming from LayoutShift and LayoutInvalidation\n * events.\n */\nfunction collectNodes(): void {\n  backendNodeIds.clear();\n\n  // Collect the node ids present in the shifts.\n  for (const layoutShift of layoutShiftEvents) {\n    if (!layoutShift.args.data?.impacted_nodes) {\n      continue;\n    }\n    for (const node of layoutShift.args.data.impacted_nodes) {\n      backendNodeIds.add(node.node_id);\n    }\n  }\n\n  // Collect the node ids present in LayoutInvalidation & scheduleStyleInvalidation events.\n  for (const layoutInvalidation of layoutInvalidationEvents) {\n    if (!layoutInvalidation.args.data?.nodeId) {\n      continue;\n    }\n    backendNodeIds.add(layoutInvalidation.args.data.nodeId);\n  }\n  for (const scheduleStyleInvalidation of scheduleStyleInvalidationEvents) {\n    if (!scheduleStyleInvalidation.args.data?.nodeId) {\n      continue;\n    }\n    backendNodeIds.add(scheduleStyleInvalidation.args.data.nodeId);\n  }\n}\n\nexport async function finalize(): Promise<void> {\n  // Ensure the events are sorted by #time ascending.\n  layoutShiftEvents.sort((a, b) => a.ts - b.ts);\n  prePaintEvents.sort((a, b) => a.ts - b.ts);\n  layoutInvalidationEvents.sort((a, b) => a.ts - b.ts);\n\n  // Each function transforms the data used by the next, as such the invoke order\n  // is important.\n  await buildLayoutShiftsClusters();\n  buildScoreRecords();\n  collectNodes();\n  handlerState = HandlerState.FINALIZED;\n}\n\nasync function buildLayoutShiftsClusters(): Promise<void> {\n  const {navigationsByFrameId, mainFrameId, traceBounds} = metaHandlerData();\n  const navigations = navigationsByFrameId.get(mainFrameId) || [];\n  if (layoutShiftEvents.length === 0) {\n    return;\n  }\n  let firstShiftTime = layoutShiftEvents[0].ts;\n  let lastShiftTime = layoutShiftEvents[0].ts;\n  let lastShiftNavigation = null;\n  // Now step through each and create clusters.\n  // A cluster is equivalent to a session window (see https://web.dev/cls/#what-is-cls).\n  // To make the line chart clear, we explicitly demark the limits of each session window\n  // by starting the cumulative score of the window at the time of the first layout shift\n  // and ending it (dropping the line back to 0) when the window ends according to the\n  // thresholds (MAX_CLUSTER_DURATION, MAX_SHIFT_TIME_DELTA).\n  for (const event of layoutShiftEvents) {\n    // First detect if either the cluster duration or the #time between this and\n    // the last shift has been exceeded.\n    const clusterDurationExceeded = event.ts - firstShiftTime > MAX_CLUSTER_DURATION;\n    const maxTimeDeltaSinceLastShiftExceeded = event.ts - lastShiftTime > MAX_SHIFT_TIME_DELTA;\n\n    // Next take a look at navigations. If between this and the last shift we have navigated,\n    // note it.\n    const currentShiftNavigation = Platform.ArrayUtilities.nearestIndexFromEnd(navigations, nav => nav.ts < event.ts);\n    const hasNavigated = lastShiftNavigation !== currentShiftNavigation && currentShiftNavigation !== null;\n\n    // If any of the above criteria are met or if we don't have any cluster yet we should\n    // start a new one.\n    if (clusterDurationExceeded || maxTimeDeltaSinceLastShiftExceeded || hasNavigated || !clusters.length) {\n      // The cluster starts #time should be the timestamp of the first layout shift in it.\n      const clusterStartTime = event.ts;\n\n      // If the last session window ended because the max delta time between shifts\n      // was exceeded set the endtime to MAX_SHIFT_TIME_DELTA microseconds after the\n      // last shift in the session.\n      const endTimeByMaxSessionDuration = clusterDurationExceeded ? firstShiftTime + MAX_CLUSTER_DURATION : Infinity;\n\n      // If the last session window ended because the max session duration was\n      // surpassed, set the endtime so that the window length = MAX_CLUSTER_DURATION;\n      const endTimeByMaxShiftGap = maxTimeDeltaSinceLastShiftExceeded ? lastShiftTime + MAX_SHIFT_TIME_DELTA : Infinity;\n\n      // If there was a navigation during the last window, close it at the time\n      // of the navigation.\n      const endTimeByNavigation = hasNavigated ? navigations[currentShiftNavigation].ts : Infinity;\n\n      // End the previous cluster at the time of the first of the criteria above that was met.\n      const previousClusterEndTime = Math.min(endTimeByMaxSessionDuration, endTimeByMaxShiftGap, endTimeByNavigation);\n\n      // If there is an existing cluster update its closing time.\n      if (clusters.length > 0) {\n        const currentCluster = clusters[clusters.length - 1];\n        updateTraceWindowMax(currentCluster.clusterWindow, Types.Timing.MicroSeconds(previousClusterEndTime));\n      }\n\n      clusters.push({\n        events: [],\n        clusterWindow: traceWindowFromTime(clusterStartTime),\n        clusterCumulativeScore: 0,\n        scoreWindows: {\n          good: traceWindowFromTime(clusterStartTime),\n          needsImprovement: null,\n          bad: null,\n        },\n      });\n\n      firstShiftTime = clusterStartTime;\n    }\n\n    // Given the above we should have a cluster available, so pick the most\n    // recent one and append the shift, bump its score and window values accordingly.\n    const currentCluster = clusters[clusters.length - 1];\n    const timeFromNavigation = currentShiftNavigation !== null ?\n        Types.Timing.MicroSeconds(event.ts - navigations[currentShiftNavigation].ts) :\n        undefined;\n\n    currentCluster.clusterCumulativeScore += event.args.data ? event.args.data.weighted_score_delta : 0;\n    if (!event.args.data) {\n      continue;\n    }\n    const shift: Types.TraceEvents.SyntheticLayoutShift = {\n      ...event,\n      args: {\n        frame: event.args.frame,\n        data: {\n          ...event.args.data,\n          rawEvent: event,\n        },\n      },\n      parsedData: {\n        timeFromNavigation,\n        cumulativeWeightedScoreInWindow: currentCluster.clusterCumulativeScore,\n        // The score of the session window is temporarily set to 0 just\n        // to initialize it. Since we need to get the score of all shifts\n        // in the session window to determine its value, its definite\n        // value is set when stepping through the built clusters.\n        sessionWindowData: {cumulativeWindowScore: 0, id: clusters.length},\n      },\n    };\n    currentCluster.events.push(shift);\n    updateTraceWindowMax(currentCluster.clusterWindow, event.ts);\n\n    lastShiftTime = event.ts;\n    lastShiftNavigation = currentShiftNavigation;\n  }\n\n  // Now step through each cluster and set up the times at which the value\n  // goes from Good, to needs improvement, to Bad. Note that if there is a\n  // large jump we may go from Good to Bad without ever creating a Needs\n  // Improvement window at all.\n  for (const cluster of clusters) {\n    let weightedScore = 0;\n    let windowID = -1;\n    // If this is the last cluster update its window. The cluster duration is determined\n    // by the minimum between: time to next navigation, trace end time, time to maximum\n    // cluster duration and time to maximum gap between layout shifts.\n    if (cluster === clusters[clusters.length - 1]) {\n      const clusterEndByMaxDuration = MAX_CLUSTER_DURATION + cluster.clusterWindow.min;\n      const clusterEndByMaxGap = cluster.clusterWindow.max + MAX_SHIFT_TIME_DELTA;\n      const nextNavigationIndex =\n          Platform.ArrayUtilities.nearestIndexFromBeginning(navigations, nav => nav.ts > cluster.clusterWindow.max);\n      const nextNavigationTime = nextNavigationIndex ? navigations[nextNavigationIndex].ts : Infinity;\n      const clusterEnd = Math.min(clusterEndByMaxDuration, clusterEndByMaxGap, traceBounds.max, nextNavigationTime);\n      updateTraceWindowMax(cluster.clusterWindow, Types.Timing.MicroSeconds(clusterEnd));\n    }\n    for (const shift of cluster.events) {\n      weightedScore += shift.args.data ? shift.args.data.weighted_score_delta : 0;\n      windowID = shift.parsedData.sessionWindowData.id;\n      const ts = shift.ts;\n      // Update the the CLS score of this shift's session window now that\n      // we have it.\n      shift.parsedData.sessionWindowData.cumulativeWindowScore = cluster.clusterCumulativeScore;\n      if (weightedScore < LayoutShiftsThreshold.NEEDS_IMPROVEMENT) {\n        // Expand the Good window.\n        updateTraceWindowMax(cluster.scoreWindows.good, ts);\n      } else if (\n          weightedScore >= LayoutShiftsThreshold.NEEDS_IMPROVEMENT && weightedScore < LayoutShiftsThreshold.BAD) {\n        if (!cluster.scoreWindows.needsImprovement) {\n          // Close the Good window, and open the needs improvement window.\n          updateTraceWindowMax(cluster.scoreWindows.good, Types.Timing.MicroSeconds(ts - 1));\n          cluster.scoreWindows.needsImprovement = traceWindowFromTime(ts);\n        }\n\n        // Expand the needs improvement window.\n        updateTraceWindowMax(cluster.scoreWindows.needsImprovement, ts);\n      } else if (weightedScore >= LayoutShiftsThreshold.BAD) {\n        if (!cluster.scoreWindows.bad) {\n          // We may jump from Good to Bad here, so update whichever window is open.\n          if (cluster.scoreWindows.needsImprovement) {\n            updateTraceWindowMax(cluster.scoreWindows.needsImprovement, Types.Timing.MicroSeconds(ts - 1));\n          } else {\n            updateTraceWindowMax(cluster.scoreWindows.good, Types.Timing.MicroSeconds(ts - 1));\n          }\n\n          cluster.scoreWindows.bad = traceWindowFromTime(shift.ts);\n        }\n\n        // Expand the Bad window.\n        updateTraceWindowMax(cluster.scoreWindows.bad, ts);\n      }\n\n      // At this point the windows are set by the timestamps of the events, but the\n      // next cluster begins at the timestamp of its first event. As such we now\n      // need to expand the score window to the end of the cluster, and we do so\n      // by using the Bad widow if it's there, or the NI window, or finally the\n      // Good window.\n      if (cluster.scoreWindows.bad) {\n        updateTraceWindowMax(cluster.scoreWindows.bad, cluster.clusterWindow.max);\n      } else if (cluster.scoreWindows.needsImprovement) {\n        updateTraceWindowMax(cluster.scoreWindows.needsImprovement, cluster.clusterWindow.max);\n      } else {\n        updateTraceWindowMax(cluster.scoreWindows.good, cluster.clusterWindow.max);\n      }\n    }\n    if (weightedScore > sessionMaxScore) {\n      clsWindowID = windowID;\n      sessionMaxScore = weightedScore;\n    }\n  }\n}\n\nexport function data(): LayoutShifts {\n  if (handlerState !== HandlerState.FINALIZED) {\n    throw new Error('Layout Shifts Handler is not finalized');\n  }\n\n  return {\n    clusters: [...clusters],\n    sessionMaxScore: sessionMaxScore,\n    clsWindowID,\n    prePaintEvents: [...prePaintEvents],\n    layoutInvalidationEvents: [...layoutInvalidationEvents],\n    scheduleStyleInvalidationEvents: [...scheduleStyleInvalidationEvents],\n    styleRecalcInvalidationEvents: [],\n    scoreRecords: [...scoreRecords],\n    backendNodeIds: [...backendNodeIds],\n  };\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['Screenshots', 'Meta'];\n}\n\nexport function stateForLayoutShiftScore(score: number): ScoreClassification {\n  let state = ScoreClassification.GOOD;\n  if (score >= LayoutShiftsThreshold.NEEDS_IMPROVEMENT) {\n    state = ScoreClassification.OK;\n  }\n\n  if (score >= LayoutShiftsThreshold.BAD) {\n    state = ScoreClassification.BAD;\n  }\n\n  return state;\n}\n\nexport interface LayoutShiftCluster {\n  clusterWindow: Types.Timing.TraceWindowMicroSeconds;\n  clusterCumulativeScore: number;\n  events: Types.TraceEvents.SyntheticLayoutShift[];\n  // For convenience we split apart the cluster into good, NI, and bad windows.\n  // Since a cluster may remain in the good window, we mark NI and bad as being\n  // possibly null.\n  scoreWindows: {\n    good: Types.Timing.TraceWindowMicroSeconds,\n    needsImprovement: Types.Timing.TraceWindowMicroSeconds|null,\n    bad: Types.Timing.TraceWindowMicroSeconds|null,\n  };\n}\n\n// Based on https://web.dev/cls/\nexport const enum LayoutShiftsThreshold {\n  GOOD = 0,\n  NEEDS_IMPROVEMENT = 0.1,\n  BAD = 0.25,\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/handlers/MemoryHandler.js

@@ -0,0 +1,17 @@
+import * as Platform from "../../../core/platform/platform.js";
+import * as Types from "../types/types.js";
+const updateCountersByProcess = /* @__PURE__ */ new Map();
+export function reset() {
+  updateCountersByProcess.clear();
+}
+export function handleEvent(event) {
+  if (Types.TraceEvents.isTraceEventUpdateCounters(event)) {
+    const countersForProcess = Platform.MapUtilities.getWithDefault(updateCountersByProcess, event.pid, () => []);
+    countersForProcess.push(event);
+    updateCountersByProcess.set(event.pid, countersForProcess);
+  }
+}
+export function data() {
+  return { updateCountersByProcess: new Map(updateCountersByProcess) };
+}
+//# sourceMappingURL=MemoryHandler.js.map

package/models/trace/handlers/MemoryHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/MemoryHandler.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Platform from '../../../core/platform/platform.js';\nimport * as Types from '../types/types.js';\n\nexport interface MemoryData {\n  updateCountersByProcess: Map<Types.TraceEvents.ProcessID, Types.TraceEvents.TraceEventUpdateCounters[]>;\n}\n\nconst updateCountersByProcess: MemoryData['updateCountersByProcess'] = new Map();\n\nexport function reset(): void {\n  updateCountersByProcess.clear();\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (Types.TraceEvents.isTraceEventUpdateCounters(event)) {\n    const countersForProcess = Platform.MapUtilities.getWithDefault(updateCountersByProcess, event.pid, () => []);\n    countersForProcess.push(event);\n    updateCountersByProcess.set(event.pid, countersForProcess);\n  }\n}\n\nexport function data(): MemoryData {\n  return {updateCountersByProcess: new Map(updateCountersByProcess)};\n}\n"],
+  "mappings": "AAIA;AACA;AAMA,MAAM,0BAAiE,oBAAI;AAEpE,wBAAuB;AAC5B,0BAAwB;AAAA;AAGnB,4BAAqB,OAA+C;AACzE,MAAI,MAAM,YAAY,2BAA2B,QAAQ;AACvD,UAAM,qBAAqB,SAAS,aAAa,eAAe,yBAAyB,MAAM,KAAK,MAAM;AAC1G,uBAAmB,KAAK;AACxB,4BAAwB,IAAI,MAAM,KAAK;AAAA;AAAA;AAIpC,uBAA4B;AACjC,SAAO,EAAC,yBAAyB,IAAI,IAAI;AAAA;",
+  "names": []
+}

package/models/trace/handlers/MetaHandler.js

@@ -0,0 +1,250 @@
+import * as Platform from "../../../core/platform/platform.js";
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+import { HandlerState } from "./types.js";
+const rendererProcessesByFrameId = /* @__PURE__ */ new Map();
+let mainFrameId = "";
+let mainFrameURL = "";
+const framesByProcessId = /* @__PURE__ */ new Map();
+let browserProcessId = Types.TraceEvents.ProcessID(-1);
+let browserThreadId = Types.TraceEvents.ThreadID(-1);
+let gpuProcessId = Types.TraceEvents.ProcessID(-1);
+let gpuThreadId = Types.TraceEvents.ThreadID(-1);
+let viewportRect = null;
+const processNames = /* @__PURE__ */ new Map();
+const topLevelRendererIds = /* @__PURE__ */ new Set();
+const traceBounds = {
+  min: Types.Timing.MicroSeconds(Number.POSITIVE_INFINITY),
+  max: Types.Timing.MicroSeconds(Number.NEGATIVE_INFINITY),
+  range: Types.Timing.MicroSeconds(Number.POSITIVE_INFINITY)
+};
+const navigationsByFrameId = /* @__PURE__ */ new Map();
+const navigationsByNavigationId = /* @__PURE__ */ new Map();
+const mainFrameNavigations = [];
+const threadsInProcess = /* @__PURE__ */ new Map();
+let traceStartedTimeFromTracingStartedEvent = Types.Timing.MicroSeconds(-1);
+const eventPhasesOfInterestForTraceBounds = /* @__PURE__ */ new Set([
+  Types.TraceEvents.Phase.BEGIN,
+  Types.TraceEvents.Phase.END,
+  Types.TraceEvents.Phase.COMPLETE,
+  Types.TraceEvents.Phase.INSTANT
+]);
+let handlerState = HandlerState.UNINITIALIZED;
+let traceIsGeneric = true;
+const CHROME_WEB_TRACE_EVENTS = /* @__PURE__ */ new Set([
+  Types.TraceEvents.KnownEventName.TracingStartedInPage,
+  Types.TraceEvents.KnownEventName.TracingSessionIdForWorker,
+  Types.TraceEvents.KnownEventName.TracingStartedInBrowser
+]);
+export function reset() {
+  navigationsByFrameId.clear();
+  navigationsByNavigationId.clear();
+  processNames.clear();
+  mainFrameNavigations.length = 0;
+  browserProcessId = Types.TraceEvents.ProcessID(-1);
+  browserThreadId = Types.TraceEvents.ThreadID(-1);
+  gpuProcessId = Types.TraceEvents.ProcessID(-1);
+  gpuThreadId = Types.TraceEvents.ThreadID(-1);
+  viewportRect = null;
+  topLevelRendererIds.clear();
+  threadsInProcess.clear();
+  rendererProcessesByFrameId.clear();
+  framesByProcessId.clear();
+  traceBounds.min = Types.Timing.MicroSeconds(Number.POSITIVE_INFINITY);
+  traceBounds.max = Types.Timing.MicroSeconds(Number.NEGATIVE_INFINITY);
+  traceBounds.range = Types.Timing.MicroSeconds(Number.POSITIVE_INFINITY);
+  traceStartedTimeFromTracingStartedEvent = Types.Timing.MicroSeconds(-1);
+  traceIsGeneric = true;
+  handlerState = HandlerState.UNINITIALIZED;
+}
+export function initialize() {
+  if (handlerState !== HandlerState.UNINITIALIZED) {
+    throw new Error("Meta Handler was not reset");
+  }
+  handlerState = HandlerState.INITIALIZED;
+}
+function updateRendererProcessByFrame(event, frame) {
+  const framesInProcessById = Platform.MapUtilities.getWithDefault(framesByProcessId, frame.processId, () => /* @__PURE__ */ new Map());
+  framesInProcessById.set(frame.frame, frame);
+  const rendererProcessInFrame = Platform.MapUtilities.getWithDefault(rendererProcessesByFrameId, frame.frame, () => /* @__PURE__ */ new Map());
+  const rendererProcessInfo = Platform.MapUtilities.getWithDefault(rendererProcessInFrame, frame.processId, () => {
+    return [];
+  });
+  const lastProcessData = rendererProcessInfo.at(-1);
+  if (lastProcessData && lastProcessData.frame.url === frame.url) {
+    return;
+  }
+  rendererProcessInfo.push({
+    frame,
+    window: {
+      min: event.ts,
+      max: Types.Timing.MicroSeconds(0),
+      range: Types.Timing.MicroSeconds(0)
+    }
+  });
+}
+export function handleEvent(event) {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("Meta Handler is not initialized");
+  }
+  if (traceIsGeneric && CHROME_WEB_TRACE_EVENTS.has(event.name)) {
+    traceIsGeneric = false;
+  }
+  if (Types.TraceEvents.isProcessName(event)) {
+    processNames.set(event.pid, event);
+  }
+  if (event.ts !== 0 && !event.name.endsWith("::UMA") && eventPhasesOfInterestForTraceBounds.has(event.ph)) {
+    traceBounds.min = Types.Timing.MicroSeconds(Math.min(event.ts, traceBounds.min));
+    const eventDuration = event.dur || Types.Timing.MicroSeconds(0);
+    traceBounds.max = Types.Timing.MicroSeconds(Math.max(event.ts + eventDuration, traceBounds.max));
+  }
+  if (Types.TraceEvents.isProcessName(event) && (event.args.name === "Browser" || event.args.name === "HeadlessBrowser")) {
+    browserProcessId = event.pid;
+    return;
+  }
+  if (Types.TraceEvents.isProcessName(event) && (event.args.name === "Gpu" || event.args.name === "GPU Process")) {
+    gpuProcessId = event.pid;
+    return;
+  }
+  if (Types.TraceEvents.isThreadName(event) && event.args.name === "CrGpuMain") {
+    gpuThreadId = event.tid;
+    return;
+  }
+  if (Types.TraceEvents.isThreadName(event) && event.args.name === "CrBrowserMain") {
+    browserThreadId = event.tid;
+  }
+  if (Types.TraceEvents.isTraceEventMainFrameViewport(event) && viewportRect === null) {
+    const rectAsArray = event.args.data.viewport_rect;
+    const viewportX = rectAsArray[0];
+    const viewportY = rectAsArray[1];
+    const viewportWidth = rectAsArray[2];
+    const viewportHeight = rectAsArray[5];
+    viewportRect = new DOMRect(viewportX, viewportY, viewportWidth, viewportHeight);
+  }
+  if (Types.TraceEvents.isTraceEventTracingStartedInBrowser(event)) {
+    traceStartedTimeFromTracingStartedEvent = event.ts;
+    if (!event.args.data) {
+      throw new Error("No frames found in trace data");
+    }
+    for (const frame of event.args.data.frames ?? []) {
+      updateRendererProcessByFrame(event, frame);
+      if (frame.parent) {
+        continue;
+      }
+      mainFrameId = frame.frame;
+      mainFrameURL = frame.url;
+      topLevelRendererIds.add(frame.processId);
+    }
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventFrameCommittedInBrowser(event)) {
+    const frame = event.args.data;
+    if (!frame) {
+      return;
+    }
+    updateRendererProcessByFrame(event, frame);
+    if (frame.parent) {
+      return;
+    }
+    topLevelRendererIds.add(frame.processId);
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventCommitLoad(event)) {
+    const frameData = event.args.data;
+    if (!frameData) {
+      return;
+    }
+    const { frame, name, url } = frameData;
+    updateRendererProcessByFrame(event, { processId: event.pid, frame, name, url });
+    return;
+  }
+  if (Types.TraceEvents.isThreadName(event)) {
+    const threads = Platform.MapUtilities.getWithDefault(threadsInProcess, event.pid, () => /* @__PURE__ */ new Map());
+    threads.set(event.tid, event);
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventNavigationStartWithURL(event) && event.args.data) {
+    const navigationId = event.args.data.navigationId;
+    if (navigationsByNavigationId.has(navigationId)) {
+      return;
+    }
+    navigationsByNavigationId.set(navigationId, event);
+    const frameId = event.args.frame;
+    const existingFrameNavigations = navigationsByFrameId.get(frameId) || [];
+    existingFrameNavigations.push(event);
+    navigationsByFrameId.set(frameId, existingFrameNavigations);
+    if (frameId === mainFrameId) {
+      mainFrameNavigations.push(event);
+    }
+    return;
+  }
+}
+export async function finalize() {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("Handler is not initialized");
+  }
+  if (traceStartedTimeFromTracingStartedEvent >= 0) {
+    traceBounds.min = traceStartedTimeFromTracingStartedEvent;
+  }
+  traceBounds.range = Types.Timing.MicroSeconds(traceBounds.max - traceBounds.min);
+  for (const [, processWindows] of rendererProcessesByFrameId) {
+    const processWindowValues = [...processWindows.values()].flat();
+    for (let i = 0; i < processWindowValues.length; i++) {
+      const currentWindow = processWindowValues[i];
+      const nextWindow = processWindowValues[i + 1];
+      if (!nextWindow) {
+        currentWindow.window.max = Types.Timing.MicroSeconds(traceBounds.max);
+        currentWindow.window.range = Types.Timing.MicroSeconds(traceBounds.max - currentWindow.window.min);
+      } else {
+        currentWindow.window.max = Types.Timing.MicroSeconds(nextWindow.window.min - 1);
+        currentWindow.window.range = Types.Timing.MicroSeconds(currentWindow.window.max - currentWindow.window.min);
+      }
+    }
+  }
+  for (const [frameId, navigations] of navigationsByFrameId) {
+    if (rendererProcessesByFrameId.has(frameId)) {
+      continue;
+    }
+    navigationsByFrameId.delete(frameId);
+    for (const navigation of navigations) {
+      if (!navigation.args.data) {
+        continue;
+      }
+      navigationsByNavigationId.delete(navigation.args.data.navigationId);
+    }
+  }
+  const firstMainFrameNav = mainFrameNavigations.at(0);
+  const firstNavTimeThreshold = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(0.5));
+  if (firstMainFrameNav) {
+    const navigationIsWithinThreshold = firstMainFrameNav.ts - traceBounds.min < firstNavTimeThreshold;
+    if (firstMainFrameNav.args.data?.isOutermostMainFrame && firstMainFrameNav.args.data?.documentLoaderURL && navigationIsWithinThreshold) {
+      mainFrameURL = firstMainFrameNav.args.data.documentLoaderURL;
+    }
+  }
+  handlerState = HandlerState.FINALIZED;
+}
+export function data() {
+  if (handlerState !== HandlerState.FINALIZED) {
+    throw new Error("Meta Handler is not finalized");
+  }
+  return {
+    traceBounds: { ...traceBounds },
+    browserProcessId,
+    browserThreadId,
+    processNames: new Map(processNames),
+    gpuProcessId,
+    gpuThreadId: gpuThreadId === Types.TraceEvents.ThreadID(-1) ? void 0 : gpuThreadId,
+    viewportRect: viewportRect || void 0,
+    mainFrameId,
+    mainFrameURL,
+    navigationsByFrameId: new Map(navigationsByFrameId),
+    navigationsByNavigationId: new Map(navigationsByNavigationId),
+    threadsInProcess: new Map(threadsInProcess),
+    rendererProcessesByFrame: new Map(rendererProcessesByFrameId),
+    topLevelRendererIds: new Set(topLevelRendererIds),
+    frameByProcessId: new Map(framesByProcessId),
+    mainFrameNavigations: [...mainFrameNavigations],
+    traceIsGeneric
+  };
+}
+//# sourceMappingURL=MetaHandler.js.map