devtools-tracing 1.2.1 → 1.2.2

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

@@ -0,0 +1,6 @@
+export * as Configuration from './Configuration.js';
+export * as Extensions from './Extensions.js';
+export * as File from './File.js';
+export * as Overlays from './Overlays.js';
+export * as Timing from './Timing.js';
+export * as Events from './TraceEvents.js';

package/dist/lib/front_end/third_party/i18n/i18n-impl.d.ts

@@ -0,0 +1,25 @@
+import { RegisteredFileStrings } from './localized-string-set.js';
+export type UIStrings = Record<string, string>;
+export type LocalizedMessages = Record<string, {
+    message: string;
+}>;
+/**
+ * Encapsulates the global state of the i18n runtime.
+ */
+export declare class I18n {
+    readonly supportedLocales: ReadonlySet<Intl.UnicodeBCP47LocaleIdentifier>;
+    private localeData;
+    readonly defaultLocale: any;
+    constructor(supportedLocales: readonly Intl.UnicodeBCP47LocaleIdentifier[], defaultLocale: Intl.UnicodeBCP47LocaleIdentifier);
+    registerLocaleData(locale: Intl.UnicodeBCP47LocaleIdentifier, messages: LocalizedMessages): void;
+    hasLocaleDataForTest(locale: Intl.UnicodeBCP47LocaleIdentifier): boolean;
+    resetLocaleDataForTest(): void;
+    registerFileStrings(filename: string, stringStructure: UIStrings): RegisteredFileStrings;
+    /**
+     * Look up the best available locale for the requested language through these fall backs:
+     * - exact match
+     * - progressively shorter prefixes (`de-CH-1996` -> `de-CH` -> `de`)
+     * - the default locale if no match is found
+     */
+    lookupClosestSupportedLocale(locale: Intl.UnicodeBCP47LocaleIdentifier): Intl.UnicodeBCP47LocaleIdentifier;
+}

package/dist/lib/front_end/third_party/i18n/i18n.d.ts

@@ -0,0 +1,3 @@
+import * as I18n from './i18n-impl.js';
+import * as LocalizedStringSet from './localized-string-set.js';
+export { I18n, LocalizedStringSet, };

package/dist/lib/front_end/third_party/i18n/localized-string-set.d.ts

@@ -0,0 +1,49 @@
+import type { LocalizedMessages, UIStrings } from './i18n-impl.js';
+import * as IntlMessageFormat from '../intl-messageformat/intl-messageformat.js';
+/**
+ * This class is usually created at module instantiation time and
+ * holds the filename, the UIStrings object and a reference to
+ * all the localization data.
+ *
+ * Later, once needed, users can request a `LocalizedStringSet` that represents
+ * all the translated strings, in a given locale for the specific file and
+ * UIStrings object.
+ *
+ * Please note that this class is implemented with invariant in mind that the
+ * DevTools locale never changes. Otherwise we would have to use a Map as
+ * the cache. For performance reasons, we store the single possible map entry
+ * as a property directly.
+ *
+ * The DevTools locale CANNOT be passed via the constructor. When instances
+ * of `RegisteredFileStrings` are created, the DevTools locale has not yet
+ * been determined.
+ */
+export declare class RegisteredFileStrings {
+    private filename;
+    private stringStructure;
+    private localizedMessages;
+    private localizedStringSet?;
+    constructor(filename: string, stringStructure: UIStrings, localizedMessages: Map<Intl.UnicodeBCP47LocaleIdentifier, LocalizedMessages>);
+    getLocalizedStringSetFor(locale: Intl.UnicodeBCP47LocaleIdentifier): LocalizedStringSet;
+}
+export type Values = Record<string, string | number | boolean>;
+/**
+ * A set of translated strings for a single file in a specific locale.
+ *
+ * The class is a wrapper around `IntlMessageFormat#format` plus a cache
+ * to speed up consecutive lookups of the same message.
+ */
+export declare class LocalizedStringSet {
+    private filename;
+    private stringStructure;
+    private localizedMessages;
+    private readonly cachedSimpleStrings;
+    private readonly cachedMessageFormatters;
+    /** For pseudo locales, use 'de-DE' for number formatting */
+    private readonly localeForFormatter;
+    constructor(filename: string, stringStructure: UIStrings, locale: Intl.UnicodeBCP47LocaleIdentifier, localizedMessages: LocalizedMessages);
+    getLocalizedString(message: string, values?: Values): string;
+    getMessageFormatterFor(message: string): IntlMessageFormat.IntlMessageFormat;
+    private getSimpleLocalizedString;
+    private getFormattedLocalizedString;
+}

package/dist/lib/front_end/third_party/intl-messageformat/intl-messageformat.d.ts

@@ -0,0 +1,2 @@
+import IntlMessageFormat from './package/intl-messageformat.esm.js';
+export { IntlMessageFormat };

package/dist/lib/front_end/third_party/legacy-javascript/legacy-javascript.d.ts

@@ -0,0 +1,2 @@
+import * as LegacyJavaScript from './lib/legacy-javascript.js';
+export { LegacyJavaScript };

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/builder/builder.d.ts

@@ -0,0 +1,67 @@
+import type { Binding, GeneratedRange, OriginalPosition, OriginalScope, ScopeInfo } from "../scopes.ts";
+/**
+ * Small utility class to build scope and range trees.
+ *
+ * This class allows construction of scope/range trees that will be rejected by the encoder.
+ * Use this class if you guarantee proper nesting yourself and don't want to pay for the
+ * checks, otherwise use the `SafeScopeInfoBuilder`.
+ *
+ * This class will also silently ignore calls that would fail otherwise. E.g. calling
+ * `end*` without a matching `start*`.
+ */
+export declare class ScopeInfoBuilder {
+    #private;
+    addNullScope(): this;
+    startScope(line: number, column: number, options?: {
+        name?: string;
+        kind?: string;
+        isStackFrame?: boolean;
+        variables?: string[];
+        key?: ScopeKey;
+    }): this;
+    setScopeName(name: string): this;
+    setScopeKind(kind: string): this;
+    setScopeStackFrame(isStackFrame: boolean): this;
+    setScopeVariables(variables: string[]): this;
+    endScope(line: number, column: number): this;
+    /**
+     * @returns The OriginalScope opened with the most recent `startScope` call, but not yet closed.
+     */
+    currentScope(): OriginalScope | null;
+    /**
+     * @returns The most recent OriginalScope closed with `endScope`.
+     */
+    lastScope(): OriginalScope | null;
+    /**
+     * @param option The definition 'scope' of this range can either be the "OriginalScope" directly
+     * (produced by this builder) or the scope's key set while building the scope.
+     */
+    startRange(line: number, column: number, options?: {
+        scope?: OriginalScope;
+        scopeKey?: ScopeKey;
+        isStackFrame?: boolean;
+        isHidden?: boolean;
+        values?: Binding[];
+        callSite?: OriginalPosition;
+    }): this;
+    setRangeDefinitionScope(scope: OriginalScope): this;
+    setRangeDefinitionScopeKey(scopeKey: ScopeKey): this;
+    setRangeStackFrame(isStackFrame: boolean): this;
+    setRangeHidden(isHidden: boolean): this;
+    setRangeValues(values: Binding[]): this;
+    setRangeCallSite(callSite: OriginalPosition): this;
+    endRange(line: number, column: number): this;
+    build(): ScopeInfo;
+    protected get scopeStack(): ReadonlyArray<OriginalScope>;
+    protected get rangeStack(): ReadonlyArray<GeneratedRange>;
+    protected isKnownScope(scope: OriginalScope): boolean;
+    protected isValidScopeKey(key: ScopeKey): boolean;
+    protected getScopeByValidKey(key: ScopeKey): OriginalScope;
+}
+/**
+ * Users of the {@link ScopeInfoBuilder} can provide their own keys to uniquely identify a scope,
+ * and use the key later when building the corresponding range to connect them.
+ *
+ * The only requirement for ScopeKey is that it can be used as a key in a `Map`.
+ */
+export type ScopeKey = unknown;

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/builder/safe_builder.d.ts

@@ -0,0 +1,38 @@
+import type { Binding, OriginalPosition, OriginalScope, ScopeInfo } from "../scopes.ts";
+import { ScopeInfoBuilder, type ScopeKey } from "./builder.js";
+/**
+ * Similar to `ScopeInfoBuilder`, but with checks that scopes/ranges are well
+ * nested and don't partially overlap.
+ */
+export declare class SafeScopeInfoBuilder extends ScopeInfoBuilder {
+    #private;
+    addNullScope(): this;
+    startScope(line: number, column: number, options?: {
+        name?: string;
+        kind?: string;
+        isStackFrame?: boolean;
+        variables?: string[];
+        key?: ScopeKey;
+    }): this;
+    setScopeName(name: string): this;
+    setScopeKind(kind: string): this;
+    setScopeStackFrame(isStackFrame: boolean): this;
+    setScopeVariables(variables: string[]): this;
+    endScope(line: number, column: number): this;
+    startRange(line: number, column: number, options?: {
+        scope?: OriginalScope;
+        scopeKey?: ScopeKey;
+        isStackFrame?: boolean;
+        isHidden?: boolean;
+        values?: Binding[];
+        callSite?: OriginalPosition;
+    }): this;
+    setRangeDefinitionScope(scope: OriginalScope): this;
+    setRangeDefinitionScopeKey(scopeKey: ScopeKey): this;
+    setRangeStackFrame(isStackFrame: boolean): this;
+    setRangeHidden(isHidden: boolean): this;
+    setRangeValues(values: Binding[]): this;
+    setRangeCallSite(callSite: OriginalPosition): this;
+    endRange(line: number, column: number): this;
+    build(): ScopeInfo;
+}

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/codec.d.ts

@@ -0,0 +1,48 @@
+export declare const enum Tag {
+    EMPTY = 0,
+    ORIGINAL_SCOPE_START = 1,
+    ORIGINAL_SCOPE_END = 2,
+    ORIGINAL_SCOPE_VARIABLES = 3,
+    GENERATED_RANGE_START = 4,
+    GENERATED_RANGE_END = 5,
+    GENERATED_RANGE_BINDINGS = 6,
+    GENERATED_RANGE_SUBRANGE_BINDING = 7,
+    GENERATED_RANGE_CALL_SITE = 8,
+    VENDOR_EXTENSION = 99
+}
+export declare const enum EncodedTag {
+    EMPTY = "A",// 0x0
+    ORIGINAL_SCOPE_START = "B",// 0x1
+    ORIGINAL_SCOPE_END = "C",// 0x2
+    ORIGINAL_SCOPE_VARIABLES = "D",// 0x3
+    GENERATED_RANGE_START = "E",// 0x4
+    GENERATED_RANGE_END = "F",// 0x5
+    GENERATED_RANGE_BINDINGS = "G",// 0x6
+    GENERATED_RANGE_SUBRANGE_BINDING = "H",// 0x7
+    GENERATED_RANGE_CALL_SITE = "I",// 0x8
+    VENDOR_EXTENSION = "/"
+}
+export declare const enum OriginalScopeFlags {
+    HAS_NAME = 1,
+    HAS_KIND = 2,
+    IS_STACK_FRAME = 4
+}
+export declare const enum GeneratedRangeFlags {
+    HAS_LINE = 1,
+    HAS_DEFINITION = 2,
+    IS_STACK_FRAME = 4,
+    IS_HIDDEN = 8
+}
+export interface OriginalScopeStartItem {
+    flags: number;
+    line: number;
+    column: number;
+    nameIdx?: number;
+    kindIdx?: number;
+}
+export interface GeneratedRangeStartItem {
+    flags: number;
+    line?: number;
+    column: number;
+    definitionIdx?: number;
+}

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/decode/decode.d.ts

@@ -0,0 +1,31 @@
+import type { DecodedScopeInfo, Position, SourceMap } from "../scopes.ts";
+/**
+ * The mode decides how well-formed the encoded scopes have to be, to be accepted by the decoder.
+ *
+ * LAX is the default and is much more lenient. It's still best effort though and the decoder doesn't
+ * implement any error recovery: e.g. superfluous "start" items can lead to whole trees being omitted.
+ *
+ * STRICT mode will throw in the following situations:
+ *
+ *   - Encountering ORIGINAL_SCOPE_END, or GENERATED_RANGE_END items that don't have matching *_START items.
+ *   - Encountering ORIGINAL_SCOPE_VARIABLES items outside a surrounding scope START/END.
+ *   - Encountering GENERATED_RANGE_BINDINGS items outside a surrounding range START/END.
+ *   - Miss-matches between the number of variables in a scope vs the number of value expressions in the ranges.
+ *   - Out-of-bound indices into the "names" array.
+ */
+export declare const enum DecodeMode {
+    STRICT = 1,
+    LAX = 2
+}
+export interface DecodeOptions {
+    mode: DecodeMode;
+    /**
+     * Offsets `start` and `end` of all generated ranges by the specified amount.
+     * Intended to be used when decoding sections of index source maps one-by-one.
+     *
+     * Has no effect when passing a {@link IndexSourceMapJson} directly to {@link decode}.
+     */
+    generatedOffset: Position;
+}
+export declare const DEFAULT_DECODE_OPTIONS: DecodeOptions;
+export declare function decode(sourceMap: SourceMap, options?: Partial<DecodeOptions>): DecodedScopeInfo;

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/encode/encode.d.ts

@@ -0,0 +1,8 @@
+import type { ScopeInfo, SourceMapJson } from "../scopes.ts";
+/**
+ * Encodes the `ScopeInfo` into a source map JSON object.
+ *
+ * If `inputSourceMap` is provided, `encode` will augment the "names" array and
+ * overwrite the "scopes" field, before returning the provided `inputSourceMap` again.
+ */
+export declare function encode(scopesInfo: ScopeInfo, inputSourceMap?: SourceMapJson): SourceMapJson;

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/encode/encoder.d.ts

@@ -0,0 +1,6 @@
+import type { ScopeInfo } from "../scopes.ts";
+export declare class Encoder {
+    #private;
+    constructor(info: ScopeInfo, names: string[]);
+    encode(): string;
+}

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/mod.d.ts

@@ -0,0 +1,5 @@
+export type { Binding, DecodedScopeInfo, GeneratedRange, OriginalPosition, OriginalScope, Position, ScopeInfo, SourceMapJson, SubRangeBinding, } from "./scopes.ts";
+export { encode } from "./encode/encode.js";
+export { decode, DecodeMode } from "./decode/decode.js";
+export { ScopeInfoBuilder } from "./builder/builder.js";
+export { SafeScopeInfoBuilder } from "./builder/safe_builder.js";

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/scopes.d.ts

@@ -0,0 +1,168 @@
+/**
+ * The scopes information found in a source map.
+ */
+export interface ScopeInfo {
+    /**
+     * The length of {@linkcode scopes} must match the length of "sources" in the source map JSON. Each entry describes the scope tree of the corresponding source file.
+     */
+    scopes: (OriginalScope | null)[];
+    /**
+     * The range tree of the generated bundle. Multiple top-level ranges are allowed but must not overlap source position wise.
+     */
+    ranges: GeneratedRange[];
+}
+/**
+ * The scopes information produced by the decoder.
+ */
+export interface DecodedScopeInfo extends ScopeInfo {
+    /**
+     * When the encoded scopes contained variable and binding expression items.
+     * Note that a value of `true` also indicates "partial" info and does not guarantee comprehensiveness.
+     */
+    hasVariableAndBindingInfo: boolean;
+}
+/**
+ * A scope in the authored source.
+ */
+export interface OriginalScope {
+    /** The beginning of this scope (inclusive). */
+    start: Position;
+    /** The end of this scope (exclusive) */
+    end: Position;
+    /**
+     * The name of this scope. For function scopes this is the function name.
+     *
+     * Constructors may put the class name here.
+     */
+    name?: string;
+    /**
+     * JavaScript-like languages are encouraged to use 'Global', 'Class', 'Function' and 'Block'.
+     *
+     * The "kind" is only used in debuggers as a label for scope UI views, but does not have any
+     * semantic significance.
+     */
+    kind?: string;
+    /**
+     * Whether this scope is something that can be called and results in stack frame (e.g. functions, methods, etc.).
+     */
+    isStackFrame: boolean;
+    /**
+     * All variable names that this scope declares.
+     */
+    variables: string[];
+    /**
+     * The child scopes. When manually building scopes, {@linkcode children} must be sorted, not
+     * overlap each other and be contained within [start, end).
+     */
+    children: OriginalScope[];
+    /** The parent scope or `undefined` for top-level scopes. */
+    parent?: OriginalScope;
+}
+/**
+ * A range (can be a scope) in the generated JavaScript/WASM.
+ *
+ * The name "range" was chosen deliberately as a GeneratedRange does not necessarily
+ * correspond to a lexical JavaScript scope. E.g. inlining, or concatenating multiple
+ * bundles can result in generated ranges that are not lexical scopes.
+ */
+export interface GeneratedRange {
+    /** The beginning of this range (inclusive) */
+    start: Position;
+    /** The end of this range (exclusive) */
+    end: Position;
+    /**
+     * The corresponding scope in the authored source.
+     */
+    originalScope?: OriginalScope;
+    /**
+     * Whether this generated range is an actual JavaScript/WASM function in the generated code.
+     */
+    isStackFrame: boolean;
+    /**
+     * Whether calls to this generated range should be hidden from stack traces even if
+     * this range has an `originalScope`.
+     */
+    isHidden: boolean;
+    /**
+     * If this `GeneratedRange` is the result of inlining `originalScope`, then `callSite`
+     * refers to where `originalScope` was called in the original ("authored") code.
+     *
+     * If this field is present than `originalScope` is present as well and `isStackFrame` is `false`.
+     */
+    callSite?: OriginalPosition;
+    /**
+     * Expressions that compute the values of the variables of this OriginalScope. The length
+     * of `values` matches the length of `originalScope.variables`.
+     */
+    values: Binding[];
+    /**
+     * The child ranges. When manually building ranges, {@linkcode children} must be sorted,
+     * not overlap each other and be contained within [start, end).
+     */
+    children: GeneratedRange[];
+    /** The parent range or `undefined` for top-level ranges. */
+    parent?: GeneratedRange;
+}
+/**
+ * For each variable, this can either be:
+ *
+ *   1) A single expression (valid for a full `GeneratedRange`).
+ *
+ *   2) `null` if this variable is unavailable in the whole range. This can
+ *      happen e.g. when the variable was optimized out and can't be recomputed.
+ *
+ *   3) A list of `SubRangeBinding`s. Used when computing the value requires different
+ *      expressions throughout the `GeneratedRange` or if the variable is unavailable in
+ *      parts of the `GeneratedRange`.
+ *
+ *      Note: The decoder produces `SubRangeBindings` where the "from" of the first `SubRangeBinding`
+ *      and the "to" of the last `SubRangeBinding` are equal to the `GeneratedRange`s "start" and "end"
+ *      position respectively.
+ */
+export type Binding = string | null | SubRangeBinding[];
+export interface SubRangeBinding {
+    value?: string;
+    from: Position;
+    to: Position;
+}
+/**
+ * A position with 0-based line and column numbers.
+ *
+ * A {@linkcode Position} object by itself does not imply a position in original source
+ * or generated code. It is used in both and normally it is clear from context.
+ */
+export interface Position {
+    line: number;
+    column: number;
+}
+/**
+ * A position with 0-based line and column numbers in a specific original source file.
+ */
+export interface OriginalPosition extends Position {
+    /** The 0-based index into "sources" in the source map. Or into {@linkcode ScopeInfo.scopes}. */
+    sourceIndex: number;
+}
+/**
+ * A standard source map, or index source map as per https://tc39.es/ecma426.
+ */
+export type SourceMap = SourceMapJson | IndexSourceMapJson;
+/**
+ * A standard index source map json object as per https://tc39.es/ecma426.
+ */
+export interface IndexSourceMapJson {
+    version: 3;
+    sections: Array<{
+        offset: Position;
+        map: SourceMapJson;
+    }>;
+}
+/**
+ * A standard source map json object as per https://tc39.es/ecma426.
+ */
+export interface SourceMapJson {
+    version: 3;
+    sources: (string | null)[];
+    mappings: string;
+    names?: string[];
+    scopes?: string;
+}

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/util.d.ts

@@ -0,0 +1,5 @@
+import type { Position } from "./scopes.ts";
+/**
+ * @returns A negative number iff `a` precedes `b`, 0 iff `a` and `b` are equal and a positive number iff `b` precedes `a`.
+ */
+export declare function comparePositions(a: Position, b: Position): number;

package/dist/lib/front_end/third_party/source-map-scopes-codec/package/src/vlq.d.ts

@@ -0,0 +1,14 @@
+export declare function encodeSigned(n: number): string;
+export declare function encodeUnsigned(n: number): string;
+export declare class TokenIterator {
+    #private;
+    constructor(string: string);
+    nextChar(): string;
+    /** Returns the unicode value of the next character and advances the iterator  */
+    nextCharCode(): number;
+    peek(): string;
+    hasNext(): boolean;
+    nextSignedVLQ(): number;
+    nextUnsignedVLQ(): number;
+    currentChar(): string;
+}

package/dist/lib/front_end/third_party/source-map-scopes-codec/source-map-scopes-codec.d.ts

@@ -0,0 +1 @@
+export * from './package/src/mod.js';

package/dist/lib/front_end/third_party/third-party-web/third-party-web.d.ts

@@ -0,0 +1,2 @@
+import ThirdPartyWeb from './lib/nostats-subset.js';
+export { ThirdPartyWeb };

package/dist/src/init.d.ts

@@ -0,0 +1 @@
+export declare function initDevToolsTracing(): void;

package/dist/src/timeline.d.ts

@@ -0,0 +1,5 @@
+import * as Trace from '../lib/front_end/models/trace/trace.js';
+type TimeRangeCategoryStats = Record<string, number>;
+export declare function statsForTimeRange(events: Trace.Types.Events.Event[], startTime: Trace.Types.Timing.Milli, endTime: Trace.Types.Timing.Milli): TimeRangeCategoryStats;
+export declare function entryIsVisibleInTimeline(entry: Trace.Types.Events.Event, parsedTrace?: Trace.TraceModel.ParsedTrace): boolean;
+export {};

package/examples/inp.ts

@@ -0,0 +1,34 @@
+import * as fs from 'node:fs';
+import * as zlib from 'node:zlib';
+
+import { initDevToolsTracing, Trace } from '../';
+
+async function main() {
+  const tracePath = process.argv[2];
+  if (!tracePath) {
+    console.error('Usage: npm run examples:inp <path-to-trace-file>');
+    process.exit(1);
+  }
+  initDevToolsTracing();
+
+  const fileData = fs.readFileSync(tracePath);
+  const decompressedData = tracePath.endsWith('.gz')
+    ? zlib.gunzipSync(fileData)
+    : fileData;
+  const traceData = JSON.parse(
+    decompressedData.toString()
+  ) as Trace.Types.File.TraceFile;
+
+  const processor = Trace.Processor.TraceProcessor.createWithAllHandlers();
+  await processor.parse(traceData.traceEvents, {});
+  const insights = processor.insights!.get('NO_NAVIGATION');
+  const longestInteractionEvent =
+    insights!.model.INPBreakdown.longestInteractionEvent!;
+  const inp = longestInteractionEvent.dur / 1000;
+  console.log({
+    insights: insights?.model.INPBreakdown,
+    inp,
+  });
+}
+
+main();

package/examples/stats.ts

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import * as zlib from 'node:zlib';
+
+import {
+  initDevToolsTracing,
+  entryIsVisibleInTimeline,
+  statsForTimeRange,
+  Trace,
+} from '../';
+
+async function main() {
+  const tracePath = process.argv[2];
+  if (!tracePath) {
+    console.error('Usage: npm run examples:stats <path-to-trace-file>');
+    process.exit(1);
+  }
+  initDevToolsTracing();
+
+  const fileData = fs.readFileSync(tracePath);
+  const decompressedData = tracePath.endsWith('.gz')
+    ? zlib.gunzipSync(fileData)
+    : fileData;
+  const traceData = JSON.parse(
+    decompressedData.toString(),
+  ) as Trace.Types.File.TraceFile;
+
+  const traceModel = Trace.TraceModel.Model.createWithAllHandlers({
+    debugMode: true,
+    enableAnimationsFrameHandler: false,
+    // includeRuntimeCallStats: false,
+    maxInvalidationEventsPerEvent: 20,
+    showAllEvents: false,
+  });
+  await traceModel.parse(traceData.traceEvents, {
+    isCPUProfile: false,
+    isFreshRecording: false,
+    metadata: traceData.metadata,
+    showAllEvents: false,
+  });
+  const parsedTrace = traceModel.parsedTrace(0)!;
+  const parsedTraceData = parsedTrace!.data!;
+
+  const startTime = Trace.Helpers.Timing.microToMilli(
+    parsedTraceData.Meta.traceBounds.min,
+  );
+  const endTime = Trace.Helpers.Timing.microToMilli(
+    parsedTraceData.Meta.traceBounds.max,
+  );
+
+  const threads = Trace.Handlers.Threads.threadsInTrace(parsedTrace.data);
+  const mainThread = threads.find(
+    (t) => t.type === Trace.Handlers.Threads.ThreadType.MAIN_THREAD,
+  );
+  if (!mainThread) {
+    throw new Error('No renderer main thread found in trace file');
+  }
+
+  const rendererEvents = [...mainThread.entries].filter((e) =>
+    entryIsVisibleInTimeline(e, parsedTrace),
+  );
+  const stats = statsForTimeRange(rendererEvents, startTime, endTime);
+
+  console.log(stats);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devtools-tracing",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Utilities for working with trace files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",