lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230119

package/core/lib/tracehouse/task-groups.d.ts

@@ -0,0 +1,66 @@
+export type TaskGroupIds = 'parseHTML' | 'styleLayout' | 'paintCompositeRender' | 'scriptParseCompile' | 'scriptEvaluation' | 'garbageCollection' | 'other';
+export type TaskGroup = {
+    id: TaskGroupIds;
+    label: string;
+    traceEventNames: string[];
+};
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/** @typedef {'parseHTML'|'styleLayout'|'paintCompositeRender'|'scriptParseCompile'|'scriptEvaluation'|'garbageCollection'|'other'} TaskGroupIds */
+/**
+ * @typedef TaskGroup
+ * @property {TaskGroupIds} id
+ * @property {string} label
+ * @property {string[]} traceEventNames
+ */
+/**
+ * Make sure the traceEventNames keep up with the ones in DevTools
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/timeline_model/TimelineModel.js?type=cs&q=TimelineModel.TimelineModel.RecordType+%3D&g=0&l=1156
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/timeline/TimelineUIUtils.js?type=cs&q=_initEventStyles+-f:out+f:devtools&sq=package:chromium&g=0&l=39
+ * @type {{[P in TaskGroupIds]: {id: P, label: string, traceEventNames: Array<string>}}}
+ */
+export const taskGroups: {
+    other: {
+        id: "other";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    parseHTML: {
+        id: "parseHTML";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    styleLayout: {
+        id: "styleLayout";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    paintCompositeRender: {
+        id: "paintCompositeRender";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    scriptParseCompile: {
+        id: "scriptParseCompile";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    scriptEvaluation: {
+        id: "scriptEvaluation";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+    garbageCollection: {
+        id: "garbageCollection";
+        label: string;
+        traceEventNames: Array<string>;
+    };
+};
+/** @type {Object<string, TaskGroup>} */
+export const taskNameToGroup: {
+    [x: string]: TaskGroup;
+};
+//# sourceMappingURL=task-groups.d.ts.map

package/core/lib/tracehouse/task-summary.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {LH.Artifacts.NetworkRequest[]} records
+ */
+export function getJavaScriptURLs(records: LH.Artifacts.NetworkRequest[]): Set<string>;
+/**
+ * @param {LH.Artifacts.TaskNode} task
+ * @param {Set<string>} jsURLs
+ * @return {string}
+ */
+export function getAttributableURLForTask(task: LH.Artifacts.TaskNode, jsURLs: Set<string>): string;
+/**
+ * @param {LH.Artifacts.TaskNode[]} tasks
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ * @return {Map<string, Record<string, number>>}
+ */
+export function getExecutionTimingsByURL(tasks: LH.Artifacts.TaskNode[], networkRecords: Array<LH.Artifacts.NetworkRequest>): Map<string, Record<string, number>>;
+import { NetworkRequest } from "../network-request.js";
+//# sourceMappingURL=task-summary.d.ts.map

package/core/lib/tracehouse/trace-processor.d.ts

@@ -0,0 +1,275 @@
+export type TraceNavigationTimesForFrame = Omit<LH.Artifacts.NavigationTraceTimes, 'firstContentfulPaintAllFrames' | 'traceEnd'>;
+export type TimeOriginDeterminationMethod = 'lastNavigationStart' | 'firstResourceSendRequest' | 'lighthouseMarker' | 'auto';
+export type FrameCommittedEvent = Omit<LH.TraceEvent, 'name' | 'args'> & {
+    name: 'FrameCommittedInBrowser';
+    args: {
+        data: {
+            frame: string;
+            url: string;
+            parent?: string;
+        };
+    };
+};
+export type LCPEvent = Omit<LH.TraceEvent, 'name' | 'args'> & {
+    name: 'largestContentfulPaint::Invalidate' | 'largestContentfulPaint::Candidate';
+    args: {
+        data?: {
+            size?: number;
+        };
+        frame: string;
+    };
+};
+export type LCPCandidateEvent = Omit<LH.TraceEvent, 'name' | 'args'> & {
+    name: 'largestContentfulPaint::Candidate';
+    args: {
+        data: {
+            size: number;
+        };
+        frame: string;
+    };
+};
+export type ToplevelEvent = {
+    start: number;
+    end: number;
+    duration: number;
+};
+export class TraceProcessor {
+    static get TIMESPAN_MARKER_ID(): string;
+    /**
+     * @return {Error}
+     */
+    static createNoNavstartError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoResourceSendRequestError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoTracingStartedError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoFirstContentfulPaintError(): Error;
+    /**
+     * @return {Error}
+     */
+    static createNoLighthouseMarkerError(): Error;
+    /**
+     * Returns true if the event is a navigation start event of a document whose URL seems valid.
+     *
+     * @param {LH.TraceEvent} event
+     * @return {boolean}
+     */
+    static _isNavigationStartOfInterest(event: LH.TraceEvent): boolean;
+    /**
+     * This method sorts a group of trace events that have the same timestamp. We want to...
+     *
+     * 1. Put E events first, we finish off our existing events before we start new ones.
+     * 2. Order B/X events by their duration, we want parents to start before child events.
+     * 3. If we don't have any of this to go on, just use the position in the original array (stable sort).
+     *
+     * Note that the typical group size with the same timestamp will be quite small (<10 or so events),
+     * and the number of groups typically ~1% of total trace, so the same ultra-performance-sensitive consideration
+     * given to functions that run on entire traces does not necessarily apply here.
+     *
+     * @param {number[]} tsGroupIndices
+     * @param {number[]} timestampSortedIndices
+     * @param {number} indexOfTsGroupIndicesStart
+     * @param {LH.TraceEvent[]} traceEvents
+     * @return {number[]}
+     */
+    static _sortTimestampEventGroup(tsGroupIndices: number[], timestampSortedIndices: number[], indexOfTsGroupIndicesStart: number, traceEvents: LH.TraceEvent[]): number[];
+    /**
+     * Sorts and filters trace events by timestamp and respecting the nesting structure inherent to
+     * parent/child event relationships.
+     *
+     * @param {LH.TraceEvent[]} traceEvents
+     * @param {(e: LH.TraceEvent) => boolean} filter
+     */
+    static filteredTraceSort(traceEvents: LH.TraceEvent[], filter: (e: LH.TraceEvent) => boolean): import("../..").TraceEvent[];
+    /**
+     * There should *always* be at least one top level event, having 0 typically means something is
+     * drastically wrong with the trace and we should just give up early and loudly.
+     *
+     * @param {LH.TraceEvent[]} events
+     */
+    static assertHasToplevelEvents(events: LH.TraceEvent[]): void;
+    /**
+     * Calculate duration at specified percentiles for given population of
+     * durations.
+     * If one of the durations overlaps the end of the window, the full
+     * duration should be in the duration array, but the length not included
+     * within the window should be given as `clippedLength`. For instance, if a
+     * 50ms duration occurs 10ms before the end of the window, `50` should be in
+     * the `durations` array, and `clippedLength` should be set to 40.
+     * @see https://docs.google.com/document/d/1b9slyaB9yho91YTOkAQfpCdULFkZM9LqsipcX3t7He8/preview
+     * @param {!Array<number>} durations Array of durations, sorted in ascending order.
+     * @param {number} totalTime Total time (in ms) of interval containing durations.
+     * @param {!Array<number>} percentiles Array of percentiles of interest, in ascending order.
+     * @param {number=} clippedLength Optional length clipped from a duration overlapping end of window. Default of 0.
+     * @return {!Array<{percentile: number, time: number}>}
+     * @private
+     */
+    private static _riskPercentiles;
+    /**
+     * Calculates the maximum queueing time (in ms) of high priority tasks for
+     * selected percentiles within a window of the main thread.
+     * @see https://docs.google.com/document/d/1b9slyaB9yho91YTOkAQfpCdULFkZM9LqsipcX3t7He8/preview
+     * @param {Array<ToplevelEvent>} events
+     * @param {number} startTime Start time (in ms relative to timeOrigin) of range of interest.
+     * @param {number} endTime End time (in ms relative to timeOrigin) of range of interest.
+     * @param {!Array<number>=} percentiles Optional array of percentiles to compute. Defaults to [0.5, 0.75, 0.9, 0.99, 1].
+     * @return {!Array<{percentile: number, time: number}>}
+     */
+    static getRiskToResponsiveness(events: Array<ToplevelEvent>, startTime: number, endTime: number, percentiles?: Array<number> | undefined): Array<{
+        percentile: number;
+        time: number;
+    }>;
+    /**
+     * Provides durations in ms of all main thread top-level events
+     * @param {Array<ToplevelEvent>} topLevelEvents
+     * @param {number} startTime Optional start time (in ms relative to timeOrigin) of range of interest. Defaults to 0.
+     * @param {number} endTime Optional end time (in ms relative to timeOrigin) of range of interest. Defaults to trace end.
+     * @return {{durations: Array<number>, clippedLength: number}}
+     */
+    static getMainThreadTopLevelEventDurations(topLevelEvents: Array<ToplevelEvent>, startTime?: number, endTime?: number): {
+        durations: Array<number>;
+        clippedLength: number;
+    };
+    /**
+     * Provides the top level events on the main thread with timestamps in ms relative to timeOrigin.
+     * start.
+     * @param {LH.Artifacts.ProcessedTrace} trace
+     * @param {number=} startTime Optional start time (in ms relative to timeOrigin) of range of interest. Defaults to 0.
+     * @param {number=} endTime Optional end time (in ms relative to timeOrigin) of range of interest. Defaults to trace end.
+     * @return {Array<ToplevelEvent>}
+     */
+    static getMainThreadTopLevelEvents(trace: LH.Artifacts.ProcessedTrace, startTime?: number | undefined, endTime?: number | undefined): Array<ToplevelEvent>;
+    /**
+     * @param {LH.TraceEvent[]} events
+     * @return {{pid: number, tid: number, frameId: string}}
+     */
+    static findMainFrameIds(events: LH.TraceEvent[]): {
+        pid: number;
+        tid: number;
+        frameId: string;
+    };
+    /**
+     * @param {LH.TraceEvent} evt
+     * @return {boolean}
+     */
+    static isScheduleableTask(evt: LH.TraceEvent): boolean;
+    /**
+     * @param {LH.TraceEvent} evt
+     * @return {evt is LCPEvent}
+     */
+    static isLCPEvent(evt: LH.TraceEvent): evt is LCPEvent;
+    /**
+     * @param {LH.TraceEvent} evt
+     * @return {evt is LCPCandidateEvent}
+     */
+    static isLCPCandidateEvent(evt: LH.TraceEvent): evt is LCPCandidateEvent;
+    /**
+     * Returns the maximum LCP event across all frames in `events`.
+     * Sets `invalidated` flag if LCP of every frame is invalidated.
+     *
+     * LCP's trace event was first introduced in m78. We can't surface an LCP for older Chrome versions.
+     * LCP comes from a frame's latest `largestContentfulPaint::Candidate`, but it can be invalidated by a `largestContentfulPaint::Invalidate` event.
+     *
+     * @param {LH.TraceEvent[]} events
+     * @param {LH.TraceEvent} timeOriginEvent
+     * @return {{lcp: LCPEvent | undefined, invalidated: boolean}}
+     */
+    static computeValidLCPAllFrames(events: LH.TraceEvent[], timeOriginEvent: LH.TraceEvent): {
+        lcp: LCPEvent | undefined;
+        invalidated: boolean;
+    };
+    /**
+     * @param {Array<{id: string, url: string, parent?: string}>} frames
+     * @return {Map<string, string>}
+     */
+    static resolveRootFrames(frames: Array<{
+        id: string;
+        url: string;
+        parent?: string;
+    }>): Map<string, string>;
+    /**
+     * Finds key trace events, identifies main process/thread, and returns timings of trace events
+     * in milliseconds since the time origin in addition to the standard microsecond monotonic timestamps.
+     * @param {LH.Trace} trace
+     * @param {{timeOriginDeterminationMethod?: TimeOriginDeterminationMethod}} [options]
+     * @return {LH.Artifacts.ProcessedTrace}
+    */
+    static processTrace(trace: LH.Trace, options?: {
+        timeOriginDeterminationMethod?: TimeOriginDeterminationMethod | undefined;
+    } | undefined): LH.Artifacts.ProcessedTrace;
+    /**
+     * Finds key navigation trace events and computes timings of events in milliseconds since the time
+     * origin in addition to the standard microsecond monotonic timestamps.
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {LH.Artifacts.ProcessedNavigation}
+    */
+    static processNavigation(processedTrace: LH.Artifacts.ProcessedTrace): LH.Artifacts.ProcessedNavigation;
+    /**
+     * Computes the last observable timestamp in a set of trace events.
+     *
+     * @param {Array<LH.TraceEvent>} events
+     * @param {LH.TraceEvent} timeOriginEvt
+     * @return {{timing: number, timestamp: number}}
+     */
+    static computeTraceEnd(events: Array<LH.TraceEvent>, timeOriginEvt: LH.TraceEvent): {
+        timing: number;
+        timestamp: number;
+    };
+    /**
+     * Computes the time origin using the specified method.
+     *
+     *    - firstResourceSendRequest
+     *      Uses the time that the very first network request is sent in the main frame.
+     *      Eventually should be used in place of lastNavigationStart as the default for navigations.
+     *      This method includes the cost of all redirects when evaluating a navigation (which matches lantern behavior).
+     *      The only difference between firstResourceSendRequest and the first `navigationStart` is
+     *      the unload time of `about:blank` (which is a Lighthouse implementation detail and shouldn't be included).
+     *
+     *    - lastNavigationStart
+     *      Uses the time of the last `navigationStart` event in the main frame.
+     *      The historical time origin of Lighthouse from 2016-Present.
+     *      This method excludes the cost of client-side redirects when evaluating a navigation.
+     *      Can also be skewed by several hundred milliseconds or even seconds when the browser takes a long
+     *      time to unload `about:blank`.
+     *
+     * @param {{keyEvents: Array<LH.TraceEvent>, frameEvents: Array<LH.TraceEvent>, mainFrameIds: {frameId: string}}} traceEventSubsets
+     * @param {TimeOriginDeterminationMethod} method
+     * @return {LH.TraceEvent}
+     */
+    static computeTimeOrigin(traceEventSubsets: {
+        keyEvents: Array<LH.TraceEvent>;
+        frameEvents: Array<LH.TraceEvent>;
+        mainFrameIds: {
+            frameId: string;
+        };
+    }, method: TimeOriginDeterminationMethod): LH.TraceEvent;
+    /**
+     * Computes timings of trace events of key trace events in milliseconds since the time origin
+     * in addition to the standard microsecond monotonic timestamps.
+     * @param {Array<LH.TraceEvent>} frameEvents
+     * @param {{timeOriginEvt: LH.TraceEvent}} options
+    */
+    static computeNavigationTimingsForFrame(frameEvents: Array<LH.TraceEvent>, options: {
+        timeOriginEvt: LH.TraceEvent;
+    }): {
+        timings: TraceNavigationTimesForFrame;
+        timestamps: TraceNavigationTimesForFrame;
+        timeOriginEvt: import("../..").TraceEvent;
+        firstPaintEvt: import("../..").TraceEvent | undefined;
+        firstContentfulPaintEvt: import("../..").TraceEvent;
+        firstMeaningfulPaintEvt: import("../..").TraceEvent | undefined;
+        largestContentfulPaintEvt: LCPEvent | undefined;
+        loadEvt: import("../..").TraceEvent | undefined;
+        domContentLoadedEvt: import("../..").TraceEvent | undefined;
+        fmpFellBack: boolean;
+        lcpInvalidated: boolean;
+    };
+}
+//# sourceMappingURL=trace-processor.d.ts.map

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

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

package/core/lib/url-utils.d.ts

@@ -0,0 +1,100 @@
+export default UrlUtils;
+export type NetworkRequest = import('./network-request.js').NetworkRequest;
+declare class UrlUtils {
+    /**
+     * @param {string} url
+     * @return {boolean}
+     */
+    static isValid(url: string): boolean;
+    /**
+     * @param {string} urlA
+     * @param {string} urlB
+     * @return {boolean}
+     */
+    static hostsMatch(urlA: string, urlB: string): boolean;
+    /**
+     * @param {string} urlA
+     * @param {string} urlB
+     * @return {boolean}
+     */
+    static originsMatch(urlA: string, urlB: string): boolean;
+    /**
+     * @param {string} url
+     * @return {?string}
+     */
+    static getOrigin(url: string): string | null;
+    /**
+     * Check if rootDomains matches
+     *
+     * @param {string|URL} urlA
+     * @param {string|URL} urlB
+     */
+    static rootDomainsMatch(urlA: string | URL, urlB: string | URL): boolean;
+    /**
+     * @param {string} url
+     * @param {{numPathParts: number, preserveQuery: boolean, preserveHost: boolean}=} options
+     * @return {string}
+     */
+    static getURLDisplayName(url: string, options?: {
+        numPathParts: number;
+        preserveQuery: boolean;
+        preserveHost: boolean;
+    } | undefined): string;
+    /**
+     * Limits data URIs to 100 characters, returns all other strings untouched.
+     * @param {string} url
+     * @return {string}
+     */
+    static elideDataURI(url: string): string;
+    /**
+     * Determine if url1 equals url2, ignoring URL fragments.
+     * @param {string} url1
+     * @param {string} url2
+     * @return {boolean}
+     */
+    static equalWithExcludedFragments(url1: string, url2: string): boolean;
+    /**
+     * Determine if the url has a protocol that we're able to test
+     * @param {string} url
+     * @return {boolean}
+     */
+    static isProtocolAllowed(url: string): boolean;
+    /**
+     * Is the host localhost-enough to satisfy the "secure context" definition
+     * https://github.com/GoogleChrome/lighthouse/pull/11766#discussion_r582340683
+     * @param {string} hostname Either a `new URL(url).hostname` or a `networkRequest.parsedUrl.host`
+     * @return {boolean}
+     */
+    static isLikeLocalhost(hostname: string): boolean;
+    /**
+     * @param {NetworkRequest['parsedURL']['scheme']} scheme
+     * @return {boolean}
+     */
+    static isSecureScheme(scheme: NetworkRequest['parsedURL']['scheme']): boolean;
+    /**
+     * Use `NetworkRequest.isNonNetworkRequest(req)` if working with a request.
+     * Note: the `protocol` field from CDP can be 'h2', 'http', (not 'https'!) or it'll be url's scheme.
+     *   https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/protocol/network_handler.cc;l=598-611;drc=56d4a9a9deb30be73adcee8737c73bcb2a5ab64f
+     * However, a `new URL(href).protocol` has a colon suffix.
+     *   https://url.spec.whatwg.org/#dom-url-protocol
+     * A URL's `scheme` is specced as the `protocol` sans-colon, but isn't exposed on a URL object.
+     * This method can take all 3 of these string types as a parameter.
+     * @param {NetworkRequest['protocol'] | URL['protocol']} protocol Either a networkRequest's `protocol` per CDP or a `new URL(href).protocol`
+     * @return {boolean}
+     */
+    static isNonNetworkProtocol(protocol: NetworkRequest['protocol'] | URL['protocol']): boolean;
+    /**
+     * @param {string} src
+     * @return {string|undefined}
+     */
+    static guessMimeType(src: string): string | undefined;
+    /**
+     * @param {string|undefined} url
+     * @return {string}
+     */
+    static normalizeUrl(url: string | undefined): string;
+}
+declare namespace UrlUtils {
+    const INVALID_URL_DEBUG_STRING: string;
+}
+//# sourceMappingURL=url-utils.d.ts.map

package/core/runner.d.ts

@@ -0,0 +1,109 @@
+export type Connection = import('./legacy/gather/connections/connection.js').Connection;
+export type ArbitraryEqualityMap = import('./lib/arbitrary-equality-map.js').ArbitraryEqualityMap;
+export type Config = LH.Config.LegacyResolvedConfig;
+/** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
+/** @typedef {import('./lib/arbitrary-equality-map.js').ArbitraryEqualityMap} ArbitraryEqualityMap */
+/** @typedef {LH.Config.LegacyResolvedConfig} Config */
+export class Runner {
+    /**
+     * @template {LH.Config.LegacyResolvedConfig | LH.Config.ResolvedConfig} TConfig
+     * @param {LH.Artifacts} artifacts
+     * @param {{resolvedConfig: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
+     * @return {Promise<LH.RunnerResult|undefined>}
+     */
+    static audit<TConfig extends import("../types/config.js").default.ResolvedConfig | import("../types/config.js").default.LegacyResolvedConfig>(artifacts: LH.Artifacts, options: {
+        resolvedConfig: TConfig;
+        driverMock?: Driver | undefined;
+        computedCache: Map<string, ArbitraryEqualityMap>;
+    }): Promise<LH.RunnerResult | undefined>;
+    /**
+     * User can run -G solo, -A solo, or -GA together
+     * -G and -A will run partial lighthouse pipelines,
+     * and -GA will run everything plus save artifacts and lhr to disk.
+     *
+     * @template {LH.Config.LegacyResolvedConfig | LH.Config.ResolvedConfig} TConfig
+     * @param {(runnerData: {resolvedConfig: TConfig, driverMock?: Driver}) => Promise<LH.Artifacts>} gatherFn
+     * @param {{resolvedConfig: TConfig, driverMock?: Driver, computedCache: Map<string, ArbitraryEqualityMap>}} options
+     * @return {Promise<LH.Artifacts>}
+     */
+    static gather<TConfig_1 extends import("../types/config.js").default.ResolvedConfig | import("../types/config.js").default.LegacyResolvedConfig>(gatherFn: (runnerData: {
+        resolvedConfig: TConfig_1;
+        driverMock?: Driver | undefined;
+    }) => Promise<LH.Artifacts>, options: {
+        resolvedConfig: TConfig_1;
+        driverMock?: Driver | undefined;
+        computedCache: Map<string, ArbitraryEqualityMap>;
+    }): Promise<LH.Artifacts>;
+    /**
+     * @param {any} err
+     * @param {LH.Config.Settings} settings
+     */
+    static createRunnerError(err: any, settings: LH.Config.Settings): any;
+    /**
+     * This handles both the auditMode case where gatherer entries need to be merged in and
+     * the gather/audit case where timingEntriesFromRunner contains all entries from this run,
+     * including those also in timingEntriesFromArtifacts.
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Result.Timing}
+     */
+    static _getTiming(artifacts: LH.Artifacts): LH.Result.Timing;
+    /**
+     * Establish connection, load page and collect all required artifacts
+     * @param {string} requestedUrl
+     * @param {{resolvedConfig: Config, computedCache: Map<string, ArbitraryEqualityMap>, driverMock?: Driver}} runnerOpts
+     * @param {Connection} connection
+     * @return {Promise<LH.Artifacts>}
+     */
+    static _gatherArtifactsFromBrowser(requestedUrl: string, runnerOpts: {
+        resolvedConfig: Config;
+        computedCache: Map<string, ArbitraryEqualityMap>;
+        driverMock?: Driver;
+    }, connection: Connection): Promise<LH.Artifacts>;
+    /**
+     * Run all audits with specified settings and artifacts.
+     * @param {LH.Config.Settings} settings
+     * @param {Array<LH.Config.AuditDefn>} audits
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<string | LH.IcuMessage>} runWarnings
+     * @param {Map<string, ArbitraryEqualityMap>} computedCache
+     * @return {Promise<Record<string, LH.RawIcu<LH.Audit.Result>>>}
+     */
+    static _runAudits(settings: LH.Config.Settings, audits: Array<LH.Config.AuditDefn>, artifacts: LH.Artifacts, runWarnings: Array<string | LH.IcuMessage>, computedCache: Map<string, ArbitraryEqualityMap>): Promise<Record<string, LH.RawIcu<LH.Audit.Result>>>;
+    /**
+     * Checks that the audit's required artifacts exist and runs the audit if so.
+     * Otherwise returns error audit result.
+     * @param {LH.Config.AuditDefn} auditDefn
+     * @param {LH.Artifacts} artifacts
+     * @param {Pick<LH.Audit.Context, 'settings'|'computedCache'>} sharedAuditContext
+     * @param {Array<string | LH.IcuMessage>} runWarnings
+     * @return {Promise<LH.RawIcu<LH.Audit.Result>>}
+     * @private
+     */
+    private static _runAudit;
+    /**
+     * Searches a pass's artifacts for any `lhrRuntimeError` error artifacts.
+     * Returns the first one found or `null` if none found.
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.RawIcu<LH.Result['runtimeError']>|undefined}
+     */
+    static getArtifactRuntimeError(artifacts: LH.Artifacts): LH.RawIcu<LH.Result['runtimeError']> | undefined;
+    /**
+     * Returns list of audit names for external querying.
+     * @return {Array<string>}
+     */
+    static getAuditList(): Array<string>;
+    /**
+     * Returns list of gatherer names for external querying.
+     * @return {Array<string>}
+     */
+    static getGathererList(): Array<string>;
+    /**
+     * Get path to use for -G and -A modes. Defaults to $CWD/latest-run
+     * @param {LH.Config.Settings} settings
+     * @return {string}
+     */
+    static _getDataSavePath(settings: LH.Config.Settings): string;
+}
+import { Driver } from "./legacy/gather/driver.js";
+import { Audit } from "./audits/audit.js";
+//# sourceMappingURL=runner.d.ts.map

package/core/scoring.d.ts

@@ -0,0 +1,26 @@
+export class ReportScoring {
+    /**
+     * Computes the weighted-average of the score of the list of items.
+     * @param {Array<{score: number|null, weight: number}>} items
+     * @return {number|null}
+     */
+    static arithmeticMean(items: Array<{
+        score: number | null;
+        weight: number;
+    }>): number | null;
+    /**
+     * Returns the report JSON object with computed scores.
+     * @param {Object<string, LH.Config.Category>} configCategories
+     * @param {Object<string, LH.RawIcu<LH.Audit.Result>>} resultsByAuditId
+     * @return {Object<string, LH.RawIcu<LH.Result.Category>>}
+     */
+    static scoreAllCategories(configCategories: {
+        [x: string]: LH.Config.Category;
+    }, resultsByAuditId: {
+        [x: string]: LH.RawIcu<LH.Audit.Result>;
+    }): {
+        [x: string]: LH.RawIcu<LH.Result.Category>;
+    };
+}
+import { Audit } from "./audits/audit.js";
+//# sourceMappingURL=scoring.d.ts.map