lighthouse 9.5.0-dev.20230117 → 9.5.0-dev.20230119

package/core/lib/tracehouse/main-thread-tasks.d.ts

@@ -0,0 +1,162 @@
+export type TaskGroup = import('./task-groups.js').TaskGroup;
+export type TaskNode = {
+    event: LH.TraceEvent;
+    endEvent: LH.TraceEvent | undefined;
+    children: TaskNode[];
+    parent: TaskNode | undefined;
+    /**
+     * Indicates that the task had an endTime that was inferred rather than specified in the trace. i.e. in the source trace this task was unbounded.
+     */
+    unbounded: boolean;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    selfTime: number;
+    attributableURLs: string[];
+    group: TaskGroup;
+};
+export type PriorTaskData = {
+    timers: Map<string, TaskNode>;
+    xhrs: Map<string, TaskNode>;
+    frameURLsById: Map<string, string>;
+    lastTaskURLs: string[];
+};
+/**
+ * @fileoverview
+ *
+ * This artifact converts the array of raw trace events into an array of hierarchical
+ * tasks for easier consumption and bottom-up analysis.
+ *
+ * Events are easily produced but difficult to consume. They're a mixture of start/end markers, "complete" events, etc.
+ * @see https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview
+ *
+ * LH's TaskNode is an artifact that fills in the gaps a trace event leaves behind.
+ * i.e. when did it end? which events are children/parents of this one?
+ *
+ * Each task will have its group/classification, start time, end time,
+ * duration, and self time computed. Each task will potentially have a parent, children, and an
+ * attributableURL for the script that was executing/forced this execution.
+ */
+/** @typedef {import('./task-groups.js').TaskGroup} TaskGroup */
+/**
+ * @typedef TaskNode
+ * @prop {LH.TraceEvent} event
+ * @prop {LH.TraceEvent|undefined} endEvent
+ * @prop {TaskNode[]} children
+ * @prop {TaskNode|undefined} parent
+ * @prop {boolean} unbounded Indicates that the task had an endTime that was inferred rather than specified in the trace. i.e. in the source trace this task was unbounded.
+ * @prop {number} startTime
+ * @prop {number} endTime
+ * @prop {number} duration
+ * @prop {number} selfTime
+ * @prop {string[]} attributableURLs
+ * @prop {TaskGroup} group
+ */
+/** @typedef {{timers: Map<string, TaskNode>, xhrs: Map<string, TaskNode>, frameURLsById: Map<string, string>, lastTaskURLs: string[]}} PriorTaskData */
+export class MainThreadTasks {
+    /**
+     * @param {LH.TraceEvent} event
+     * @param {LH.TraceEvent} [endEvent]
+     * @return {TaskNode}
+     */
+    static _createNewTaskNode(event: LH.TraceEvent, endEvent?: LH.TraceEvent | undefined): TaskNode;
+    /**
+     *
+     * @param {TaskNode} currentTask
+     * @param {number} stopTs
+     * @param {PriorTaskData} priorTaskData
+     * @param {Array<LH.TraceEvent>} reverseEventsQueue
+     */
+    static _assignAllTimersUntilTs(currentTask: TaskNode, stopTs: number, priorTaskData: PriorTaskData, reverseEventsQueue: Array<LH.TraceEvent>): void;
+    /**
+     * This function takes the start and end events from a thread and creates tasks from them.
+     * We do this by iterating through the start and end event arrays simultaneously. For each start
+     * event we attempt to find its end event.
+     *
+     * Because of this matching of start/end events and the need to be mutating our end events queue,
+     * we reverse the array to more efficiently `.pop()` them off rather than `.shift()` them off.
+     * While it's true the worst case runtime here is O(n^2), ~99.999% of the time the reverse loop is O(1)
+     * because the overwhelmingly common case is that end event for a given start event is simply the very next event in our queue.
+     *
+     * @param {LH.TraceEvent[]} taskStartEvents
+     * @param {LH.TraceEvent[]} taskEndEvents
+     * @param {number} traceEndTs
+     * @return {TaskNode[]}
+     */
+    static _createTasksFromStartAndEndEvents(taskStartEvents: LH.TraceEvent[], taskEndEvents: LH.TraceEvent[], traceEndTs: number): TaskNode[];
+    /**
+     * This function iterates through the tasks to set the `.parent`/`.children` properties of tasks
+     * according to their implied nesting structure. If any of these relationships seem impossible based on
+     * the timestamps, this method will throw.
+     *
+     * @param {TaskNode[]} sortedTasks
+     * @param {LH.TraceEvent[]} timerInstallEvents
+     * @param {PriorTaskData} priorTaskData
+     */
+    static _createTaskRelationships(sortedTasks: TaskNode[], timerInstallEvents: LH.TraceEvent[], priorTaskData: PriorTaskData): void;
+    /**
+     * This function takes the raw trace events sorted in increasing timestamp order and outputs connected task nodes.
+     * To create the task heirarchy we make several passes over the events.
+     *
+     *    1. Create three arrays of X/B events, E events, and TimerInstall events.
+     *    2. Create tasks for each X/B event, throwing if a matching E event cannot be found for a given B.
+     *    3. Sort the tasks by ↑ startTime, ↓ duration.
+     *    4. Match each task to its parent, throwing if there is any invalid overlap between tasks.
+     *    5. Sort the tasks once more by ↑ startTime, ↓ duration in case they changed during relationship creation.
+     *
+     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {PriorTaskData} priorTaskData
+     * @param {number} traceEndTs
+     * @return {TaskNode[]}
+     */
+    static _createTasksFromEvents(mainThreadEvents: LH.TraceEvent[], priorTaskData: PriorTaskData, traceEndTs: number): TaskNode[];
+    /**
+     * @param {TaskNode} task
+     * @param {TaskNode|undefined} parent
+     * @return {number}
+     */
+    static _computeRecursiveSelfTime(task: TaskNode, parent: TaskNode | undefined): number;
+    /**
+     * @param {TaskNode} task
+     * @param {string[]} parentURLs
+     * @param {string[]} allURLsInTree
+     * @param {PriorTaskData} priorTaskData
+     */
+    static _computeRecursiveAttributableURLs(task: TaskNode, parentURLs: string[], allURLsInTree: string[], priorTaskData: PriorTaskData): void;
+    /**
+     * @param {TaskNode} task
+     * @param {Array<string>} urls
+     */
+    static _setRecursiveEmptyAttributableURLs(task: TaskNode, urls: Array<string>): void;
+    /**
+     * @param {TaskNode} task
+     * @param {TaskGroup} [parentGroup]
+     */
+    static _computeRecursiveTaskGroup(task: TaskNode, parentGroup?: import("./task-groups.js").TaskGroup | undefined): void;
+    /**
+     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {Array<{id: string, url: string}>} frames
+     * @param {number} traceEndTs
+     * @param {number} [traceStartTs] Optional time-0 ts for tasks. Tasks before this point will have negative start/end times. Defaults to the first task found.
+     * @return {TaskNode[]}
+     */
+    static getMainThreadTasks(mainThreadEvents: LH.TraceEvent[], frames: Array<{
+        id: string;
+        url: string;
+    }>, traceEndTs: number, traceStartTs?: number | undefined): TaskNode[];
+    /**
+     * Prints an artistic rendering of the task tree for easier debugability.
+     *
+     * @param {TaskNode[]} tasks
+     * @param {{printWidth?: number, startTime?: number, endTime?: number, taskLabelFn?: (node: TaskNode) => string}} options
+     * @return {string}
+     */
+    static printTaskTreeToDebugString(tasks: TaskNode[], options?: {
+        printWidth?: number | undefined;
+        startTime?: number | undefined;
+        endTime?: number | undefined;
+        taskLabelFn?: ((node: TaskNode) => string) | undefined;
+    }): string;
+}
+import * as LH from "../../../types/lh.js";
+//# sourceMappingURL=main-thread-tasks.d.ts.map

package/core/lib/tracehouse/main-thread-tasks.js

@@ -4,6 +4,7 @@
  * 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.
  */
 
+import * as LH from '../../../types/lh.js';
 import {taskGroups, taskNameToGroup} from './task-groups.js';
 
 /**

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-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/trace-processor.d.ts

@@ -0,0 +1,275 @@
+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 {{pid: number, tid: number, frameId: string}}
+     */
+    static findMainFrameIds(events: LH.TraceEvent[]): {
+        pid: number;
+        tid: number;
+        frameId: string;
+    };
+    /**
+     * @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>, mainFrameIds: {frameId: string}}} traceEventSubsets
+     * @param {TimeOriginDeterminationMethod} method
+     * @return {LH.TraceEvent}
+     */
+    static computeTimeOrigin(traceEventSubsets: {
+        keyEvents: Array<LH.TraceEvent>;
+        frameEvents: Array<LH.TraceEvent>;
+        mainFrameIds: {
+            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

package/core/lib/traces/metric-trace-events.d.ts

@@ -0,0 +1,65 @@
+export class MetricTraceEvents {
+    /**
+     * Returns simplified representation of all metrics
+     * @return {Array<{id: string, name: string, tsKey: keyof LH.Artifacts.TimingSummary}>} metrics to consider
+     */
+    static get metricsDefinitions(): {
+        id: string;
+        name: string;
+        tsKey: keyof LH.Artifacts.TimingSummary;
+    }[];
+    /**
+     * @param {Array<LH.TraceEvent>} traceEvents
+     * @param {LH.Result['audits']} auditResults
+     */
+    constructor(traceEvents: Array<LH.TraceEvent>, auditResults: LH.Result['audits']);
+    _traceEvents: import("../../index.js").TraceEvent[];
+    _auditResults: Record<string, import("../../../types/lhr/audit-result.js").Result>;
+    /**
+     * Returns simplified representation of all metrics' timestamps from monotonic clock
+     * @return {Array<{ts: number, id: string, name: string}>} metrics to consider
+     */
+    gatherMetrics(): Array<{
+        ts: number;
+        id: string;
+        name: string;
+    }>;
+    /**
+     * Get the trace event data for our timeOrigin
+     * @param {Array<{ts: number, id: string, name: string}>} metrics
+     * @return {{pid: number, tid: number, ts: number} | {errorMessage: string}}
+     */
+    getTimeOriginEvt(metrics: Array<{
+        ts: number;
+        id: string;
+        name: string;
+    }>): {
+        pid: number;
+        tid: number;
+        ts: number;
+    } | {
+        errorMessage: string;
+    };
+    /**
+     * Constructs performance.measure trace events, which have start/end events as follows:
+     *     { "pid": 89922,"tid":1295,"ts":77176783452,"ph":"b","cat":"blink.user_timing","name":"innermeasure","args":{},"tts":1257886,"id":"0xe66c67"}
+     *     { "pid": 89922,"tid":1295,"ts":77176882592,"ph":"e","cat":"blink.user_timing","name":"innermeasure","args":{},"tts":1257898,"id":"0xe66c67"}
+     * @param {{ts: number, id: string, name: string}} metric
+     * @param {{pid: number, tid: number, ts: number}} timeOriginEvt
+     * @return {Array<LH.TraceEvent>} Pair of trace events (start/end)
+     */
+    synthesizeEventPair(metric: {
+        ts: number;
+        id: string;
+        name: string;
+    }, timeOriginEvt: {
+        pid: number;
+        tid: number;
+        ts: number;
+    }): Array<LH.TraceEvent>;
+    /**
+     * @return {Array<LH.TraceEvent>} User timing raw trace event pairs
+     */
+    generateFakeEvents(): Array<LH.TraceEvent>;
+}
+//# sourceMappingURL=metric-trace-events.d.ts.map