lighthouse 9.6.7 → 10.0.0

package/core/lib/tracehouse/task-groups.d.ts

@@ -0,0 +1,66 @@
+export type TaskGroupIds = 'parseHTML' | 'styleLayout' | 'paintCompositeRender' | 'scriptParseCompile' | 'scriptEvaluation' | 'garbageCollection' | 'other';
+export type TaskGroup = {
+    id: TaskGroupIds;
+    label: string;
+    traceEventNames: string[];
+};
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/** @typedef {'parseHTML'|'styleLayout'|'paintCompositeRender'|'scriptParseCompile'|'scriptEvaluation'|'garbageCollection'|'other'} TaskGroupIds */
+/**
+ * @typedef TaskGroup
+ * @property {TaskGroupIds} id
+ * @property {string} label
+ * @property {string[]} traceEventNames
+ */
+/**
+ * Make sure the traceEventNames keep up with the ones in DevTools
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/timeline_model/TimelineModel.js?type=cs&q=TimelineModel.TimelineModel.RecordType+%3D&g=0&l=1156
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/timeline/TimelineUIUtils.js?type=cs&q=_initEventStyles+-f:out+f:devtools&sq=package:chromium&g=0&l=39
+ * @type {{[P in TaskGroupIds]: {id: P, label: string, traceEventNames: Array<string>}}}
+ */
+export const taskGroups: {
+    other: {
+        id: "other";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    parseHTML: {
+        id: "parseHTML";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    styleLayout: {
+        id: "styleLayout";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    paintCompositeRender: {
+        id: "paintCompositeRender";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    scriptParseCompile: {
+        id: "scriptParseCompile";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    scriptEvaluation: {
+        id: "scriptEvaluation";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    garbageCollection: {
+        id: "garbageCollection";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+};
+/** @type {Object<string, TaskGroup>} */
+export const taskNameToGroup: {
+    [x: string]: TaskGroup;
+};
+//# sourceMappingURL=task-groups.d.ts.map

package/core/lib/tracehouse/task-groups.js

@@ -0,0 +1,111 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/** @typedef {'parseHTML'|'styleLayout'|'paintCompositeRender'|'scriptParseCompile'|'scriptEvaluation'|'garbageCollection'|'other'} TaskGroupIds */
+
+/**
+ * @typedef TaskGroup
+ * @property {TaskGroupIds} id
+ * @property {string} label
+ * @property {string[]} traceEventNames
+ */
+
+/**
+ * Make sure the traceEventNames keep up with the ones in DevTools
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/timeline_model/TimelineModel.js?type=cs&q=TimelineModel.TimelineModel.RecordType+%3D&g=0&l=1156
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/timeline/TimelineUIUtils.js?type=cs&q=_initEventStyles+-f:out+f:devtools&sq=package:chromium&g=0&l=39
+ * @type {{[P in TaskGroupIds]: {id: P, label: string, traceEventNames: Array<string>}}}
+ */
+const taskGroups = {
+  parseHTML: {
+    id: 'parseHTML',
+    label: 'Parse HTML & CSS',
+    traceEventNames: ['ParseHTML', 'ParseAuthorStyleSheet'],
+  },
+  styleLayout: {
+    id: 'styleLayout',
+    label: 'Style & Layout',
+    traceEventNames: [
+      'ScheduleStyleRecalculation',
+      'UpdateLayoutTree', // previously RecalculateStyles
+      'InvalidateLayout',
+      'Layout',
+    ],
+  },
+  paintCompositeRender: {
+    id: 'paintCompositeRender',
+    label: 'Rendering',
+    traceEventNames: [
+      'Animation',
+      'HitTest',
+      'PaintSetup',
+      'Paint',
+      'PaintImage',
+      'RasterTask', // Previously Rasterize
+      'ScrollLayer',
+      'UpdateLayer',
+      'UpdateLayerTree',
+      'CompositeLayers',
+      'PrePaint', // New name for UpdateLayerTree: https://crrev.com/c/3519012
+    ],
+  },
+  scriptParseCompile: {
+    id: 'scriptParseCompile',
+    label: 'Script Parsing & Compilation',
+    traceEventNames: ['v8.compile', 'v8.compileModule', 'v8.parseOnBackground'],
+  },
+  scriptEvaluation: {
+    id: 'scriptEvaluation',
+    label: 'Script Evaluation',
+    traceEventNames: [
+      'EventDispatch',
+      'EvaluateScript',
+      'v8.evaluateModule',
+      'FunctionCall',
+      'TimerFire',
+      'FireIdleCallback',
+      'FireAnimationFrame',
+      'RunMicrotasks',
+      'V8.Execute',
+    ],
+  },
+  garbageCollection: {
+    id: 'garbageCollection',
+    label: 'Garbage Collection',
+    traceEventNames: [
+      'MinorGC', // Previously GCEvent
+      'MajorGC',
+      'BlinkGC.AtomicPhase', // Previously ThreadState::performIdleLazySweep, ThreadState::completeSweep, BlinkGCMarking
+
+      // Kept for compatibility on older traces
+      'ThreadState::performIdleLazySweep',
+      'ThreadState::completeSweep',
+      'BlinkGCMarking',
+    ],
+  },
+  other: {
+    id: 'other',
+    label: 'Other',
+    traceEventNames: [
+      'MessageLoop::RunTask',
+      'TaskQueueManager::ProcessTaskFromWorkQueue',
+      'ThreadControllerImpl::DoWork',
+    ],
+  },
+};
+
+/** @type {Object<string, TaskGroup>} */
+const taskNameToGroup = {};
+for (const group of Object.values(taskGroups)) {
+  for (const traceEventName of group.traceEventNames) {
+    taskNameToGroup[traceEventName] = group;
+  }
+}
+
+export {
+  taskGroups,
+  taskNameToGroup,
+};

package/core/lib/tracehouse/task-summary.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {LH.Artifacts.NetworkRequest[]} records
+ */
+export function getJavaScriptURLs(records: LH.Artifacts.NetworkRequest[]): Set<string>;
+/**
+ * @param {LH.Artifacts.TaskNode} task
+ * @param {Set<string>} jsURLs
+ * @return {string}
+ */
+export function getAttributableURLForTask(task: LH.Artifacts.TaskNode, jsURLs: Set<string>): string;
+/**
+ * @param {LH.Artifacts.TaskNode[]} tasks
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ * @return {Map<string, Record<string, number>>}
+ */
+export function getExecutionTimingsByURL(tasks: LH.Artifacts.TaskNode[], networkRecords: Array<LH.Artifacts.NetworkRequest>): Map<string, Record<string, number>>;
+import { NetworkRequest } from "../network-request.js";
+//# sourceMappingURL=task-summary.d.ts.map

package/core/lib/tracehouse/task-summary.js

@@ -0,0 +1,86 @@
+/**
+ * @license Copyright 2022 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * @fileoverview Utility functions for grouping and summarizing tasks.
+ */
+
+import {NetworkRequest} from '../network-request.js';
+
+// These trace events, when not triggered by a script inside a particular task, are just general Chrome overhead.
+const BROWSER_TASK_NAMES_SET = new Set([
+  'CpuProfiler::StartProfiling',
+]);
+
+// These trace events, when not triggered by a script inside a particular task, are GC Chrome overhead.
+const BROWSER_GC_TASK_NAMES_SET = new Set([
+  'V8.GCCompactor',
+  'MajorGC',
+  'MinorGC',
+]);
+
+/**
+ * @param {LH.Artifacts.NetworkRequest[]} records
+ */
+function getJavaScriptURLs(records) {
+  /** @type {Set<string>} */
+  const urls = new Set();
+  for (const record of records) {
+    if (record.resourceType === NetworkRequest.TYPES.Script) {
+      urls.add(record.url);
+    }
+  }
+
+  return urls;
+}
+
+/**
+ * @param {LH.Artifacts.TaskNode} task
+ * @param {Set<string>} jsURLs
+ * @return {string}
+ */
+function getAttributableURLForTask(task, jsURLs) {
+  const jsURL = task.attributableURLs.find(url => jsURLs.has(url));
+  const fallbackURL = task.attributableURLs[0];
+  let attributableURL = jsURL || fallbackURL;
+  // If we can't find what URL was responsible for this execution, attribute it to the root page
+  // or Chrome depending on the type of work.
+  if (!attributableURL || attributableURL === 'about:blank') {
+    if (BROWSER_TASK_NAMES_SET.has(task.event.name)) attributableURL = 'Browser';
+    else if (BROWSER_GC_TASK_NAMES_SET.has(task.event.name)) attributableURL = 'Browser GC';
+    else attributableURL = 'Unattributable';
+  }
+
+  return attributableURL;
+}
+
+/**
+ * @param {LH.Artifacts.TaskNode[]} tasks
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ * @return {Map<string, Record<string, number>>}
+ */
+function getExecutionTimingsByURL(tasks, networkRecords) {
+  const jsURLs = getJavaScriptURLs(networkRecords);
+
+  /** @type {Map<string, Record<string, number>>} */
+  const result = new Map();
+
+  for (const task of tasks) {
+    const attributableURL = getAttributableURLForTask(task, jsURLs);
+    const timingByGroupId = result.get(attributableURL) || {};
+    const originalTime = timingByGroupId[task.group.id] || 0;
+    timingByGroupId[task.group.id] = originalTime + task.selfTime;
+    result.set(attributableURL, timingByGroupId);
+  }
+
+  return result;
+}
+
+export {
+  getJavaScriptURLs,
+  getAttributableURLForTask,
+  getExecutionTimingsByURL,
+};

package/core/lib/tracehouse/trace-processor.d.ts

@@ -0,0 +1,284 @@
+export type TraceNavigationTimesForFrame = Omit<LH.Artifacts.NavigationTraceTimes, 'firstContentfulPaintAllFrames' | 'traceEnd'>;
+export type TimeOriginDeterminationMethod = 'lastNavigationStart' | 'firstResourceSendRequest' | 'lighthouseMarker' | 'auto';
+export type FrameCommittedEvent = Omit<LH.TraceEvent, 'name' | 'args'> & {
+    name: 'FrameCommittedInBrowser';
+    args: {
+        data: {
+            frame: string;
+            url: string;
+            parent?: string;
+        };
+    };
+};
+export type LCPEvent = Omit<LH.TraceEvent, 'name' | 'args'> & {
+    name: 'largestContentfulPaint::Invalidate' | 'largestContentfulPaint::Candidate';
+    args: {
+        data?: {
+            size?: number;
+        };
+        frame: string;
+    };
+};
+export type LCPCandidateEvent = Omit<LH.TraceEvent, 'name' | 'args'> & {
+    name: 'largestContentfulPaint::Candidate';
+    args: {
+        data: {
+            size: number;
+        };
+        frame: string;
+    };
+};
+export type ToplevelEvent = {
+    start: number;
+    end: number;
+    duration: number;
+};
+export class TraceProcessor {
+    static get TIMESPAN_MARKER_ID(): string;
+    /**
+     * @return {Error}
+     */
+    static createNoNavstartError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoResourceSendRequestError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoTracingStartedError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoFirstContentfulPaintError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoLighthouseMarkerError(): Error;
+    /**
+     * Returns true if the event is a navigation start event of a document whose URL seems valid.
+     *
+     * @param {LH.TraceEvent} event
+     * @return {boolean}
+     */
+    static _isNavigationStartOfInterest(event: LH.TraceEvent): boolean;
+    /**
+     * This method sorts a group of trace events that have the same timestamp. We want to...
+     *
+     * 1. Put E events first, we finish off our existing events before we start new ones.
+     * 2. Order B/X events by their duration, we want parents to start before child events.
+     * 3. If we don't have any of this to go on, just use the position in the original array (stable sort).
+     *
+     * Note that the typical group size with the same timestamp will be quite small (<10 or so events),
+     * and the number of groups typically ~1% of total trace, so the same ultra-performance-sensitive consideration
+     * given to functions that run on entire traces does not necessarily apply here.
+     *
+     * @param {number[]} tsGroupIndices
+     * @param {number[]} timestampSortedIndices
+     * @param {number} indexOfTsGroupIndicesStart
+     * @param {LH.TraceEvent[]} traceEvents
+     * @return {number[]}
+     */
+    static _sortTimestampEventGroup(tsGroupIndices: number[], timestampSortedIndices: number[], indexOfTsGroupIndicesStart: number, traceEvents: LH.TraceEvent[]): number[];
+    /**
+     * Sorts and filters trace events by timestamp and respecting the nesting structure inherent to
+     * parent/child event relationships.
+     *
+     * @param {LH.TraceEvent[]} traceEvents
+     * @param {(e: LH.TraceEvent) => boolean} filter
+     */
+    static filteredTraceSort(traceEvents: LH.TraceEvent[], filter: (e: LH.TraceEvent) => boolean): import("../..").TraceEvent[];
+    /**
+     * There should *always* be at least one top level event, having 0 typically means something is
+     * drastically wrong with the trace and we should just give up early and loudly.
+     *
+     * @param {LH.TraceEvent[]} events
+     */
+    static assertHasToplevelEvents(events: LH.TraceEvent[]): void;
+    /**
+     * Calculate duration at specified percentiles for given population of
+     * durations.
+     * If one of the durations overlaps the end of the window, the full
+     * duration should be in the duration array, but the length not included
+     * within the window should be given as `clippedLength`. For instance, if a
+     * 50ms duration occurs 10ms before the end of the window, `50` should be in
+     * the `durations` array, and `clippedLength` should be set to 40.
+     * @see https://docs.google.com/document/d/1b9slyaB9yho91YTOkAQfpCdULFkZM9LqsipcX3t7He8/preview
+     * @param {!Array<number>} durations Array of durations, sorted in ascending order.
+     * @param {number} totalTime Total time (in ms) of interval containing durations.
+     * @param {!Array<number>} percentiles Array of percentiles of interest, in ascending order.
+     * @param {number=} clippedLength Optional length clipped from a duration overlapping end of window. Default of 0.
+     * @return {!Array<{percentile: number, time: number}>}
+     * @private
+     */
+    private static _riskPercentiles;
+    /**
+     * Calculates the maximum queueing time (in ms) of high priority tasks for
+     * selected percentiles within a window of the main thread.
+     * @see https://docs.google.com/document/d/1b9slyaB9yho91YTOkAQfpCdULFkZM9LqsipcX3t7He8/preview
+     * @param {Array<ToplevelEvent>} events
+     * @param {number} startTime Start time (in ms relative to timeOrigin) of range of interest.
+     * @param {number} endTime End time (in ms relative to timeOrigin) of range of interest.
+     * @param {!Array<number>=} percentiles Optional array of percentiles to compute. Defaults to [0.5, 0.75, 0.9, 0.99, 1].
+     * @return {!Array<{percentile: number, time: number}>}
+     */
+    static getRiskToResponsiveness(events: Array<ToplevelEvent>, startTime: number, endTime: number, percentiles?: Array<number> | undefined): Array<{
+        percentile: number;
+        time: number;
+    }>;
+    /**
+     * Provides durations in ms of all main thread top-level events
+     * @param {Array<ToplevelEvent>} topLevelEvents
+     * @param {number} startTime Optional start time (in ms relative to timeOrigin) of range of interest. Defaults to 0.
+     * @param {number} endTime Optional end time (in ms relative to timeOrigin) of range of interest. Defaults to trace end.
+     * @return {{durations: Array<number>, clippedLength: number}}
+     */
+    static getMainThreadTopLevelEventDurations(topLevelEvents: Array<ToplevelEvent>, startTime?: number, endTime?: number): {
+        durations: Array<number>;
+        clippedLength: number;
+    };
+    /**
+     * Provides the top level events on the main thread with timestamps in ms relative to timeOrigin.
+     * start.
+     * @param {LH.Artifacts.ProcessedTrace} trace
+     * @param {number=} startTime Optional start time (in ms relative to timeOrigin) of range of interest. Defaults to 0.
+     * @param {number=} endTime Optional end time (in ms relative to timeOrigin) of range of interest. Defaults to trace end.
+     * @return {Array<ToplevelEvent>}
+     */
+    static getMainThreadTopLevelEvents(trace: LH.Artifacts.ProcessedTrace, startTime?: number | undefined, endTime?: number | undefined): Array<ToplevelEvent>;
+    /**
+     * @param {LH.TraceEvent[]} events
+     * @return {{startingPid: number, frameId: string}}
+     */
+    static findMainFrameIds(events: LH.TraceEvent[]): {
+        startingPid: number;
+        frameId: string;
+    };
+    /**
+     * If there were any cross-origin navigations, there'll be more than one pid returned
+     * @param {{startingPid: number, frameId: string}} mainFrameInfo
+     * @param {LH.TraceEvent[]} keyEvents
+     * @return {Map<number, number>} Map where keys are process IDs and their values are thread IDs
+     */
+    static findMainFramePidTids(mainFrameInfo: {
+        startingPid: number;
+        frameId: string;
+    }, keyEvents: LH.TraceEvent[]): Map<number, number>;
+    /**
+     * @param {LH.TraceEvent} evt
+     * @return {boolean}
+     */
+    static isScheduleableTask(evt: LH.TraceEvent): boolean;
+    /**
+     * @param {LH.TraceEvent} evt
+     * @return {evt is LCPEvent}
+     */
+    static isLCPEvent(evt: LH.TraceEvent): evt is LCPEvent;
+    /**
+     * @param {LH.TraceEvent} evt
+     * @return {evt is LCPCandidateEvent}
+     */
+    static isLCPCandidateEvent(evt: LH.TraceEvent): evt is LCPCandidateEvent;
+    /**
+     * Returns the maximum LCP event across all frames in `events`.
+     * Sets `invalidated` flag if LCP of every frame is invalidated.
+     *
+     * LCP's trace event was first introduced in m78. We can't surface an LCP for older Chrome versions.
+     * LCP comes from a frame's latest `largestContentfulPaint::Candidate`, but it can be invalidated by a `largestContentfulPaint::Invalidate` event.
+     *
+     * @param {LH.TraceEvent[]} events
+     * @param {LH.TraceEvent} timeOriginEvent
+     * @return {{lcp: LCPEvent | undefined, invalidated: boolean}}
+     */
+    static computeValidLCPAllFrames(events: LH.TraceEvent[], timeOriginEvent: LH.TraceEvent): {
+        lcp: LCPEvent | undefined;
+        invalidated: boolean;
+    };
+    /**
+     * @param {Array<{id: string, url: string, parent?: string}>} frames
+     * @return {Map<string, string>}
+     */
+    static resolveRootFrames(frames: Array<{
+        id: string;
+        url: string;
+        parent?: string;
+    }>): Map<string, string>;
+    /**
+     * Finds key trace events, identifies main process/thread, and returns timings of trace events
+     * in milliseconds since the time origin in addition to the standard microsecond monotonic timestamps.
+     * @param {LH.Trace} trace
+     * @param {{timeOriginDeterminationMethod?: TimeOriginDeterminationMethod}} [options]
+     * @return {LH.Artifacts.ProcessedTrace}
+    */
+    static processTrace(trace: LH.Trace, options?: {
+        timeOriginDeterminationMethod?: TimeOriginDeterminationMethod | undefined;
+    } | undefined): LH.Artifacts.ProcessedTrace;
+    /**
+     * Finds key navigation trace events and computes timings of events in milliseconds since the time
+     * origin in addition to the standard microsecond monotonic timestamps.
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {LH.Artifacts.ProcessedNavigation}
+    */
+    static processNavigation(processedTrace: LH.Artifacts.ProcessedTrace): LH.Artifacts.ProcessedNavigation;
+    /**
+     * Computes the last observable timestamp in a set of trace events.
+     *
+     * @param {Array<LH.TraceEvent>} events
+     * @param {LH.TraceEvent} timeOriginEvt
+     * @return {{timing: number, timestamp: number}}
+     */
+    static computeTraceEnd(events: Array<LH.TraceEvent>, timeOriginEvt: LH.TraceEvent): {
+        timing: number;
+        timestamp: number;
+    };
+    /**
+     * Computes the time origin using the specified method.
+     *
+     *    - firstResourceSendRequest
+     *      Uses the time that the very first network request is sent in the main frame.
+     *      Eventually should be used in place of lastNavigationStart as the default for navigations.
+     *      This method includes the cost of all redirects when evaluating a navigation (which matches lantern behavior).
+     *      The only difference between firstResourceSendRequest and the first `navigationStart` is
+     *      the unload time of `about:blank` (which is a Lighthouse implementation detail and shouldn't be included).
+     *
+     *    - lastNavigationStart
+     *      Uses the time of the last `navigationStart` event in the main frame.
+     *      The historical time origin of Lighthouse from 2016-Present.
+     *      This method excludes the cost of client-side redirects when evaluating a navigation.
+     *      Can also be skewed by several hundred milliseconds or even seconds when the browser takes a long
+     *      time to unload `about:blank`.
+     *
+     * @param {{keyEvents: Array<LH.TraceEvent>, frameEvents: Array<LH.TraceEvent>, mainFrameInfo: {frameId: string}}} traceEventSubsets
+     * @param {TimeOriginDeterminationMethod} method
+     * @return {LH.TraceEvent}
+     */
+    static computeTimeOrigin(traceEventSubsets: {
+        keyEvents: Array<LH.TraceEvent>;
+        frameEvents: Array<LH.TraceEvent>;
+        mainFrameInfo: {
+            frameId: string;
+        };
+    }, method: TimeOriginDeterminationMethod): LH.TraceEvent;
+    /**
+     * Computes timings of trace events of key trace events in milliseconds since the time origin
+     * in addition to the standard microsecond monotonic timestamps.
+     * @param {Array<LH.TraceEvent>} frameEvents
+     * @param {{timeOriginEvt: LH.TraceEvent}} options
+    */
+    static computeNavigationTimingsForFrame(frameEvents: Array<LH.TraceEvent>, options: {
+        timeOriginEvt: LH.TraceEvent;
+    }): {
+        timings: TraceNavigationTimesForFrame;
+        timestamps: TraceNavigationTimesForFrame;
+        timeOriginEvt: import("../..").TraceEvent;
+        firstPaintEvt: import("../..").TraceEvent | undefined;
+        firstContentfulPaintEvt: import("../..").TraceEvent;
+        firstMeaningfulPaintEvt: import("../..").TraceEvent | undefined;
+        largestContentfulPaintEvt: LCPEvent | undefined;
+        loadEvt: import("../..").TraceEvent | undefined;
+        domContentLoadedEvt: import("../..").TraceEvent | undefined;
+        fmpFellBack: boolean;
+        lcpInvalidated: boolean;
+    };
+}
+//# sourceMappingURL=trace-processor.d.ts.map