devtools-tracing 1.2.1 → 1.3.0

package/dist/lib/front_end/models/trace/insights/ModernHTTP.d.ts

@@ -0,0 +1,53 @@
+import * as Handlers from '../handlers/handlers.js';
+import type * as Types from '../types/types.js';
+import { type InsightModel, type InsightSetContext } from './types.js';
+export declare const UIStrings: {
+    /**
+     * @description Title of an insight that recommends using HTTP/2 over HTTP/1.1 because of the performance benefits. "HTTP" should not be translated.
+     */
+    readonly title: "Modern HTTP";
+    /**
+     * @description Description of an insight that recommends recommends using HTTP/2 over HTTP/1.1 because of the performance benefits. "HTTP" should not be translated.
+     */
+    readonly description: "HTTP/2 and HTTP/3 offer many benefits over HTTP/1.1, such as multiplexing. [Learn more about using modern HTTP](https://developer.chrome.com/docs/performance/insights/modern-http).";
+    /**
+     * @description Column header for a table where each cell represents a network request.
+     */
+    readonly request: "Request";
+    /**
+     * @description Column header for a table where each cell represents the protocol of a network request.
+     */
+    readonly protocol: "Protocol";
+    /**
+     * @description Text explaining that there were not requests that were slowed down by using HTTP/1.1. "HTTP/1.1" should not be translated.
+     */
+    readonly noOldProtocolRequests: "No requests used HTTP/1.1, or its current use of HTTP/1.1 does not present a significant optimization opportunity. HTTP/1.1 requests are only flagged if six or more static assets originate from the same origin, and they are not served from a local development environment or a third-party source.";
+};
+export declare const i18nString: any;
+export type ModernHTTPInsightModel = InsightModel<typeof UIStrings, {
+    http1Requests: Types.Events.SyntheticNetworkRequest[];
+}>;
+export declare function isModernHTTPInsight(model: InsightModel): model is ModernHTTPInsightModel;
+/**
+ * Determine the set of resources that aren't HTTP/2 but should be.
+ * We're a little conservative about what we surface for a few reasons:
+ *
+ *    - The simulator approximation of HTTP/2 is a little more generous than reality.
+ *    - There's a bit of debate surrounding HTTP/2 due to its worse performance in environments with high packet loss. [1][2][3]
+ *    - It's something that you'd have absolutely zero control over with a third-party (can't defer to fix it for example).
+ *
+ * Therefore, we only surface requests that were...
+ *
+ *    - Served over HTTP/1.1 or earlier
+ *    - Served over an origin that serves at least 6 static asset requests
+ *      (if there aren't more requests than browser's max/host, multiplexing isn't as big a deal)
+ *    - Not served on localhost (h2 is a pain to deal with locally & and CI)
+ *
+ * [1] https://news.ycombinator.com/item?id=19086639
+ * [2] https://www.twilio.com/blog/2017/10/http2-issues.html
+ * [3] https://www.cachefly.com/http-2-is-not-a-magic-bullet/
+ */
+export declare function determineHttp1Requests(requests: Types.Events.SyntheticNetworkRequest[], entityMappings: Handlers.Helpers.EntityMappings, firstPartyEntity: Handlers.Helpers.Entity | null): Types.Events.SyntheticNetworkRequest[];
+export declare function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): ModernHTTPInsightModel;
+export declare function createOverlayForRequest(request: Types.Events.SyntheticNetworkRequest): Types.Overlays.EntryOutline;
+export declare function createOverlays(model: ModernHTTPInsightModel): Types.Overlays.Overlay[];

package/dist/lib/front_end/models/trace/insights/NetworkDependencyTree.d.ts

@@ -0,0 +1,135 @@
+import * as Platform from '../../../core/platform/platform.js';
+import * as Protocol from '../../../generated/protocol.js';
+import type * as Handlers from '../handlers/handlers.js';
+import * as Types from '../types/types.js';
+import { type InsightModel, type InsightSetContext, type InsightSetContextWithNavigation } from './types.js';
+export declare const UIStrings: {
+    /**
+     * @description Title of an insight that recommends avoiding chaining critical requests.
+     */
+    readonly title: "Network dependency tree";
+    /**
+     * @description Description of an insight that recommends avoiding chaining critical requests.
+     */
+    readonly description: "[Avoid chaining critical requests](https://developer.chrome.com/docs/performance/insights/network-dependency-tree) by reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load.";
+    /**
+     * @description Description of the warning that recommends avoiding chaining critical requests.
+     */
+    readonly warningDescription: "Avoid chaining critical requests by reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load.";
+    /**
+     * @description Text status indicating that there isn't long chaining critical network requests.
+     */
+    readonly noNetworkDependencyTree: "No rendering tasks impacted by network dependencies";
+    /**
+     * @description Text for the maximum critical path latency. This refers to the longest chain of network requests that
+     * the browser must download before it can render the page.
+     */
+    readonly maxCriticalPathLatency: "Max critical path latency:";
+    /** Label for a column in a data table; entries will be the network request */
+    readonly columnRequest: "Request";
+    /** Label for a column in a data table; entries will be the time from main document till current network request. */
+    readonly columnTime: "Time";
+    /**
+     * @description Title of the table of the detected preconnect origins.
+     */
+    readonly preconnectOriginsTableTitle: "Preconnected origins";
+    /**
+     * @description Description of the table of the detected preconnect origins.
+     */
+    readonly preconnectOriginsTableDescription: "[preconnect](https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preconnect/) hints help the browser establish a connection earlier in the page load, saving time when the first request for that origin is made. The following are the origins that the page preconnected to.";
+    /**
+     * @description Text status indicating that there isn't any preconnected origins.
+     */
+    readonly noPreconnectOrigins: "no origins were preconnected";
+    /**
+     * @description A warning message that is shown when found more than 4 preconnected links. "preconnect" should not be translated.
+     */
+    readonly tooManyPreconnectLinksWarning: "More than 4 `preconnect` connections were found. These should be used sparingly and only to the most important origins.";
+    /**
+     * @description A warning message that is shown when the user added preconnect for some unnecessary origins. "preconnect" should not be translated.
+     */
+    readonly unusedWarning: "Unused preconnect. Only use `preconnect` for origins that the page is likely to request.";
+    /**
+     * @description A warning message that is shown when the user forget to set the `crossorigin` HTML attribute, or setting it to an incorrect value, on the link is a common mistake when adding preconnect links. "preconnect" should not be translated.
+     * */
+    readonly crossoriginWarning: "Unused preconnect. Check that the `crossorigin` attribute is used properly.";
+    /**
+     * @description Label for a column in a data table; entries will be the source of the origin.
+     */
+    readonly columnSource: "Source";
+    /**
+     * @description Text status indicating that there isn't preconnect candidates.
+     */
+    readonly noPreconnectCandidates: "No additional origins are good candidates for preconnecting";
+    /**
+     * @description Title of the table that shows the origins that the page should have preconnected to.
+     */
+    readonly estSavingTableTitle: "Preconnect candidates";
+    /**
+     * @description Description of the table that recommends preconnecting to the origins to save time. "preconnect" should not be translated.
+     */
+    readonly estSavingTableDescription: "Add [preconnect](https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preconnect/) hints to your most important origins, but try to use no more than 4.";
+    /**
+     * @description Label for a column in a data table; entries will be the origin of a web resource
+     */
+    readonly columnOrigin: "Origin";
+    /**
+     * @description Label for a column in a data table; entries will be the number of milliseconds the user could reduce page load by if they implemented the suggestions.
+     */
+    readonly columnWastedMs: "Est LCP savings";
+};
+export declare const i18nString: any;
+export declare const TOO_MANY_PRECONNECTS_THRESHOLD = 4;
+export interface CriticalRequestNode {
+    request: Types.Events.SyntheticNetworkRequest;
+    timeFromInitialRequest: Types.Timing.Micro;
+    children: CriticalRequestNode[];
+    isLongest?: boolean;
+    relatedRequests: Set<Types.Events.SyntheticNetworkRequest>;
+}
+export type PreconnectedOrigin = PreconnectedOriginFromDom | PreconnectedOriginFromResponseHeader;
+export interface PreconnectedOriginFromDom {
+    node_id: Protocol.DOM.BackendNodeId;
+    frame?: string;
+    url: string;
+    unused: boolean;
+    crossorigin: boolean;
+    source: 'DOM';
+}
+export interface PreconnectedOriginFromResponseHeader {
+    url: string;
+    headerText: string;
+    request: Types.Events.SyntheticNetworkRequest;
+    unused: boolean;
+    crossorigin: boolean;
+    source: 'ResponseHeader';
+}
+export interface PreconnectCandidate {
+    origin: Platform.DevToolsPath.UrlString;
+    wastedMs: Types.Timing.Milli;
+}
+export type NetworkDependencyTreeInsightModel = InsightModel<typeof UIStrings, {
+    rootNodes: CriticalRequestNode[];
+    maxTime: Types.Timing.Micro;
+    fail: boolean;
+    preconnectedOrigins: PreconnectedOrigin[];
+    preconnectCandidates: PreconnectCandidate[];
+}>;
+/**
+ * Parses an HTTP Link header string into an array of url and related header text.
+ *
+ * Export the function for test purpose.
+ * @param linkHeaderValue The value of the HTTP Link header (e.g., '</style.css>; rel=preload; as=style, <https://example.com>; rel="preconnect"').
+ * @returns An array of url and header text objects if it contains `rel=preconnect`.
+ */
+export declare function handleLinkResponseHeader(linkHeaderValue: string): Array<{
+    url: string;
+    headerText: string;
+}>;
+/** Export the function for test purpose. **/
+export declare function generatePreconnectedOrigins(data: Handlers.Types.HandlerData, context: InsightSetContextWithNavigation, contextRequests: Types.Events.SyntheticNetworkRequest[], preconnectCandidates: PreconnectCandidate[]): PreconnectedOrigin[];
+/** Export the function for test purpose. **/
+export declare function generatePreconnectCandidates(data: Handlers.Types.HandlerData, context: InsightSetContextWithNavigation, contextRequests: Types.Events.SyntheticNetworkRequest[]): PreconnectCandidate[];
+export declare function isNetworkDependencyTreeInsight(model: InsightModel): model is NetworkDependencyTreeInsightModel;
+export declare function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): NetworkDependencyTreeInsightModel;
+export declare function createOverlays(model: NetworkDependencyTreeInsightModel): Types.Overlays.Overlay[];

package/dist/lib/front_end/models/trace/insights/RenderBlocking.d.ts

@@ -0,0 +1,34 @@
+import * as Handlers from '../handlers/handlers.js';
+import type * as Types from '../types/types.js';
+import { type InsightModel, type InsightSetContext } from './types.js';
+export declare const UIStrings: {
+    /**
+     * @description Title of an insight that provides the user with the list of network requests that blocked and therefore slowed down the page rendering and becoming visible to the user.
+     */
+    readonly title: "Render-blocking requests";
+    /**
+     * @description Text to describe that there are requests blocking rendering, which may affect LCP.
+     */
+    readonly description: string;
+    /**
+     * @description Label to describe a network request (that happens to be render-blocking).
+     */
+    readonly renderBlockingRequest: "Request";
+    /**
+     * @description Label used for a time duration.
+     */
+    readonly duration: "Duration";
+    /**
+     * @description Text status indicating that no requests blocked the initial render of a navigation
+     */
+    readonly noRenderBlocking: "No render-blocking requests for this navigation";
+};
+export declare const i18nString: any;
+export declare function isRenderBlockingInsight(insight: InsightModel): insight is RenderBlockingInsightModel;
+export type RenderBlockingInsightModel = InsightModel<typeof UIStrings, {
+    renderBlockingRequests: Types.Events.SyntheticNetworkRequest[];
+    requestIdToWastedMs?: Map<string, number>;
+}>;
+export declare function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): RenderBlockingInsightModel;
+export declare function createOverlayForRequest(request: Types.Events.SyntheticNetworkRequest): Types.Overlays.EntryOutline;
+export declare function createOverlays(model: RenderBlockingInsightModel): Types.Overlays.Overlay[];

package/dist/lib/front_end/models/trace/insights/SlowCSSSelector.d.ts

@@ -0,0 +1,56 @@
+import type * as Handlers from '../handlers/handlers.js';
+import * as Types from '../types/types.js';
+import { type InsightModel, type InsightSetContext } from './types.js';
+export declare const UIStrings: {
+    /**
+     * @description Title of an insight that provides details about slow CSS selectors.
+     */
+    readonly title: "CSS Selector costs";
+    /**
+     * @description Text to describe how to improve the performance of CSS selectors.
+     */
+    readonly description: "If Recalculate Style costs remain high, selector optimization can reduce them. [Optimize the selectors](https://developer.chrome.com/docs/performance/insights/slow-css-selector) with both high elapsed time and high slow-path %. Simpler selectors, fewer selectors, a smaller DOM, and a shallower DOM will all reduce matching costs.";
+    /**
+     * @description Column name for count of elements that the engine attempted to match against a style rule
+     */
+    readonly matchAttempts: "Match attempts";
+    /**
+     * @description Column name for count of elements that matched a style rule
+     */
+    readonly matchCount: "Match count";
+    /**
+     * @description Column name for elapsed time spent computing a style rule
+     */
+    readonly elapsed: "Elapsed time";
+    /**
+     * @description Column name for the selectors that took the longest amount of time/effort.
+     */
+    readonly topSelectors: "Top selectors";
+    /**
+     * @description Column name for a total sum.
+     */
+    readonly total: "Total";
+    /**
+     * @description Text status indicating that no CSS selector data was found.
+     */
+    readonly enableSelectorData: "No CSS selector data was found. CSS selector stats need to be enabled in the performance panel settings.";
+    /**
+     * @description top CSS selector when ranked by elapsed time in ms
+     */
+    readonly topSelectorElapsedTime: "Top selector elapsed time";
+    /**
+     * @description top CSS selector when ranked by match attempt
+     */
+    readonly topSelectorMatchAttempt: "Top selector match attempt";
+};
+export declare const i18nString: any;
+export type SlowCSSSelectorInsightModel = InsightModel<typeof UIStrings, {
+    totalElapsedMs: Types.Timing.Milli;
+    totalMatchAttempts: number;
+    totalMatchCount: number;
+    topSelectorElapsedMs: Types.Events.SelectorTiming | null;
+    topSelectorMatchAttempts: Types.Events.SelectorTiming | null;
+}>;
+export declare function isSlowCSSSelectorInsight(model: InsightModel): model is SlowCSSSelectorInsightModel;
+export declare function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): SlowCSSSelectorInsightModel;
+export declare function createOverlays(_: SlowCSSSelectorInsightModel): Types.Overlays.Overlay[];

package/dist/lib/front_end/models/trace/insights/Statistics.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns the score (1 - percentile) of `value` in a log-normal distribution
+ * specified by the `median` value, at which the score will be 0.5, and a 10th
+ * percentile value, at which the score will be 0.9. The score represents the
+ * amount of the distribution greater than `value`. All values should be in the
+ * same units (e.g. milliseconds). See
+ *   https://www.desmos.com/calculator/o98tbeyt1t
+ * for an interactive view of the relationship between these parameters and the
+ * typical parameterization (location and shape) of the log-normal distribution.
+ */
+export declare function getLogNormalScore({ median, p10 }: {
+    median: number;
+    p10: number;
+}, value: number): number;
+/**
+ * Interpolates the y value at a point x on the line defined by (x0, y0) and (x1, y1)
+ */
+export declare function linearInterpolation(x0: number, y0: number, x1: number, y1: number, x: number): number;

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

@@ -0,0 +1,33 @@
+import * as Extras from '../extras/extras.js';
+import * as Handlers from '../handlers/handlers.js';
+import type * as Types from '../types/types.js';
+import { type InsightModel, type InsightSetContext } from './types.js';
+export declare const UIStrings: {
+    /** Title of an insight that provides details about the code on a web page that the user doesn't control (referred to as "third-party code"). */
+    readonly title: "3rd parties";
+    /**
+     * @description Description of a DevTools insight that identifies the code on the page that the user doesn't control.
+     * This is displayed after a user expands the section to see more. No character length limits.
+     */
+    readonly description: string;
+    /** Label for a table column that displays the name of a third-party provider. */
+    readonly columnThirdParty: "3rd party";
+    /** Label for a column in a data table; entries will be the download size of a web resource in kilobytes. */
+    readonly columnTransferSize: "Transfer size";
+    /** Label for a table column that displays how much time each row spent running on the main thread, entries will be the number of milliseconds spent. */
+    readonly columnMainThreadTime: "Main thread time";
+    /**
+     * @description Text block indicating that no third party content was detected on the page
+     */
+    readonly noThirdParties: "No third parties found";
+};
+export declare const i18nString: any;
+export type ThirdPartiesInsightModel = InsightModel<typeof UIStrings, {
+    /** The entity for this navigation's URL. Any other entity is from a third party. */
+    entitySummaries: Extras.ThirdParties.EntitySummary[];
+    firstPartyEntity?: Extras.ThirdParties.Entity;
+}>;
+export declare function isThirdPartyInsight(model: InsightModel): model is ThirdPartiesInsightModel;
+export declare function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): ThirdPartiesInsightModel;
+export declare function createOverlaysForSummary(summary: Extras.ThirdParties.EntitySummary): Types.Overlays.Overlay[];
+export declare function createOverlays(model: ThirdPartiesInsightModel): Types.Overlays.Overlay[];

package/dist/lib/front_end/models/trace/insights/Viewport.d.ts

@@ -0,0 +1,24 @@
+import * as Handlers from '../handlers/handlers.js';
+import * as Types from '../types/types.js';
+import { type InsightModel, type InsightSetContext } from './types.js';
+export declare const UIStrings: {
+    /** Title of an insight that provides details about if the page's viewport is optimized for mobile viewing. */
+    readonly title: "Optimize viewport for mobile";
+    /**
+     * @description Text to tell the user how a viewport meta element can improve performance. \xa0 is a non-breaking space
+     */
+    readonly description: "Tap interactions may be [delayed by up to 300 ms](https://developer.chrome.com/docs/performance/insights/viewport) if the viewport is not optimized for mobile.";
+    /**
+     * @description Text for a label describing the portion of an interaction event that was delayed due to a bad mobile viewport.
+     */
+    readonly mobileTapDelayLabel: "Mobile tap delay";
+};
+export declare const i18nString: any;
+export type ViewportInsightModel = InsightModel<typeof UIStrings, {
+    mobileOptimized: boolean | null;
+    viewportEvent?: Types.Events.ParseMetaViewport;
+    longPointerInteractions?: Types.Events.SyntheticInteractionPair[];
+}>;
+export declare function isViewportInsight(model: InsightModel): model is ViewportInsightModel;
+export declare function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): ViewportInsightModel;
+export declare function createOverlays(model: ViewportInsightModel): Types.Overlays.Overlay[];

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

@@ -0,0 +1,6 @@
+export * as Cache from './Cache.js';
+export * as Common from './Common.js';
+export * as Models from './Models.js';
+export * as ModernHTTP from './ModernHTTP.js';
+export * as Statistics from './Statistics.js';
+export * as Types from './types.js';

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

@@ -0,0 +1,143 @@
+import type * as Common from '../../../core/common/common.js';
+import type * as Lantern from '../lantern/lantern.js';
+import type * as Types from '../types/types.js';
+import type * as Models from './Models.js';
+/**
+ * Context for the portion of the trace an insight should look at.
+ */
+export type InsightSetContext = InsightSetContextWithoutNavigation | InsightSetContextWithNavigation;
+export interface InsightSetContextWithoutNavigation {
+    options: Types.Configuration.ParseOptions;
+    bounds: Types.Timing.TraceWindowMicro;
+    frameId: string;
+    navigation?: never;
+}
+export interface InsightSetContextWithNavigation {
+    options: Types.Configuration.ParseOptions;
+    bounds: Types.Timing.TraceWindowMicro;
+    frameId: string;
+    navigation: Types.Events.NavigationStart;
+    navigationId: string;
+    lantern?: LanternContext;
+}
+export interface LanternContext {
+    requests: Array<Lantern.Types.NetworkRequest<Types.Events.SyntheticNetworkRequest>>;
+    graph: Lantern.Graph.Node<Types.Events.SyntheticNetworkRequest>;
+    simulator: Lantern.Simulation.Simulator<Types.Events.SyntheticNetworkRequest>;
+    metrics: Record<string, Lantern.Metrics.MetricResult>;
+}
+export type InsightModelsType = typeof Models;
+export declare enum InsightWarning {
+    NO_FP = "NO_FP",
+    NO_LCP = "NO_LCP",
+    NO_DOCUMENT_REQUEST = "NO_DOCUMENT_REQUEST",
+    NO_LAYOUT = "NO_LAYOUT"
+}
+export interface MetricSavings {
+    FCP?: Types.Timing.Milli;
+    LCP?: Types.Timing.Milli;
+    TBT?: Types.Timing.Milli;
+    CLS?: number;
+    INP?: Types.Timing.Milli;
+}
+export declare enum InsightCategory {
+    ALL = "All",
+    INP = "INP",
+    LCP = "LCP",
+    CLS = "CLS"
+}
+export type RelatedEventsMap = Map<Types.Events.Event, string[]>;
+export type Checklist<Keys extends string> = Record<Keys, {
+    label: Common.UIString.LocalizedString;
+    value: boolean;
+}>;
+export type InsightModel<UIStrings extends Record<string, string> = Record<string, string>, ExtraDetail extends Record<string, unknown> = Record<string, unknown>> = ExtraDetail & {
+    /** Used internally to identify the type of a model, not shown visibly to users **/
+    insightKey: keyof InsightModelsType;
+    /** Not used within DevTools - this is for external consumers (like Lighthouse). */
+    strings: UIStrings;
+    title: Common.UIString.LocalizedString;
+    description: Common.UIString.LocalizedString;
+    docs: string;
+    category: InsightCategory;
+    state: 'pass' | 'fail' | 'informative';
+    /** Used by RelatedInsightChips.ts */
+    relatedEvents?: RelatedEventsMap | Types.Events.Event[];
+    warnings?: InsightWarning[];
+    metricSavings?: MetricSavings;
+    /**
+     * An estimate for the number of bytes that this insight deems to have been wasted.
+     * Bytes are in terms of transfer size: for each component of savings related to an
+     * individual request, the insight will estimate its impact on transfer size by using
+     * the compression ratio of the resource.
+     *
+     * This field is only displayed for informational purposes.
+     */
+    wastedBytes?: number;
+    frameId?: string;
+    /**
+     * If this insight is attached to a navigation, this stores its ID.
+     */
+    navigation?: Types.Events.NavigationStart;
+    /** This is lazily-generated because some insights may create many overlays. */
+    createOverlays?: () => Types.Overlays.Overlay[];
+};
+export type PartialInsightModel<T> = Omit<T, 'strings' | 'title' | 'description' | 'docs' | 'category' | 'state' | 'insightKey' | 'navigationId' | 'frameId'>;
+/**
+ * Contains insights for a specific navigation. If a trace began after a navigation already started,
+ * this could instead represent the duration from the beginning of the trace up to the first recorded
+ * navigation (or the end of the trace).
+ */
+export interface InsightSet {
+    /** If for a navigation, this is of the form "NAVIGATION_(index)". Else it is Trace.Types.Events.NO_NAVIGATION. */
+    id: Types.Events.NavigationId;
+    /** The URL to show in the accordion list. */
+    url: URL;
+    frameId: string;
+    bounds: Types.Timing.TraceWindowMicro;
+    /** Contains results for all non-errored insights. */
+    model: InsightModels;
+    /** Contains errors for all insights that had an internal error. */
+    modelErrors: InsightModelErrors;
+    navigation?: Types.Events.NavigationStart;
+}
+/**
+ * Contains insights for a specific insight set. If missing, it error'd.
+ */
+export type InsightModels = {
+    [I in keyof InsightModelsType]?: ReturnType<InsightModelsType[I]['generateInsight']>;
+};
+/**
+ * Contains an internal error for each insight in a specific insight set.
+ */
+export type InsightModelErrors = {
+    [I in keyof InsightModelsType]?: Error;
+};
+/**
+ * Contains insights for the entire trace. Insights are mostly grouped by `navigationId`, with one exception:
+ *
+ * If the analyzed trace started after the navigation, and has meaningful work with that span, there is no
+ * navigation to map it to. In this case `Types.Events.NO_NAVIGATION` is used for the key.
+ */
+export type TraceInsightSets = Map<Types.Events.NavigationId, InsightSet>;
+export declare const enum InsightKeys {
+    LCP_BREAKDOWN = "LCPBreakdown",
+    INP_BREAKDOWN = "INPBreakdown",
+    CLS_CULPRITS = "CLSCulprits",
+    THIRD_PARTIES = "ThirdParties",
+    DOCUMENT_LATENCY = "DocumentLatency",
+    DOM_SIZE = "DOMSize",
+    DUPLICATE_JAVASCRIPT = "DuplicatedJavaScript",
+    FONT_DISPLAY = "FontDisplay",
+    FORCED_REFLOW = "ForcedReflow",
+    IMAGE_DELIVERY = "ImageDelivery",
+    LCP_DISCOVERY = "LCPDiscovery",
+    LEGACY_JAVASCRIPT = "LegacyJavaScript",
+    NETWORK_DEPENDENCY_TREE = "NetworkDependencyTree",
+    RENDER_BLOCKING = "RenderBlocking",
+    SLOW_CSS_SELECTOR = "SlowCSSSelector",
+    VIEWPORT = "Viewport",
+    MODERN_HTTP = "ModernHTTP",
+    CACHE = "Cache",
+    CHARACTER_SET = "CharacterSet"
+}

package/dist/lib/front_end/models/trace/lantern/core/LanternError.d.ts

@@ -0,0 +1,3 @@
+declare class LanternError extends Error {
+}
+export { LanternError };

package/dist/lib/front_end/models/trace/lantern/core/NetworkAnalyzer.d.ts

@@ -0,0 +1,112 @@
+import type * as Lantern from '../types/types.js';
+interface Summary {
+    min: number;
+    max: number;
+    avg: number;
+    median: number;
+}
+interface RTTEstimateOptions {
+    /**
+     * TCP connection handshake information will be used when available, but in
+     * some circumstances this data can be unreliable. This flag exposes an
+     * option to ignore the handshake data and use the coarse download/TTFB timing data.
+     */
+    forceCoarseEstimates?: boolean;
+    /**
+     * Coarse estimates include lots of extra time and noise multiply by some factor
+     * to deflate the estimates a bit.
+     */
+    coarseEstimateMultiplier?: number;
+    /** Useful for testing to isolate the different methods of estimation. */
+    useDownloadEstimates?: boolean;
+    /** Useful for testing to isolate the different methods of estimation. */
+    useSendStartEstimates?: boolean;
+    /** Useful for testing to isolate the different methods of estimation. */
+    useHeadersEndEstimates?: boolean;
+}
+interface RequestInfo {
+    request: Lantern.NetworkRequest;
+    timing: Lantern.ResourceTiming;
+    connectionReused?: boolean;
+}
+declare class NetworkAnalyzer {
+    static get summary(): string;
+    static groupByOrigin(records: Lantern.NetworkRequest[]): Map<string, Lantern.NetworkRequest[]>;
+    static getSummary(values: number[]): Summary;
+    static summarize(values: Map<string, number[]>): Map<string, Summary>;
+    static estimateValueByOrigin(requests: Lantern.NetworkRequest[], iteratee: (e: RequestInfo) => number | number[] | undefined): Map<string, number[]>;
+    /**
+     * Estimates the observed RTT to each origin based on how long the connection setup.
+     * For h1 and h2, this could includes two estimates - one for the TCP handshake, another for
+     * SSL negotiation.
+     * For h3, we get only one estimate since QUIC establishes a secure connection in a
+     * single handshake.
+     * This is the most accurate and preferred method of measurement when the data is available.
+     */
+    static estimateRTTViaConnectionTiming(info: RequestInfo): number[] | number | undefined;
+    /**
+     * Estimates the observed RTT to each origin based on how long a download took on a fresh connection.
+     * NOTE: this will tend to overestimate the actual RTT quite significantly as the download can be
+     * slow for other reasons as well such as bandwidth constraints.
+     */
+    static estimateRTTViaDownloadTiming(info: RequestInfo): number | undefined;
+    /**
+     * Estimates the observed RTT to each origin based on how long it took until Chrome could
+     * start sending the actual request when a new connection was required.
+     * NOTE: this will tend to overestimate the actual RTT as the request can be delayed for other
+     * reasons as well such as more SSL handshakes if TLS False Start is not enabled.
+     */
+    static estimateRTTViaSendStartTiming(info: RequestInfo): number | undefined;
+    /**
+     * Estimates the observed RTT to each origin based on how long it took until Chrome received the
+     * headers of the response (~TTFB).
+     * NOTE: this is the most inaccurate way to estimate the RTT, but in some environments it's all
+     * we have access to :(
+     */
+    static estimateRTTViaHeadersEndTiming(info: RequestInfo): number | undefined;
+    /**
+     * Given the RTT to each origin, estimates the observed server response times.
+     */
+    static estimateResponseTimeByOrigin(records: Lantern.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    static canTrustConnectionInformation(requests: Lantern.NetworkRequest[]): boolean;
+    /**
+     * Returns a map of requestId -> connectionReused, estimating the information if the information
+     * available in the records themselves appears untrustworthy.
+     */
+    static estimateIfConnectionWasReused(records: Lantern.NetworkRequest[], options?: {
+        forceCoarseEstimates: boolean;
+    }): Map<string, boolean>;
+    /**
+     * Estimates the RTT to each origin by examining observed network timing information.
+     * Attempts to use the most accurate information first and falls back to coarser estimates when it
+     * is unavailable.
+     */
+    static estimateRTTByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions): Map<string, Summary>;
+    /**
+     * Estimates the server response time of each origin. RTT times can be passed in or will be
+     * estimated automatically if not provided.
+     */
+    static estimateServerResponseTimeByOrigin(records: Lantern.NetworkRequest[], options?: RTTEstimateOptions & {
+        rttByOrigin?: Map<string, number>;
+    }): Map<string, Summary>;
+    /**
+     * Computes the average throughput for the given requests in bits/second.
+     * Excludes data URI, failed or otherwise incomplete, and cached requests.
+     * Returns null if there were no analyzable network requests.
+     */
+    static estimateThroughput(records: Lantern.NetworkRequest[]): number | null;
+    static computeRTTAndServerResponseTime(records: Lantern.NetworkRequest[]): {
+        rtt: number;
+        additionalRttByOrigin: Map<string, number>;
+        serverResponseTimeByOrigin: Map<string, number>;
+    };
+    static analyze(records: Lantern.NetworkRequest[]): Lantern.Simulation.Settings['networkAnalysis'] | null;
+    static findResourceForUrl<T extends Lantern.NetworkRequest>(records: T[], resourceUrl: string): T | undefined;
+    static findLastDocumentForUrl<T extends Lantern.NetworkRequest>(records: T[], resourceUrl: string): T | undefined;
+    /**
+     * Resolves redirect chain given a main document.
+     * See: {@link NetworkAnalyzer.findLastDocumentForUrl} for how to retrieve main document.
+     */
+    static resolveRedirects<T extends Lantern.NetworkRequest>(request: T): T;
+}
+export { NetworkAnalyzer };

package/dist/lib/front_end/models/trace/lantern/core/core.d.ts

@@ -0,0 +1,2 @@
+export * from './LanternError.js';
+export * from './NetworkAnalyzer.js';