devtools-tracing 1.2.0 → 1.2.2

package/dist/lib/front_end/models/trace/LanternComputationData.d.ts

@@ -0,0 +1,8 @@
+import * as Handlers from './handlers/handlers.js';
+import * as Lantern from './lantern/lantern.js';
+import type * as Types from './types/types.js';
+type NetworkRequest = Lantern.Types.NetworkRequest<Types.Events.SyntheticNetworkRequest>;
+declare function createProcessedNavigation(data: Handlers.Types.HandlerData, frameId: string, navigation: Types.Events.NavigationStart): Lantern.Types.Simulation.ProcessedNavigation;
+declare function createNetworkRequests(trace: Lantern.Types.Trace, data: Handlers.Types.HandlerData, startTime?: number, endTime?: number): NetworkRequest[];
+declare function createGraph(requests: Lantern.Types.NetworkRequest[], trace: Lantern.Types.Trace, data: Handlers.Types.HandlerData, url?: Lantern.Types.Simulation.URL): Lantern.Graph.Node<Types.Events.SyntheticNetworkRequest>;
+export { createGraph, createNetworkRequests, createProcessedNavigation, };

package/dist/lib/front_end/models/trace/ModelImpl.d.ts

@@ -0,0 +1,103 @@
+import * as Handlers from './handlers/handlers.js';
+import * as Helpers from './helpers/helpers.js';
+import type * as Insights from './insights/insights.js';
+import * as Types from './types/types.js';
+/**
+ * The Model is responsible for parsing arrays of raw trace events and storing the
+ * resulting data. It can store multiple traces at once, and can return the data for
+ * any of them.
+ *
+ * Most uses of this class should be through `createWithAllHandlers`, but
+ * `createWithSubsetOfHandlers` can be used to run just some handlers.
+ **/
+export declare class Model extends EventTarget {
+    #private;
+    static createWithAllHandlers(config?: Types.Configuration.Configuration): Model;
+    /**
+     * Runs only the provided handlers.
+     *
+     * Callers must ensure they are providing all dependant handlers (although Meta is included automatically),
+     * and must know that the result of `.parsedTrace` will be limited to the handlers provided, even though
+     * the type won't reflect that.
+     */
+    static createWithSubsetOfHandlers(traceHandlers: Partial<Handlers.Types.Handlers>, config?: Types.Configuration.Configuration): Model;
+    constructor(handlers: Handlers.Types.Handlers, config?: Types.Configuration.Configuration);
+    /**
+     * Parses an array of trace events into a structured object containing all the
+     * information parsed by the trace handlers.
+     * You can `await` this function to pause execution until parsing is complete,
+     * or instead rely on the `ModuleUpdateEvent` that is dispatched when the
+     * parsing is finished.
+     *
+     * Once parsed, you then have to call the `parsedTrace` method, providing an
+     * index of the trace you want to have the data for. This is because any model
+     * can store a number of traces. Each trace is given an index, which starts at 0
+     * and increments by one as a new trace is parsed.
+     *
+     * @example
+     * // Awaiting the parse method() to block until parsing complete
+     * await this.traceModel.parse(events);
+     * const data = this.traceModel.parsedTrace(0)
+     * @example
+     * // Using an event listener to be notified when tracing is complete.
+     * this.traceModel.addEventListener(Trace.ModelUpdateEvent.eventName, (event) => {
+     *   if(event.data.data === 'done') {
+     *     // trace complete
+     *     const data = this.traceModel.parsedTrace(0);
+     *   }
+     * });
+     * void this.traceModel.parse(events);
+     **/
+    parse(traceEvents: readonly Types.Events.Event[], config?: Types.Configuration.ParseOptions): Promise<void>;
+    lastTraceIndex(): number;
+    /**
+     * Returns the parsed trace data indexed by the order in which it was stored.
+     * If no index is given, the last stored parsed data is returned.
+     */
+    parsedTrace(index?: number): ParsedTrace | null;
+    overrideModifications(index: number, newModifications: Types.File.Modifications): void;
+    syntheticTraceEventsManager(index?: number): Helpers.SyntheticEvents.SyntheticEventsManager | null;
+    size(): number;
+    deleteTraceByIndex(recordingIndex: number): void;
+    indexForTrace(trace: ParsedTrace): number;
+    getRecordingsAvailable(): string[];
+    resetProcessor(): void;
+}
+/**
+ * This parsed trace is used by the Model. It keeps multiple instances
+ * of these so that the user can swap between them. The key is that it is
+ * essentially the TraceFile plus whatever the model has parsed from it.
+ */
+export type ParsedTrace = Types.File.TraceFile & {
+    data: Handlers.Types.HandlerData;
+    /** Is null for CPU profiles. */
+    insights: Insights.Types.TraceInsightSets | null;
+    syntheticEventsManager: Helpers.SyntheticEvents.SyntheticEventsManager;
+};
+export declare const enum ModelUpdateType {
+    COMPLETE = "COMPLETE",
+    PROGRESS_UPDATE = "PROGRESS_UPDATE"
+}
+export type ModelUpdateEventData = ModelUpdateEventComplete | ModelUpdateEventProgress;
+export interface ModelUpdateEventComplete {
+    type: ModelUpdateType.COMPLETE;
+    data: 'done';
+}
+export interface ModelUpdateEventProgress {
+    type: ModelUpdateType.PROGRESS_UPDATE;
+    data: TraceParseEventProgressData;
+}
+export interface TraceParseEventProgressData {
+    percent: number;
+}
+export declare class ModelUpdateEvent extends Event {
+    data: ModelUpdateEventData;
+    static readonly eventName = "modelupdate";
+    constructor(data: ModelUpdateEventData);
+}
+declare global {
+    interface HTMLElementEventMap {
+        [ModelUpdateEvent.eventName]: ModelUpdateEvent;
+    }
+}
+export declare function isModelUpdateDataComplete(eventData: ModelUpdateEventData): eventData is ModelUpdateEventComplete;

package/dist/lib/front_end/models/trace/Name.d.ts

@@ -0,0 +1,12 @@
+import type { ParsedTrace } from './ModelImpl.js';
+import * as Types from './types/types.js';
+/**
+ * Calculates the display name for a given entry.
+ * @param parsedTrace If the trace data is provided
+ * as the second argument it can be used to find source map resolved names for
+ * profile calls.
+ * Use this function to customize the user visible name for an entry. If no
+ * custom name is found, we will fallback to the `name` property in the trace
+ * entry.
+ */
+export declare function forEntry(entry: Types.Events.Event, parsedTrace?: ParsedTrace): string;

package/dist/lib/front_end/models/trace/Processor.d.ts

@@ -0,0 +1,39 @@
+import * as Handlers from './handlers/handlers.js';
+import * as Insights from './insights/insights.js';
+import type * as Model from './ModelImpl.js';
+import * as Types from './types/types.js';
+export declare class TraceParseProgressEvent extends Event {
+    data: Model.TraceParseEventProgressData;
+    static readonly eventName = "traceparseprogress";
+    constructor(data: Model.TraceParseEventProgressData, init?: EventInit);
+}
+declare global {
+    interface HTMLElementEventMap {
+        [TraceParseProgressEvent.eventName]: TraceParseProgressEvent;
+    }
+}
+export declare class TraceProcessor extends EventTarget {
+    #private;
+    static createWithAllHandlers(): TraceProcessor;
+    /**
+     * This function is kept for testing with `stub`.
+     */
+    static getInsightRunners(): Insights.Types.InsightModelsType;
+    constructor(traceHandlers: Partial<Handlers.Types.Handlers>, modelConfiguration?: Types.Configuration.Configuration);
+    reset(): void;
+    parse(traceEvents: readonly Types.Events.Event[], options: Types.Configuration.ParseOptions): Promise<void>;
+    get data(): Handlers.Types.HandlerData | null;
+    get insights(): Insights.Types.TraceInsightSets | null;
+    /**
+     * Sort the insight models based on the impact of each insight's estimated savings, additionally weighted by the
+     * worst metrics according to field data (if present).
+     */
+    sortInsightSet(insightSet: Insights.Types.InsightSet, metadata: Types.File.MetaData | null): void;
+}
+/**
+ * Some Handlers need data provided by others. Dependencies of a handler handler are
+ * declared in the `deps` field.
+ * @returns A map from trace event handler name to trace event handler whose entries
+ * iterate in such a way that each handler is visited after its dependencies.
+ */
+export declare function sortHandlers(traceHandlers: Partial<Record<Handlers.Types.HandlerName, Handlers.Types.Handler>>): Map<Handlers.Types.HandlerName, Handlers.Types.Handler>;

package/dist/lib/front_end/models/trace/Styles.d.ts

@@ -0,0 +1,50 @@
+import type * as Platform from '../../core/platform/platform.js';
+import * as Types from './types/types.js';
+export declare enum EventCategory {
+    DRAWING = "drawing",
+    RASTERIZING = "rasterizing",
+    LAYOUT = "layout",
+    LOADING = "loading",
+    EXPERIENCE = "experience",
+    SCRIPTING = "scripting",
+    MESSAGING = "messaging",
+    RENDERING = "rendering",
+    PAINTING = "painting",
+    GPU = "gpu",
+    ASYNC = "async",
+    OTHER = "other",
+    IDLE = "idle"
+}
+export declare class TimelineRecordStyle {
+    title: string;
+    category: TimelineCategory;
+    hidden: boolean;
+    constructor(title: string, category: TimelineCategory, hidden?: boolean | undefined);
+}
+export declare class TimelineCategory {
+    #private;
+    name: EventCategory;
+    title: Platform.UIString.LocalizedString;
+    visible: boolean;
+    constructor(name: EventCategory, title: Platform.UIString.LocalizedString, visible: boolean, cssVariable: `--app-color-${string}`);
+    get hidden(): boolean;
+    get cssVariable(): string;
+    getCSSValue(): string;
+    set hidden(hidden: boolean);
+}
+export type CategoryPalette = Record<EventCategory, TimelineCategory>;
+type EventStylesMap = Partial<Record<Types.Events.Name, TimelineRecordStyle>>;
+export declare function getEventStyle(eventName: Types.Events.Name): TimelineRecordStyle | undefined;
+export declare function stringIsEventCategory(it: string): it is EventCategory;
+export declare function getCategoryStyles(): CategoryPalette;
+export declare function maybeInitSylesMap(): EventStylesMap;
+export declare function setEventStylesMap(eventStyles: EventStylesMap): void;
+export declare function setCategories(cats: CategoryPalette): void;
+export declare function visibleTypes(): string[];
+export declare function getTimelineMainEventCategories(): EventCategory[];
+export declare function setTimelineMainEventCategories(categories: EventCategory[]): void;
+export declare function markerDetailsForEvent(event: Types.Events.Event): {
+    color: string;
+    title: string;
+};
+export {};

package/dist/lib/front_end/models/trace/extras/FilmStrip.d.ts

@@ -0,0 +1,19 @@
+import type * as Handlers from '../handlers/handlers.js';
+import type * as Types from '../types/types.js';
+export interface Data {
+    zeroTime: Types.Timing.Micro;
+    spanTime: Types.Timing.Micro;
+    frames: readonly Frame[];
+}
+export interface Frame {
+    screenshotEvent: Types.Events.LegacySyntheticScreenshot | Types.Events.Screenshot;
+    index: number;
+}
+export type HandlersWithFilmStrip = Handlers.Types.HandlersWithMeta<{
+    Screenshots: typeof Handlers.ModelHandlers.Screenshots;
+}>;
+export type HandlerDataWithScreenshots = Handlers.Types.EnabledHandlerDataWithMeta<{
+    Screenshots: typeof Handlers.ModelHandlers.Screenshots;
+}>;
+export declare function fromHandlerData(data: HandlerDataWithScreenshots, customZeroTime?: Types.Timing.Micro): Data;
+export declare function frameClosestToTimestamp(filmStrip: Data, searchTimestamp: Types.Timing.Micro): Frame | null;

package/dist/lib/front_end/models/trace/extras/Initiators.d.ts

@@ -0,0 +1,12 @@
+import type * as Handlers from '../handlers/handlers.js';
+import type * as Types from '../types/types.js';
+/**
+ * There are bugs in the backend tracing that means that network requests are
+ * often incorrectly tied to an initiator. This function exists as a utility to
+ * look up an event's initiator regardless of the type of event, but also to
+ * provide a post-parsing fix for network initiators.
+ * The TL;DR is that images injected by a script will incorrectly have their
+ * initiator set to the root document. To fix this, we look at the stack trace
+ * when the request was sent, and use that.
+ */
+export declare function getNetworkInitiator(data: Handlers.Types.HandlerData, event: Types.Events.SyntheticNetworkRequest): Types.Events.SyntheticNetworkRequest | undefined;

package/dist/lib/front_end/models/trace/extras/MainThreadActivity.d.ts

@@ -0,0 +1,2 @@
+import * as Types from '../types/types.js';
+export declare function calculateWindow(traceBounds: Types.Timing.TraceWindowMicro, mainThreadEntries: readonly Types.Events.Event[]): Types.Timing.TraceWindowMicro;

package/dist/lib/front_end/models/trace/extras/ScriptDuplication.d.ts

@@ -0,0 +1,52 @@
+import * as Handlers from '../handlers/handlers.js';
+export declare function normalizeSource(source: string): string;
+/**
+ * The key is a source map `sources` entry (these are URLs/file paths), but normalized
+ * via `normalizeSource`.
+ *
+ * The value is an object with an entry for every script that has a source map which
+ * denotes that this source was used, along with the estimated resource size it takes
+ * up in the script.
+ */
+export type ScriptDuplication = Map<string, {
+    /**
+     * This is the sum of all (but one) `attributedSize` in `scripts`.
+     *
+     * One copy of this module is treated as the canonical version - the rest will
+     * have non-zero `wastedBytes`. The canonical copy is the first entry of
+     * `scripts`.
+     *
+     * In the case of all copies being the same version, all sizes are
+     * equal and the selection doesn't matter (ignoring compression ratios). When
+     * the copies are different versions, it does matter. Ideally the newest
+     * version would be the canonical copy, but version information is not present.
+     * Instead, size is used as a heuristic for latest version. This makes the
+     * value here conserative in its estimation.
+     */
+    estimatedDuplicateBytes: number;
+    duplicates: Array<{
+        script: Handlers.ModelHandlers.Scripts.Script;
+        /**
+         * The number of bytes in the script bundle that map back to this module,
+         * in terms of estimated impact on transfer size.
+         */
+        attributedSize: number;
+    }>;
+}>;
+/**
+ * Sorts each array within @see ScriptDuplication by attributedSize, drops information
+ * on sources that are too small, and calculates esimatedDuplicateBytes.
+ */
+export declare function normalizeDuplication(duplication: ScriptDuplication): void;
+export declare function getNodeModuleName(source: string): string;
+/**
+ * Returns 2 @see ScriptDuplication for the given collection of script contents + source maps:
+ *
+ * 1. `duplication` keys correspond to authored files
+ * 2. `duplication` keys correspond to authored files, except all files within the same
+ *    node_module package are aggregated under the same entry.
+ */
+export declare function computeScriptDuplication(scriptsData: Handlers.ModelHandlers.Scripts.ScriptsData, compressionRatios: Map<string, number>): {
+    duplication: ScriptDuplication;
+    duplicationGroupedByNodeModules: ScriptDuplication;
+};

package/dist/lib/front_end/models/trace/extras/StackTraceForEvent.d.ts

@@ -0,0 +1,12 @@
+import type * as Protocol from '../../../generated/protocol.js';
+import type * as Handlers from '../handlers/handlers.js';
+import * as Types from '../types/types.js';
+export declare const stackTraceForEventInTrace: Map<Readonly<Handlers.Types.EnabledHandlerDataWithMeta<typeof Handlers.ModelHandlers>>, Map<Types.Events.Event, Protocol.Runtime.StackTrace>>;
+export declare function clearCacheForTrace(data: Handlers.Types.HandlerData): void;
+/**
+ * This util builds a stack trace that includes async calls for a given
+ * event. It leverages data we collect from sampling to deduce sync
+ * stacks and trace event instrumentation on the V8 debugger to stitch
+ * them together.
+ */
+export declare function get(event: Types.Events.Event, data: Handlers.Types.HandlerData): Protocol.Runtime.StackTrace | null;

package/dist/lib/front_end/models/trace/extras/ThirdParties.d.ts

@@ -0,0 +1,22 @@
+import type * as ThirdPartyWeb from '../../../third_party/third-party-web/third-party-web.js';
+import * as Handlers from '../handlers/handlers.js';
+import * as Types from '../types/types.js';
+export type Entity = typeof ThirdPartyWeb.ThirdPartyWeb.entities[number];
+interface BaseSummary {
+    entity: Entity;
+    transferSize: number;
+    mainThreadTime: Types.Timing.Milli;
+}
+export interface EntitySummary extends BaseSummary {
+    relatedEvents: Types.Events.Event[];
+}
+export interface URLSummary extends BaseSummary {
+    url: string;
+    request?: Types.Events.SyntheticNetworkRequest;
+}
+export declare function summarizeByThirdParty(data: Handlers.Types.HandlerData, traceBounds: Types.Timing.TraceWindowMicro): EntitySummary[];
+/**
+ * Used only by Lighthouse.
+ */
+export declare function summarizeByURL(data: Handlers.Types.HandlerData, traceBounds: Types.Timing.TraceWindowMicro): URLSummary[];
+export {};

package/dist/lib/front_end/models/trace/extras/TraceFilter.d.ts

@@ -0,0 +1,21 @@
+import type * as Handlers from '../handlers/handlers.js';
+import * as Types from '../types/types.js';
+export declare abstract class TraceFilter {
+    abstract accept(_event: Types.Events.Event, handlerData?: Handlers.Types.HandlerData): boolean;
+}
+export declare class VisibleEventsFilter extends TraceFilter {
+    private readonly visibleTypes;
+    constructor(visibleTypes: string[]);
+    accept(event: Types.Events.Event): boolean;
+    static eventType(event: Types.Events.Event): Types.Events.Name;
+}
+export declare class InvisibleEventsFilter extends TraceFilter {
+    #private;
+    constructor(invisibleTypes: Types.Events.Name[]);
+    accept(event: Types.Events.Event): boolean;
+}
+export declare class ExclusiveNameFilter extends TraceFilter {
+    #private;
+    constructor(excludeNames: Types.Events.Name[]);
+    accept(event: Types.Events.Event): boolean;
+}

package/dist/lib/front_end/models/trace/extras/TraceTree.d.ts

@@ -0,0 +1,125 @@
+import type * as Protocol from '../../../generated/protocol.js';
+import * as Types from '../types/types.js';
+import type { TraceFilter } from './TraceFilter.js';
+export declare class Node {
+    /** ms */
+    totalTime: number;
+    /** ms */
+    selfTime: number;
+    transferSize: number;
+    id: string | symbol;
+    /** The first trace event encountered that necessitated the creation of this tree node. */
+    event: Types.Events.Event;
+    /**
+     * All of the trace events associated with this aggregate node.
+     * Minor: In the case of Event Log (EventsTimelineTreeView), the node is not aggregate and this will only hold 1 event, the same that's in this.event
+     */
+    events: Types.Events.Event[];
+    parent: Node | null;
+    groupId: string;
+    isGroupNodeInternal: boolean;
+    depth: number;
+    constructor(id: string | symbol, event: Types.Events.Event);
+    isGroupNode(): boolean;
+    hasChildren(): boolean;
+    setHasChildren(_value: boolean): void;
+    /**
+     * Returns the direct descendants of this node.
+     * @returns a map with ordered <nodeId, Node> tuples.
+     */
+    children(): ChildrenCache;
+    searchTree(matchFunction: (arg0: Types.Events.Event) => boolean, results?: Node[]): Node[];
+}
+export declare class TopDownNode extends Node {
+    root: TopDownRootNode | null;
+    private hasChildrenInternal;
+    childrenInternal: ChildrenCache | null;
+    parent: TopDownNode | null;
+    constructor(id: string | symbol, event: Types.Events.Event, parent: TopDownNode | null);
+    hasChildren(): boolean;
+    setHasChildren(value: boolean): void;
+    children(): ChildrenCache;
+    private buildChildren;
+}
+export declare class TopDownRootNode extends TopDownNode {
+    readonly filter: (e: Types.Events.Event) => boolean;
+    readonly startTime: Types.Timing.Milli;
+    readonly endTime: Types.Timing.Milli;
+    eventGroupIdCallback: ((arg0: Types.Events.Event) => string) | null | undefined;
+    /** Default behavior is to aggregate similar trace events into one Node based on generateEventID(), eventGroupIdCallback(), etc. Set true to keep nodes 1:1 with events. */
+    readonly doNotAggregate: boolean | undefined;
+    readonly includeInstantEvents?: boolean;
+    totalTime: number;
+    selfTime: number;
+    constructor(events: Types.Events.Event[], { filters, startTime, endTime, doNotAggregate, eventGroupIdCallback, includeInstantEvents }: {
+        filters: TraceFilter[];
+        startTime: Types.Timing.Milli;
+        endTime: Types.Timing.Milli;
+        doNotAggregate?: boolean;
+        eventGroupIdCallback?: ((arg0: Types.Events.Event) => string) | null;
+        includeInstantEvents?: boolean;
+    });
+    children(): ChildrenCache;
+    private grouppedTopNodes;
+    getEventGroupIdCallback(): ((arg0: Types.Events.Event) => string) | null | undefined;
+}
+export declare class BottomUpRootNode extends Node {
+    private childrenInternal;
+    private textFilter;
+    readonly filter: (e: Types.Events.Event) => boolean;
+    readonly startTime: Types.Timing.Milli;
+    readonly endTime: Types.Timing.Milli;
+    totalTime: number;
+    eventGroupIdCallback: ((arg0: Types.Events.Event) => string) | null | undefined;
+    private calculateTransferSize?;
+    private forceGroupIdCallback?;
+    constructor(events: Types.Events.Event[], { textFilter, filters, startTime, endTime, eventGroupIdCallback, calculateTransferSize, forceGroupIdCallback, }: {
+        textFilter: TraceFilter;
+        filters: readonly TraceFilter[];
+        startTime: Types.Timing.Milli;
+        endTime: Types.Timing.Milli;
+        eventGroupIdCallback?: ((arg0: Types.Events.Event) => string) | null;
+        calculateTransferSize?: boolean;
+        /**
+         * This forces using `eventGroupIdCallback` in combination with generateEventID
+         * to generate the ID of the node.
+         *
+         * This is used in the ThirdPartyTreeView and BottomUpTreeView, where we want to group all events
+         * related to a specific 3P entity together, regardless of the specific event name/type.
+         * There are cases where events under the same event name belong to different entities. But, because
+         * they get grouped first by event name/type, it throws off the 3P groupBy - grouping events of different
+         * 3P entities together.
+         */
+        forceGroupIdCallback?: boolean;
+    });
+    hasChildren(): boolean;
+    filterChildren(children: ChildrenCache): ChildrenCache;
+    children(): ChildrenCache;
+    private ungroupedTopNodes;
+    private grouppedTopNodes;
+}
+export declare class GroupNode extends Node {
+    private readonly childrenInternal;
+    isGroupNodeInternal: boolean;
+    events: Types.Events.Event[];
+    constructor(id: string, parent: BottomUpRootNode | TopDownRootNode, events: Types.Events.Event[]);
+    addChild(child: BottomUpNode, selfTime: number, totalTime: number, transferSize: number): void;
+    hasChildren(): boolean;
+    children(): ChildrenCache;
+}
+export declare class BottomUpNode extends Node {
+    parent: Node;
+    private root;
+    depth: number;
+    private cachedChildren;
+    private hasChildrenInternal;
+    constructor(root: BottomUpRootNode, id: string, event: Types.Events.Event, hasChildren: boolean, parent: Node);
+    hasChildren(): boolean;
+    setHasChildren(value: boolean): void;
+    children(): ChildrenCache;
+    searchTree(matchFunction: (arg0: Types.Events.Event) => boolean, results?: Node[]): Node[];
+}
+export declare function eventStackFrame(event: Types.Events.Event): Protocol.Runtime.CallFrame | null;
+/** TODO(paulirish): rename to generateNodeId **/
+export declare function generateEventID(event: Types.Events.Event): string;
+export type ChildrenCache = Map<string | symbol, Node>;

package/dist/lib/front_end/models/trace/extras/extras.d.ts

@@ -0,0 +1,8 @@
+export * as FilmStrip from './FilmStrip.js';
+export * as Initiators from './Initiators.js';
+export * as MainThreadActivity from './MainThreadActivity.js';
+export * as ScriptDuplication from './ScriptDuplication.js';
+export * as StackTraceForEvent from './StackTraceForEvent.js';
+export * as ThirdParties from './ThirdParties.js';
+export * as TraceFilter from './TraceFilter.js';
+export * as TraceTree from './TraceTree.js';

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

@@ -0,0 +1,12 @@
+import * as Types from '../types/types.js';
+import type { HandlerName } from './types.js';
+export interface Data {
+    animationFrames: Types.Events.SyntheticAnimationFramePair[];
+    presentationForFrame: Map<Types.Events.SyntheticAnimationFramePair, Types.Events.AnimationFramePresentation>;
+}
+export declare function reset(): void;
+export declare function handleUserConfig(config: Types.Configuration.Configuration): void;
+export declare function handleEvent(event: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): Data;
+export declare function deps(): HandlerName[];

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

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

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

@@ -0,0 +1,20 @@
+import * as Types from '../types/types.js';
+declare let schedulerToRunEntryPoints: Map<Types.Events.Event, Types.Events.Event[]>;
+declare let asyncCallToScheduler: Map<Types.Events.SyntheticProfileCall, {
+    taskName: string;
+    scheduler: Types.Events.Event;
+}>;
+declare let runEntryPointToScheduler: Map<Types.Events.Event, {
+    taskName: string;
+    scheduler: Types.Events.Event;
+}>;
+export declare function reset(): void;
+export declare function handleEvent(_: Types.Events.Event): void;
+export declare function finalize(): Promise<void>;
+export declare function data(): {
+    schedulerToRunEntryPoints: typeof schedulerToRunEntryPoints;
+    asyncCallToScheduler: typeof asyncCallToScheduler;
+    runEntryPointToScheduler: typeof runEntryPointToScheduler;
+};
+export declare function deps(): ['Renderer', 'Flows'];
+export {};

package/dist/lib/front_end/models/trace/handlers/AuctionWorkletsHandler.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 AuctionWorkletsData {
+    worklets: Map<Types.Events.ProcessID, Types.Events.SyntheticAuctionWorklet>;
+}
+export declare function data(): AuctionWorkletsData;

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

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