devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/models/trace/handlers/ExtensionTraceDataHandler.d.ts

@@ -0,0 +1,106 @@
+import * as Helpers from '../helpers/helpers.js';
+import * as Types from '../types/types.js';
+import type { HandlerName } from './types.js';
+export interface ExtensionTraceData {
+    extensionTrackData: readonly Types.Extensions.ExtensionTrackData[];
+    extensionMarkers: readonly Types.Extensions.SyntheticExtensionMarker[];
+    entryToNode: Map<Types.Events.Event, Helpers.TreeHelpers.TraceEntryNode>;
+    syntheticConsoleEntriesForTimingsTrack: Types.Events.SyntheticConsoleTimeStamp[];
+}
+export declare function handleEvent(_event: Types.Events.Event): void;
+export declare function reset(): void;
+export declare function finalize(): Promise<void>;
+/**
+ * Extracts extension entries from console.timeStamp events.
+ *
+ * Entries are built by pairing `console.timeStamp` events based on
+ * their names. When a `console.timeStamp` event includes a `start`
+ * argument (and optionally an `end` argument), it attempts to find
+ * previously recorded `console.timeStamp` events with names matching
+ * the `start` and `end` values. These matching events are then used to
+ * determine the start and end times of the new entry.
+ *
+ * If a `console.timeStamp` event includes data for a custom track
+ * (specified by the `track` argument), an extension track entry is
+ * created and added to the `extensionTrackEntries` array. These entries
+ * are used to visualize custom tracks in the Performance panel.
+ *
+ * If a `console.timeStamp` event includes data for a custom track
+ * (specified by the `track` argument), an extension track entry is
+ * created and added to the `extensionTrackEntries` array. These entries
+ * are used to visualize custom tracks in the Performance panel.
+ *
+ * If a `console.timeStamp` event does not specify a custom track but
+ * includes a start and/or end time (referencing other
+ * `console.timeStamp` names), a synthetic console time stamp entry is
+ * created and added to the `syntheticConsoleEntriesForTimingsTrack`
+ * array. These entries are displayed in the "Timings" track.
+ */
+export declare function extractConsoleAPIExtensionEntries(): void;
+/**
+ * Extracts extension entries from Performance API events (marks and
+ * measures).
+ * It specifically looks for events that contain extension-specific data
+ * within their `detail` property.
+ *
+ * If an event's `detail` property can be parsed as a JSON object and
+ * contains a `devtools` field with a valid extension payload, a
+ * synthetic extension entry is created. The type of extension entry
+ * created depends on the payload:
+ *
+ * - If the payload conforms to `ExtensionPayloadMarker`, a
+ *   `SyntheticExtensionMarker` is created and added to the
+ *   `extensionMarkers` array. These markers represent single points in
+ *   time.
+ * - If the payload conforms to `ExtensionPayloadTrackEntry`, a
+ *   `SyntheticExtensionTrackEntry` is created and added to the
+ *   `extensionTrackEntries` array. These entries represent events with
+ *   a duration and are displayed on custom tracks in the Performance
+ *   panel.
+ *
+ * **Note:** Only events with a `detail` property that contains valid
+ * extension data are processed. Other `performance.mark` and
+ * `performance.measure` events are ignored.
+ *
+ * @param timings An array of `SyntheticUserTimingPair` or
+ *                `PerformanceMark` events, typically obtained from the
+ *                `UserTimingsHandler`.
+ */
+export declare function extractPerformanceAPIExtensionEntries(timings: Array<Types.Events.SyntheticUserTimingPair | Types.Events.PerformanceMark>): void;
+/**
+ * Parses out the data in a performance.measure / mark call into two parts:
+ * 1. devtoolsObj: this is the data required to be passed by the user for the
+ *    event to be used to create a custom track in the performance panel.
+ * 2. userDetail: this is arbitrary data the user has attached to the event
+ *    that we show in the summary drawer.
+ */
+export declare function extensionDataInPerformanceTiming(timing: Types.Events.SyntheticUserTimingPair | Types.Events.PerformanceMark): {
+    devtoolsObj: Types.Extensions.DevToolsObj | null;
+    userDetail: Types.Extensions.JsonValue | null;
+};
+/**
+ * Extracts extension data from a `console.timeStamp` event.
+ *
+ * Checks if a `console.timeStamp` event contains data intended for
+ * creating a custom track entry in the DevTools Performance panel. It
+ * specifically looks for a `track` argument within the event's data.
+ *
+ * If a `track` argument is present (and not an empty string), the
+ * function constructs an `ExtensionTrackEntryPayload` object containing
+ * the track name, an optional color, an optional track group. This
+ * payload is then used to create a `SyntheticExtensionTrackEntry`.
+ *
+ * **Note:** The `color` argument is optional and its type is validated
+ * against a predefined palette (see
+ * `ExtensionUI::extensionEntryColor`).
+ *
+ * @param timeStamp The `ConsoleTimeStamp` event to extract data from.
+ * @returns An `ExtensionTrackEntryPayload` object if the event contains
+ *         valid extension data for a track entry, or `null` otherwise.
+ */
+export declare function extensionDataInConsoleTimeStamp(timeStamp: Types.Events.ConsoleTimeStamp): {
+    devtoolsObj: Types.Extensions.DevToolsObjEntry | null;
+    userDetail: Types.Extensions.JsonValue | null;
+};
+export declare function data(): ExtensionTraceData;
+export declare function deps(): HandlerName[];

package/dist/lib/front_end/models/trace/handlers/FlowsHandler.d.ts

@@ -0,0 +1,7 @@
+import * as Types from '../types/types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): {
+    flows: Types.Events.Event[][];
+};

package/dist/lib/front_end/models/trace/handlers/FramesHandler.d.ts

@@ -0,0 +1,94 @@
+import * as Types from '../types/types.js';
+import { type AuctionWorkletsData } from './AuctionWorkletsHandler.js';
+import { type LayerTreeData } from './LayerTreeHandler.js';
+import { type MetaHandlerData } from './MetaHandler.js';
+import { type RendererHandlerData } from './RendererHandler.js';
+import type { HandlerName } from './types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export interface FramesData {
+    frames: readonly Types.Events.LegacyTimelineFrame[];
+    framesById: Readonly<Record<number, Types.Events.LegacyTimelineFrame | undefined>>;
+}
+export declare function data(): FramesData;
+export declare function deps(): HandlerName[];
+export declare class TimelineFrameModel {
+    #private;
+    constructor(allEvents: readonly Types.Events.Event[], rendererData: RendererHandlerData, auctionWorkletsData: AuctionWorkletsData, metaData: MetaHandlerData, layerTreeData: LayerTreeData);
+    framesById(): Readonly<Record<number, TimelineFrame | undefined>>;
+    frames(): TimelineFrame[];
+}
+/**
+ * Legacy class that represents TimelineFrames that was ported from the old SDK.
+ * This class is purposefully not exported as it breaks the abstraction that
+ * every event shown on the timeline is a trace event. Instead, we use the Type
+ * LegacyTimelineFrame to represent frames in the codebase. These do implement
+ * the right interface to be treated just like they were a trace event.
+ */
+declare class TimelineFrame implements Types.Events.LegacyTimelineFrame {
+    cat: string;
+    name: string;
+    ph: Types.Events.Phase;
+    ts: Types.Timing.Micro;
+    pid: Types.Events.ProcessID;
+    tid: Types.Events.ThreadID;
+    index: number;
+    startTime: Types.Timing.Micro;
+    startTimeOffset: Types.Timing.Micro;
+    endTime: Types.Timing.Micro;
+    duration: Types.Timing.Micro;
+    idle: boolean;
+    dropped: boolean;
+    isPartial: boolean;
+    layerTree: Types.Events.LegacyFrameLayerTreeData | null;
+    paints: LayerPaintEvent[];
+    mainFrameId: number | undefined;
+    readonly seqId: number;
+    constructor(seqId: number, startTime: Types.Timing.Micro, startTimeOffset: Types.Timing.Micro);
+    setIndex(i: number): void;
+    setEndTime(endTime: Types.Timing.Micro): void;
+    setLayerTree(layerTree: Types.Events.LegacyFrameLayerTreeData | null): void;
+    /**
+     * Fake the `dur` field to meet the expected value given that we pretend
+     * these TimelineFrame classes are trace events across the codebase.
+     */
+    get dur(): Types.Timing.Micro;
+}
+export declare class LayerPaintEvent implements Types.Events.LegacyLayerPaintEvent {
+    #private;
+    constructor(event: Types.Events.Paint, snapshot: Types.Events.DisplayItemListSnapshot);
+    layerId(): number;
+    event(): Types.Events.Paint;
+    picture(): Types.Events.LegacyLayerPaintEventPicture | null;
+}
+export declare class PendingFrame {
+    paints: LayerPaintEvent[];
+    mainFrameId: number | undefined;
+    triggerTime: number;
+    constructor(triggerTime: number);
+}
+/** The parameters of an impl-side BeginFrame. **/
+declare class BeginFrameInfo {
+    seqId: number;
+    startTime: Types.Timing.Micro;
+    isDropped: boolean;
+    isPartial: boolean;
+    constructor(seqId: number, startTime: Types.Timing.Micro, isDropped: boolean, isPartial: boolean);
+}
+/**
+ * A queue of BeginFrames pending visualization.
+ * BeginFrames are added into this queue as they occur; later when their
+ * corresponding DrawFrames occur (or lack thereof), the BeginFrames are removed
+ * from the queue and their timestamps are used for visualization.
+ **/
+export declare class TimelineFrameBeginFrameQueue {
+    private queueFrames;
+    private mapFrames;
+    addFrameIfNotExists(seqId: number, startTime: Types.Timing.Micro, isDropped: boolean, isPartial: boolean): void;
+    setDropped(seqId: number, isDropped: boolean): void;
+    setPartial(seqId: number, isPartial: boolean): void;
+    processPendingBeginFramesOnDrawFrame(seqId: number): BeginFrameInfo[];
+}
+export declare function framesWithinWindow(frames: readonly Types.Events.LegacyTimelineFrame[], startTime: Types.Timing.Micro, endTime: Types.Timing.Micro): Types.Events.LegacyTimelineFrame[];
+export {};

package/dist/lib/front_end/models/trace/handlers/GPUHandler.d.ts

@@ -0,0 +1,10 @@
+import * as Types from '../types/types.js';
+import type { HandlerName } from './types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export interface GPUHandlerReturnData {
+    mainGPUThreadTasks: readonly Types.Events.GPUTask[];
+}
+export declare function data(): GPUHandlerReturnData;
+export declare function deps(): HandlerName[];

package/dist/lib/front_end/models/trace/handlers/ImagePaintingHandler.d.ts

@@ -0,0 +1,17 @@
+import * as Types from '../types/types.js';
+import type { FinalizeOptions } from './types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(options: FinalizeOptions): Promise<void>;
+export interface ImagePaintData {
+    paintImageByDrawLazyPixelRef: Map<number, Types.Events.PaintImage>;
+    paintImageForEvent: Map<Types.Events.Event, Types.Events.PaintImage>;
+    paintImageEventForUrl: Map<string, Types.Events.PaintImage[]>;
+    paintEventToCorrectedDisplaySize: Map<Types.Events.PaintImage, {
+        width: number;
+        height: number;
+    }>;
+    /** Go read the comment in finalize(). */
+    didCorrectForHostDpr: boolean;
+}
+export declare function data(): ImagePaintData;

package/dist/lib/front_end/models/trace/handlers/InitiatorsHandler.d.ts

@@ -0,0 +1,20 @@
+import * as Types from '../types/types.js';
+export declare function reset(): void;
+/**
+ * IMPORTANT: Before adding support for new initiator relationships in
+ * trace events consider using Perfetto's flow API on the events in
+ * question, so that they get automatically computed.
+ * @see {@link flowsHandlerData}
+ *
+ * The events manually computed here were added before we had support
+ * for flow events. As such they should be migrated to use the flow
+ * API so that no manual parsing is needed.
+ */
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export interface InitiatorsData {
+    eventToInitiator: Map<Types.Events.Event, Types.Events.Event>;
+    initiatorToEvents: Map<Types.Events.Event, Types.Events.Event[]>;
+}
+export declare function data(): InitiatorsData;
+export declare function deps(): ['Flows', 'AsyncJSCalls'];

package/dist/lib/front_end/models/trace/handlers/InvalidationsHandler.d.ts

@@ -0,0 +1,11 @@
+import * as Types from '../types/types.js';
+export declare function reset(): void;
+export declare function handleUserConfig(userConfig: Types.Configuration.Configuration): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+interface InvalidationsData {
+    invalidationsForEvent: Map<Types.Events.Event, Types.Events.InvalidationTrackingEvent[]>;
+    invalidationCountForEvent: Map<Types.Events.Event, number>;
+}
+export declare function data(): InvalidationsData;
+export {};

package/dist/lib/front_end/models/trace/handlers/LargestImagePaintHandler.d.ts

@@ -0,0 +1,10 @@
+import * as Types from '../types/types.js';
+import type { HandlerName } from './types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export interface LargestImagePaintData {
+    lcpRequestByNavigationId: Map<string, Types.Events.SyntheticNetworkRequest>;
+}
+export declare function data(): LargestImagePaintData;
+export declare function deps(): HandlerName[];

package/dist/lib/front_end/models/trace/handlers/LargestTextPaintHandler.d.ts

@@ -0,0 +1,6 @@
+import type * as Protocol from '../../../generated/protocol.js';
+import * as Types from '../types/types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): Map<Protocol.DOM.BackendNodeId, Types.Events.LargestTextPaintCandidate>;

package/dist/lib/front_end/models/trace/handlers/LayerTreeHandler.d.ts

@@ -0,0 +1,12 @@
+import * as Types from '../types/types.js';
+import type { HandlerName } from './types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export interface LayerTreeData {
+    paints: Types.Events.Paint[];
+    snapshots: Types.Events.DisplayItemListSnapshot[];
+    paintsToSnapshots: Map<Types.Events.Paint, Types.Events.DisplayItemListSnapshot>;
+}
+export declare function data(): LayerTreeData;
+export declare function deps(): HandlerName[];

package/dist/lib/front_end/models/trace/handlers/LayoutShiftsHandler.d.ts

@@ -0,0 +1,58 @@
+import type * as Protocol from '../../../generated/protocol.js';
+import * as Types from '../types/types.js';
+import { ScoreClassification } from './PageLoadMetricsHandler.js';
+import type { HandlerName } from './types.js';
+interface LayoutShiftsData {
+    clusters: readonly Types.Events.SyntheticLayoutShiftCluster[];
+    clustersByNavigationId: Map<Types.Events.NavigationId, Types.Events.SyntheticLayoutShiftCluster[]>;
+    sessionMaxScore: number;
+    clsWindowID: number;
+    prePaintEvents: readonly Types.Events.PrePaint[];
+    paintImageEvents: Types.Events.PaintImage[];
+    layoutInvalidationEvents: readonly Types.Events.LayoutInvalidationTracking[];
+    scheduleStyleInvalidationEvents: readonly Types.Events.ScheduleStyleInvalidationTracking[];
+    styleRecalcInvalidationEvents: readonly Types.Events.StyleRecalcInvalidationTracking[];
+    renderFrameImplCreateChildFrameEvents: readonly Types.Events.RenderFrameImplCreateChildFrame[];
+    domLoadingEvents: readonly Types.Events.DomLoading[];
+    layoutImageUnsizedEvents: readonly Types.Events.LayoutImageUnsized[];
+    remoteFonts: readonly RemoteFont[];
+    scoreRecords: readonly ScoreRecord[];
+    backendNodeIds: Set<Protocol.DOM.BackendNodeId>;
+}
+interface RemoteFont {
+    display: string;
+    url?: string;
+    name?: string;
+    beginRemoteFontLoadEvent: Types.Events.BeginRemoteFontLoad;
+}
+/**
+ * This represents the maximum #time we will allow a cluster to go before we
+ * reset it.
+ **/
+export declare const MAX_CLUSTER_DURATION: Types.Timing.Micro;
+/**
+ * This represents the maximum #time we will allow between layout shift events
+ * before considering it to be the start of a new cluster.
+ **/
+export declare const MAX_SHIFT_TIME_DELTA: Types.Timing.Micro;
+/**
+ * Represents a point in time in which a  LS score change
+ * was recorded.
+ **/
+interface ScoreRecord {
+    ts: number;
+    score: number;
+}
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): LayoutShiftsData;
+export declare function deps(): HandlerName[];
+export declare function scoreClassificationForLayoutShift(score: number): ScoreClassification;
+/** Based on https://web.dev/cls/ **/
+export declare const enum LayoutShiftsThreshold {
+    GOOD = 0,
+    NEEDS_IMPROVEMENT = 0.1,
+    BAD = 0.25
+}
+export {};

package/dist/lib/front_end/models/trace/handlers/MemoryHandler.d.ts

@@ -0,0 +1,8 @@
+import * as Types from '../types/types.js';
+export interface MemoryData {
+    updateCountersByProcess: Map<Types.Events.ProcessID, Types.Events.UpdateCounters[]>;
+}
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): MemoryData;

package/dist/lib/front_end/models/trace/handlers/MetaHandler.d.ts

@@ -0,0 +1,82 @@
+import * as Types from '../types/types.js';
+import type { FinalizeOptions } from './types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(options?: FinalizeOptions): Promise<void>;
+export interface MetaHandlerData {
+    config: {
+        showAllEvents: boolean;
+    };
+    traceIsGeneric: boolean;
+    traceBounds: Types.Timing.TraceWindowMicro;
+    browserProcessId: Types.Events.ProcessID;
+    processNames: Map<Types.Events.ProcessID, Types.Events.ProcessName>;
+    browserThreadId: Types.Events.ThreadID;
+    gpuProcessId: Types.Events.ProcessID;
+    navigationsByFrameId: Map<string, Types.Events.NavigationStart[]>;
+    /**
+     * This does not include soft navigations.
+     *
+     * TODO(crbug.com/414468047): include soft navs here, so that
+     * PageLoadMetricsHandler and insights can use this map for all navigation types.
+     */
+    navigationsByNavigationId: Map<string, Types.Events.NavigationStart>;
+    softNavigationsById: Map<number, Types.Events.SoftNavigationStart>;
+    /**
+     * The user-visible URL displayed to users in the address bar.
+     * This captures:
+     *  - resolving all redirects
+     *  - history API pushState
+     *
+     * Given no redirects or history API usages, this is just the navigation event's documentLoaderURL.
+     *
+     * Note: empty string special case denotes the duration of the trace between the start
+     * and the first navigation. If there is no history API navigation during this time,
+     * there will be no value for empty string.
+     **/
+    finalDisplayUrlByNavigationId: Map<string, string>;
+    threadsInProcess: Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.ThreadName>>;
+    mainFrameId: string;
+    mainFrameURL: string;
+    /**
+     * A frame can have multiple renderer processes, at the same time,
+     * a renderer process can have multiple URLs. This map tracks the
+     * processes active on a given frame, with the time window in which
+     * they were active. Because a renderer process might have multiple
+     * URLs, each process in each frame has an array of windows, with an
+     * entry for each URL it had.
+     */
+    rendererProcessesByFrame: FrameProcessData;
+    topLevelRendererIds: Set<Types.Events.ProcessID>;
+    frameByProcessId: Map<Types.Events.ProcessID, Map<string, Types.Events.TraceFrame>>;
+    mainFrameNavigations: Types.Events.NavigationStart[];
+    gpuThreadId?: Types.Events.ThreadID;
+    viewportRect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    devicePixelRatio?: number;
+}
+/**
+ * Each frame has a single render process at a given time but it can have
+ * multiple render processes  during a trace, for example if a navigation
+ * occurred in the frame. This map tracks the process that was active for
+ * each frame at each point in time. Also, because a process can be
+ * assigned to multiple URLs, there is a window for each URL a process
+ * was assigned.
+ *
+ * Note that different sites always end up in different render
+ * processes, however two different URLs can point to the same site.
+ * For example: https://google.com and https://maps.google.com point to
+ * the same site.
+ * Read more about this in
+ * https://developer.chrome.com/articles/renderingng-architecture/#threads
+ * and https://web.dev/same-site-same-origin/
+ **/
+export type FrameProcessData = Map<string, Map<Types.Events.ProcessID, Array<{
+    frame: Types.Events.TraceFrame;
+    window: Types.Timing.TraceWindowMicro;
+}>>>;
+export declare function data(): MetaHandlerData;

package/dist/lib/front_end/models/trace/handlers/ModelHandlers.d.ts

@@ -0,0 +1,30 @@
+export * as AnimationFrames from './AnimationFramesHandler.js';
+export * as Animations from './AnimationHandler.js';
+export * as AsyncJSCalls from './AsyncJSCallsHandler.js';
+export * as AuctionWorklets from './AuctionWorkletsHandler.js';
+export * as DOMStats from './DOMStatsHandler.js';
+export * as ExtensionTraceData from './ExtensionTraceDataHandler.js';
+export * as Flows from './FlowsHandler.js';
+export * as Frames from './FramesHandler.js';
+export * as GPU from './GPUHandler.js';
+export * as ImagePainting from './ImagePaintingHandler.js';
+export * as Initiators from './InitiatorsHandler.js';
+export * as Invalidations from './InvalidationsHandler.js';
+export * as LargestImagePaint from './LargestImagePaintHandler.js';
+export * as LargestTextPaint from './LargestTextPaintHandler.js';
+export * as LayerTree from './LayerTreeHandler.js';
+export * as LayoutShifts from './LayoutShiftsHandler.js';
+export * as Memory from './MemoryHandler.js';
+export * as Meta from './MetaHandler.js';
+export * as NetworkRequests from './NetworkRequestsHandler.js';
+export * as PageFrames from './PageFramesHandler.js';
+export * as PageLoadMetrics from './PageLoadMetricsHandler.js';
+export * as Renderer from './RendererHandler.js';
+export * as Samples from './SamplesHandler.js';
+export * as Screenshots from './ScreenshotsHandler.js';
+export * as Scripts from './ScriptsHandler.js';
+export * as SelectorStats from './SelectorStatsHandler.js';
+export * as UserInteractions from './UserInteractionsHandler.js';
+export * as UserTimings from './UserTimingsHandler.js';
+export * as Warnings from './WarningsHandler.js';
+export * as Workers from './WorkersHandler.js';

package/dist/lib/front_end/models/trace/handlers/NetworkRequestsHandler.d.ts

@@ -0,0 +1,56 @@
+import * as Types from '../types/types.js';
+import * as HandlerHelpers from './helpers.js';
+import type { HandlerName } from './types.js';
+/**
+ * Network requests from traces are actually formed of 5 trace records.
+ * This handler tracks all trace records based on the request ID, and
+ * then creates a new synthetic trace event for those network requests.
+ *
+ * This interface, then, defines the shape of the object we intend to
+ * keep for each request in the trace. In the finalize we will convert
+ * these 5 types of trace records to a synthetic complete event that
+ * represents a composite of these trace records.
+ **/
+export interface TraceEventsForNetworkRequest {
+    changePriority?: Types.Events.ResourceChangePriority;
+    willSendRequests?: Types.Events.ResourceWillSendRequest[];
+    sendRequests?: Types.Events.ResourceSendRequest[];
+    receiveResponse?: Types.Events.ResourceReceiveResponse;
+    resourceFinish?: Types.Events.ResourceFinish;
+    receivedData?: Types.Events.ResourceReceivedData[];
+    resourceMarkAsCached?: Types.Events.ResourceMarkAsCached;
+    preloadRenderBlockingStatusChange?: Types.Events.PreloadRenderBlockingStatusChangeEvent[];
+}
+export interface WebSocketTraceDataForFrame {
+    frame: string;
+    webSocketIdentifier: number;
+    events: Types.Events.WebSocketEvent[];
+    syntheticConnection: Types.Events.SyntheticWebSocketConnection | null;
+}
+export interface WebSocketTraceDataForWorker {
+    workerId: string;
+    webSocketIdentifier: number;
+    events: Types.Events.WebSocketEvent[];
+    syntheticConnection: Types.Events.SyntheticWebSocketConnection | null;
+}
+export type WebSocketTraceData = WebSocketTraceDataForFrame | WebSocketTraceDataForWorker;
+interface NetworkRequestData {
+    byId: Map<string, Types.Events.SyntheticNetworkRequest>;
+    byTime: Types.Events.SyntheticNetworkRequest[];
+    requestIdsByURL: Map<string, string[]>;
+    /**
+     * IMPORTANT: you should prefer to use `Trace.Extras.Initiator` to find the initiator.
+     * This is because backend trace events have some bugs which means the initiators are not always accurate.
+     * See crrev.com/c/7032169 for context.
+     */
+    incompleteInitiator: Map<Types.Events.SyntheticNetworkRequest, Types.Events.SyntheticNetworkRequest>;
+    webSocket: WebSocketTraceData[];
+    entityMappings: HandlerHelpers.EntityMappings;
+    linkPreconnectEvents: Types.Events.LinkPreconnect[];
+}
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): NetworkRequestData;
+export declare function deps(): HandlerName[];
+export {};

package/dist/lib/front_end/models/trace/handlers/PageFramesHandler.d.ts

@@ -0,0 +1,8 @@
+import * as Types from '../types/types.js';
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export interface PageFrameData {
+    frames: Map<string, Types.Events.TraceFrame>;
+}
+export declare function data(): PageFrameData;

package/dist/lib/front_end/models/trace/handlers/PageLoadMetricsHandler.d.ts

@@ -0,0 +1,86 @@
+import * as Types from '../types/types.js';
+import type { HandlerName } from './types.js';
+type AnyNavigationStart = Types.Events.NavigationStart | Types.Events.SoftNavigationStart;
+export declare function reset(): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function getFrameIdForPageLoadEvent(event: Types.Events.PageLoadEvent): string;
+/**
+ * Classifications sourced from
+ * https://web.dev/fcp/
+ */
+export declare function scoreClassificationForFirstContentfulPaint(fcpScoreInMicroseconds: Types.Timing.Micro): ScoreClassification;
+/**
+ * Classifications sourced from
+ * https://web.dev/interactive/#how-lighthouse-determines-your-tti-score
+ */
+export declare function scoreClassificationForTimeToInteractive(ttiTimeInMicroseconds: Types.Timing.Micro): ScoreClassification;
+/**
+ * Classifications sourced from
+ * https://web.dev/lcp/#what-is-lcp
+ */
+export declare function scoreClassificationForLargestContentfulPaint(lcpTimeInMicroseconds: Types.Timing.Micro): ScoreClassification;
+/**
+ * DCL does not have a classification.
+ */
+export declare function scoreClassificationForDOMContentLoaded(_dclTimeInMicroseconds: Types.Timing.Micro): ScoreClassification;
+/**
+ * Classifications sourced from
+ * https://web.dev/lighthouse-total-blocking-#time/
+ */
+export declare function scoreClassificationForTotalBlockingTime(tbtTimeInMicroseconds: Types.Timing.Micro): ScoreClassification;
+export declare function finalize(): Promise<void>;
+export interface PageLoadMetricsData {
+    /**
+     * This represents the metric scores for all navigations, for all frames in a trace.
+     * Given a frame id, the map points to another map from navigation id to metric scores.
+     * The metric scores include the event related to the metric as well as the data regarding
+     * the score itself.
+     *
+     * Includes soft navigations.
+     */
+    metricScoresByFrameId: Map<string, Map<AnyNavigationStart, Map<MetricName, MetricScore>>>;
+    /**
+     * Page load events with no associated duration that happened in the
+     * main frame.
+     */
+    allMarkerEvents: Types.Events.PageLoadEvent[];
+    /**
+     * MetaCharsetCheck events grouped by navigation.
+     */
+    metaCharsetCheckEventsByNavigation: Map<AnyNavigationStart, Types.Events.MetaCharsetCheck[]>;
+}
+export declare function data(): PageLoadMetricsData;
+export declare function deps(): HandlerName[];
+export declare const enum ScoreClassification {
+    GOOD = "good",
+    OK = "ok",
+    BAD = "bad",
+    UNCLASSIFIED = "unclassified"
+}
+export declare const enum MetricName {
+    FCP = "FCP",
+    FP = "FP",
+    L = "L",
+    LCP = "LCP",
+    DCL = "DCL",
+    TTI = "TTI",
+    TBT = "TBT",
+    CLS = "CLS",
+    NAV = "Nav",
+    SOFT_NAV = "Nav*",
+    SOFT_LCP = "LCP*"
+}
+export interface MetricScore {
+    metricName: MetricName;
+    classification: ScoreClassification;
+    event?: Types.Events.PageLoadEvent;
+    navigation?: AnyNavigationStart;
+    estimated?: boolean;
+    timing: Types.Timing.Micro;
+}
+export type LCPMetricScore = MetricScore & {
+    event: Types.Events.LargestContentfulPaintCandidate;
+    metricName: MetricName.LCP;
+};
+export declare function metricIsLCP(metric: MetricScore): metric is LCPMetricScore;
+export {};