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

package/core/audits/unsized-images.d.ts

@@ -0,0 +1,39 @@
+export default UnsizedImages;
+declare class UnsizedImages extends Audit {
+    /**
+     * An img size attribute prevents layout shifts if it is a non-negative integer (incl zero!).
+     * @url https://html.spec.whatwg.org/multipage/embedded-content-other.html#dimension-attributes
+     * @param {string | null} attrValue
+     * @return {boolean}
+     */
+    static doesHtmlAttrProvideExplicitSize(attrValue: string | null): boolean;
+    /**
+     * An img css size property prevents layout shifts if it is defined, not empty, and not equal to 'auto'.
+     * @param {string | null} property
+     * @return {boolean}
+     */
+    static isCssPropExplicitlySet(property: string | null): boolean;
+    /**
+     * Images are considered sized if they have defined & valid values.
+     * @param {LH.Artifacts.ImageElement} image
+     * @return {boolean}
+     */
+    static isSizedImage(image: LH.Artifacts.ImageElement): boolean;
+    /**
+     * @param {LH.Artifacts.ImageElement} image
+     * @return {boolean}
+     */
+    static isNonNetworkSvg(image: LH.Artifacts.ImageElement): boolean;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=unsized-images.d.ts.map

package/core/audits/user-timings.d.ts

@@ -0,0 +1,43 @@
+export default UserTimings;
+export type MarkEvent = {
+    name: string;
+    isMark: true;
+    args: LH.TraceEvent['args'];
+    startTime: number;
+};
+export type MeasureEvent = {
+    name: string;
+    isMark: false;
+    args: LH.TraceEvent['args'];
+    startTime: number;
+    endTime: number;
+    duration: number;
+};
+/** @typedef {{name: string, isMark: true, args: LH.TraceEvent['args'], startTime: number}} MarkEvent */
+/** @typedef {{name: string, isMark: false, args: LH.TraceEvent['args'], startTime: number, endTime: number, duration: number}} MeasureEvent */
+declare class UserTimings extends Audit {
+    /**
+     * @return {Array<string>}
+     */
+    static get excludedPrefixes(): string[];
+    /**
+     * We remove mark/measures entered by third parties not of interest to the user
+     * @param {MarkEvent|MeasureEvent} evt
+     * @return {boolean}
+     */
+    static excludeEvent(evt: MarkEvent | MeasureEvent): boolean;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const displayValue: string;
+    const columnType: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=user-timings.d.ts.map

package/core/audits/uses-rel-preconnect.d.ts

@@ -0,0 +1,37 @@
+export default UsesRelPreconnectAudit;
+declare class UsesRelPreconnectAudit extends Audit {
+    /**
+     * Check if record has valid timing
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {boolean}
+     */
+    static hasValidTiming(record: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Check is the connection is already open
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {boolean}
+     */
+    static hasAlreadyConnectedToOrigin(record: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Check is the connection has started before the socket idle time
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @return {boolean}
+     */
+    static socketStartTimeIsBelowThreshold(record: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const unusedWarning: string;
+    const crossoriginWarning: string;
+    const tooManyPreconnectLinksWarning: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=uses-rel-preconnect.d.ts.map

package/core/audits/uses-rel-preload.d.ts

@@ -0,0 +1,61 @@
+export default UsesRelPreloadAudit;
+declare class UsesRelPreloadAudit extends Audit {
+    /**
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @return {Set<string>}
+     */
+    static getURLsToPreload(mainResource: LH.Artifacts.NetworkRequest, graph: LH.Gatherer.Simulation.GraphNode): Set<string>;
+    /**
+     * Finds which URLs were attempted to be preloaded, but failed to be reused and were requested again.
+     *
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @return {Set<string>}
+     */
+    static getURLsFailedToPreload(graph: LH.Gatherer.Simulation.GraphNode): Set<string>;
+    /**
+     * We want to preload all first party critical requests at depth 2.
+     * Third party requests can be tricky to know the URL ahead of time.
+     * Critical requests at depth 1 would already be identified by the browser for preloading.
+     * Critical requests deeper than depth 2 are more likely to be a case-by-case basis such that it
+     * would be a little risky to recommend blindly.
+     *
+     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @param {Array<LH.Gatherer.Simulation.GraphNode>} initiatorPath
+     * @return {boolean}
+     */
+    static shouldPreloadRequest(request: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest, initiatorPath: Array<LH.Gatherer.Simulation.GraphNode>): boolean;
+    /**
+     * Computes the estimated effect of preloading all the resources.
+     * @param {Set<string>} urls The array of byte savings results per resource
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @param {LH.Gatherer.Simulation.Simulator} simulator
+     * @return {{wastedMs: number, results: Array<{url: string, wastedMs: number}>}}
+     */
+    static computeWasteWithGraph(urls: Set<string>, graph: LH.Gatherer.Simulation.GraphNode, simulator: LH.Gatherer.Simulation.Simulator): {
+        wastedMs: number;
+        results: Array<{
+            url: string;
+            wastedMs: number;
+        }>;
+    };
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit_(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+    /**
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const crossoriginWarning: string;
+}
+import { Audit } from "./audit.js";
+import { NetworkRequest } from "../lib/network-request.js";
+//# sourceMappingURL=uses-rel-preload.d.ts.map

package/core/audits/valid-source-maps.d.ts

@@ -0,0 +1,27 @@
+export default ValidSourceMaps;
+declare class ValidSourceMaps extends Audit {
+    /**
+     * Returns true if the size of the script exceeds a static threshold.
+     * @param {LH.Artifacts.Script} script
+     * @param {string} finalURL
+     * @return {boolean}
+     */
+    static isLargeFirstPartyJS(script: LH.Artifacts.Script, finalURL: string): boolean;
+    /**
+     * @param {LH.Artifacts} artifacts
+     */
+    static audit(artifacts: LH.Artifacts): Promise<{
+        score: number;
+        details: import("../../types/lhr/audit-details.js").default.Table;
+    }>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnMapURL: string;
+    const missingSourceMapErrorMessage: string;
+    const missingSourceMapItemsWarningMesssage: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=valid-source-maps.d.ts.map

package/core/audits/viewport.d.ts

@@ -0,0 +1,17 @@
+export default Viewport;
+declare class Viewport extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const explanationNoTag: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=viewport.d.ts.map

package/core/audits/violation-audit.d.ts

@@ -0,0 +1,14 @@
+export default ViolationAudit;
+declare class ViolationAudit extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @param {RegExp} pattern
+     * @return {Promise<Array<{source: LH.Audit.Details.SourceLocationValue}>>}
+     */
+    static getViolationResults(artifacts: LH.Artifacts, context: LH.Audit.Context, pattern: RegExp): Promise<Array<{
+        source: LH.Audit.Details.SourceLocationValue;
+    }>>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=violation-audit.d.ts.map

package/core/audits/work-during-interaction.d.ts

@@ -0,0 +1,82 @@
+export default WorkDuringInteraction;
+export type EventTimingEvent = import('../computed/metrics/responsiveness.js').EventTimingEvent;
+export type TaskNode = import('../lib/tracehouse/main-thread-tasks.js').TaskNode;
+/**
+ * @fileoverview This metric gives a high-percentile measure of responsiveness to input.
+ */
+declare class WorkDuringInteraction extends Audit {
+    /**
+     * @param {TaskNode} task
+     * @param {TaskNode|undefined} parent
+     * @param {number} startTs
+     * @param {number} endTs
+     * @return {number}
+     */
+    static recursivelyClipTasks(task: TaskNode, parent: TaskNode | undefined, startTs: number, endTs: number): number;
+    /**
+     * Clip the tasks by the start and end points. Take the easy route and drop
+     * to duration 0 if out of bounds, since only durations are needed in the
+     * end (for now).
+     * Assumes owned tasks, so modifies in place. Can be called multiple times on
+     * the same `tasks` because always computed from original event timing.
+     * @param {Array<TaskNode>} tasks
+     * @param {number} startTs
+     * @param {number} endTs
+     */
+    static clipTasksByTs(tasks: Array<TaskNode>, startTs: number, endTs: number): void;
+    /**
+     * @param {EventTimingEvent} interactionEvent
+     */
+    static getPhaseTimes(interactionEvent: EventTimingEvent): {
+        inputDelay: {
+            startTs: number;
+            endTs: number;
+        };
+        processingTime: {
+            startTs: number;
+            endTs: number;
+        };
+        presentationDelay: {
+            startTs: number;
+            endTs: number;
+        };
+    };
+    /**
+     * @param {EventTimingEvent} interactionEvent
+     * @param {LH.Trace} trace
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {{table: LH.Audit.Details.Table, phases: Record<string, {startTs: number, endTs: number}>}}
+     */
+    static getThreadBreakdownTable(interactionEvent: EventTimingEvent, trace: LH.Trace, processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<LH.Artifacts.NetworkRequest>): {
+        table: LH.Audit.Details.Table;
+        phases: Record<string, {
+            startTs: number;
+            endTs: number;
+        }>;
+    };
+    /**
+     * @param {LH.Artifacts['TraceElements']} traceElements
+     * @return {LH.Audit.Details.Table | undefined}
+     */
+    static getTraceElementTable(traceElements: LH.Artifacts['TraceElements']): LH.Audit.Details.Table | undefined;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const inputDelay: string;
+    const processingTime: string;
+    const presentationDelay: string;
+    const displayValue: string;
+    const eventTarget: string;
+}
+import { Audit } from "./audit.js";
+import { ProcessedTrace } from "../computed/processed-trace.js";
+//# sourceMappingURL=work-during-interaction.d.ts.map

package/core/computed/computed-artifact.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decorate computableArtifact with a caching `request()` method which will
+ * automatically call `computableArtifact.compute_()` under the hood.
+ * @template {{name: string, compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>}} C
+ * @template {Array<keyof LH.Util.FirstParamType<C['compute_']>>} K
+ * @param {C} computableArtifact
+ * @param {(K & ([keyof LH.Util.FirstParamType<C['compute_']>] extends [K[number]] ? unknown : never)) | null} keys List of properties of `dependencies` used by `compute_`; other properties are filtered out. Use `null` to allow all properties. Ensures that only required properties are used for caching result.
+ */
+export function makeComputedArtifact<C extends {
+    name: string;
+    compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>;
+}, K extends (keyof import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>)[]>(computableArtifact: C, keys: (K & ([keyof import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>] extends [K[number]] ? unknown : never)) | null): C & {
+    request: (dependencies: import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>, context: LH.Artifacts.ComputedContext) => ReturnType<C["compute_"]>;
+};
+//# sourceMappingURL=computed-artifact.d.ts.map

package/core/computed/critical-request-chains.d.ts

@@ -0,0 +1,40 @@
+export { CriticalRequestChainsComputed as CriticalRequestChains };
+declare const CriticalRequestChainsComputed: typeof CriticalRequestChains & {
+    request: (dependencies: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        trace: LH.Trace;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.CriticalRequestNode>;
+};
+declare class CriticalRequestChains {
+    /**
+     * For now, we use network priorities as a proxy for "render-blocking"/critical-ness.
+     * It's imperfect, but there is not a higher-fidelity signal available yet.
+     * @see https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuMlc
+     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @return {boolean}
+     */
+    static isCritical(request: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Create a tree of critical requests.
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @return {LH.Artifacts.CriticalRequestNode}
+     */
+    static extractChainsFromGraph(mainResource: LH.Artifacts.NetworkRequest, graph: LH.Gatherer.Simulation.GraphNode): LH.Artifacts.CriticalRequestNode;
+    /**
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.CriticalRequestNode>}
+     */
+    static compute_(data: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        trace: LH.Trace;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.CriticalRequestNode>;
+}
+import { NetworkRequest } from "../lib/network-request.js";
+//# sourceMappingURL=critical-request-chains.d.ts.map

package/core/computed/image-records.d.ts

@@ -0,0 +1,24 @@
+export { ImageRecordsComputed as ImageRecords };
+declare const ImageRecordsComputed: typeof ImageRecords & {
+    request: (dependencies: {
+        ImageElements: LH.Artifacts['ImageElements'];
+        networkRecords: LH.Artifacts.NetworkRequest[];
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.ImageElementRecord[]>;
+};
+declare class ImageRecords {
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     */
+    static indexNetworkRecords(networkRecords: LH.Artifacts.NetworkRequest[]): Record<string, import("../lib/network-request.js").NetworkRequest>;
+    /**
+     * @param {{ImageElements: LH.Artifacts['ImageElements'], networkRecords: LH.Artifacts.NetworkRequest[]}} data
+     * @return {Promise<LH.Artifacts.ImageElementRecord[]>}
+     */
+    static compute_(data: {
+        ImageElements: LH.Artifacts['ImageElements'];
+        networkRecords: LH.Artifacts.NetworkRequest[];
+    }): Promise<LH.Artifacts.ImageElementRecord[]>;
+}
+//# sourceMappingURL=image-records.d.ts.map

package/core/computed/js-bundles.d.ts

@@ -0,0 +1,13 @@
+export { JSBundlesComputed as JSBundles };
+declare const JSBundlesComputed: typeof JSBundles & {
+    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.Bundle[]>;
+};
+declare class JSBundles {
+    /**
+     * @param {Pick<LH.Artifacts, 'SourceMaps'|'Scripts'>} artifacts
+     */
+    static compute_(artifacts: Pick<LH.Artifacts, 'SourceMaps' | 'Scripts'>): Promise<import("../index.js").Artifacts.Bundle[]>;
+}
+//# sourceMappingURL=js-bundles.d.ts.map

package/core/computed/load-simulator.d.ts

@@ -0,0 +1,28 @@
+export { LoadSimulatorComputed as LoadSimulator };
+declare const LoadSimulatorComputed: typeof LoadSimulator & {
+    request: (dependencies: {
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        settings: LH.Audit.Context['settings'];
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<Simulator>;
+};
+declare class LoadSimulator {
+    /**
+     * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Simulator>}
+     */
+    static compute_(data: {
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        settings: LH.Audit.Context['settings'];
+    }, context: LH.Artifacts.ComputedContext): Promise<Simulator>;
+    /**
+     * @param {LH.Artifacts.NetworkAnalysis} networkAnalysis
+     * @return {LH.PrecomputedLanternData}
+     */
+    static convertAnalysisToSaveableLanternData(networkAnalysis: LH.Artifacts.NetworkAnalysis): LH.PrecomputedLanternData;
+}
+import { Simulator } from "../lib/dependency-graph/simulator/simulator.js";
+import { NetworkAnalysis } from "./network-analysis.js";
+//# sourceMappingURL=load-simulator.d.ts.map

package/core/computed/main-resource.d.ts

@@ -0,0 +1,25 @@
+export { MainResourceComputed as MainResource };
+declare const MainResourceComputed: typeof MainResource & {
+    request: (dependencies: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/network-request.js").NetworkRequest>;
+};
+/**
+ * @fileoverview This artifact identifies the main resource on the page. Current solution assumes
+ * that the main resource is the first non-rediected one.
+ */
+declare class MainResource {
+    /**
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.NetworkRequest>}
+     */
+    static compute_(data: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.NetworkRequest>;
+}
+//# sourceMappingURL=main-resource.d.ts.map

package/core/computed/main-thread-tasks.d.ts

@@ -0,0 +1,15 @@
+export { MainThreadTasksComputed as MainThreadTasks };
+declare const MainThreadTasksComputed: typeof MainThreadTasks & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/tracehouse/main-thread-tasks.js").TaskNode[]>;
+};
+declare class MainThreadTasks {
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Array<LH.Artifacts.TaskNode>>}
+     */
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<Array<LH.Artifacts.TaskNode>>;
+}
+//# sourceMappingURL=main-thread-tasks.d.ts.map

package/core/computed/manifest-values.d.ts

@@ -0,0 +1,24 @@
+export { ManifestValuesComputed as ManifestValues };
+declare const ManifestValuesComputed: typeof ManifestValues & {
+    request: (dependencies: Pick<import("../index.js").Artifacts, "InstallabilityErrors" | "WebAppManifest">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.ManifestValues>;
+};
+declare class ManifestValues {
+    /** @typedef {(val: NonNullable<LH.Artifacts.Manifest['value']>, errors: LH.Artifacts.InstallabilityErrors['errors']) => boolean} Validator */
+    /**
+     * @return {Array<{id: LH.Artifacts.ManifestValueCheckID, failureText: string, validate: Validator}>}
+     */
+    static get manifestChecks(): {
+        id: LH.Artifacts.ManifestValueCheckID;
+        failureText: string;
+        validate: (val: NonNullable<LH.Artifacts.Manifest['value']>, errors: LH.Artifacts.InstallabilityErrors['errors']) => boolean;
+    }[];
+    /**
+     * Returns results of all manifest checks
+     * @param {Pick<LH.Artifacts, 'WebAppManifest'|'InstallabilityErrors'>} Manifest
+     * @return {Promise<LH.Artifacts.ManifestValues>}
+     */
+    static compute_({ WebAppManifest, InstallabilityErrors }: Pick<LH.Artifacts, 'WebAppManifest' | 'InstallabilityErrors'>): Promise<LH.Artifacts.ManifestValues>;
+}
+//# sourceMappingURL=manifest-values.d.ts.map

package/core/computed/metrics/cumulative-layout-shift.d.ts

@@ -0,0 +1,53 @@
+export { CumulativeLayoutShiftComputed as CumulativeLayoutShift };
+export type LayoutShiftEvent = {
+    ts: number;
+    isMainFrame: boolean;
+    weightedScore: number;
+};
+declare const CumulativeLayoutShiftComputed: typeof CumulativeLayoutShift & {
+    request: (dependencies: import("../../index.js").Trace, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<{
+        cumulativeLayoutShift: number;
+        cumulativeLayoutShiftMainFrame: number;
+        totalCumulativeLayoutShift: number;
+    }>;
+};
+/** @typedef {{ts: number, isMainFrame: boolean, weightedScore: number}} LayoutShiftEvent */
+declare class CumulativeLayoutShift {
+    /**
+     * Returns all LayoutShift events that had no recent input.
+     * Only a `weightedScore` per event is returned. For non-main-frame events, this is
+     * the only score that matters. For main-frame events, `weighted_score_delta === score`.
+     * @see https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/layout/layout_shift_tracker.cc;l=492-495;drc=de3b3a8a8839269c6b44403fa38a13a1ed12fed5
+     * @param {LH.TraceEvent[]} traceEvents
+     * @return {Array<LayoutShiftEvent>}
+     */
+    static getLayoutShiftEvents(traceEvents: LH.TraceEvent[]): Array<LayoutShiftEvent>;
+    /**
+     * Calculates cumulative layout shifts per cluster (session) of LayoutShift
+     * events -- where a new cluster is created when there's a gap of more than
+     * 1000ms since the last LayoutShift event or the cluster is greater than
+     * 5000ms long -- and returns the max LayoutShift score found.
+     * @param {Array<LayoutShiftEvent>} layoutShiftEvents
+     * @return {number}
+     */
+    static calculate(layoutShiftEvents: Array<LayoutShiftEvent>): number;
+    /**
+     * Sum all layout shift events from the entire trace.
+     * @param {Array<LayoutShiftEvent>} layoutShiftEvents
+     * @return {number}
+     */
+    static calculateTotalCumulativeLayoutShift(layoutShiftEvents: Array<LayoutShiftEvent>): number;
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<{cumulativeLayoutShift: number, cumulativeLayoutShiftMainFrame: number, totalCumulativeLayoutShift: number}>}
+     */
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<{
+        cumulativeLayoutShift: number;
+        cumulativeLayoutShiftMainFrame: number;
+        totalCumulativeLayoutShift: number;
+    }>;
+}
+//# sourceMappingURL=cumulative-layout-shift.d.ts.map

package/core/computed/metrics/first-contentful-paint-all-frames.d.ts

@@ -0,0 +1,19 @@
+export { FirstContentfulPaintAllFramesComputed as FirstContentfulPaintAllFrames };
+declare const FirstContentfulPaintAllFramesComputed: typeof FirstContentfulPaintAllFrames & {
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class FirstContentfulPaintAllFrames extends NavigationMetric {
+    /**
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(): Promise<LH.Artifacts.LanternMetric>;
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=first-contentful-paint-all-frames.d.ts.map

package/core/computed/metrics/first-contentful-paint.d.ts

@@ -0,0 +1,15 @@
+export { FirstContentfulPaintComputed as FirstContentfulPaint };
+declare const FirstContentfulPaintComputed: typeof FirstContentfulPaint & {
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class FirstContentfulPaint extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=first-contentful-paint.d.ts.map

package/core/computed/metrics/first-meaningful-paint.d.ts

@@ -0,0 +1,15 @@
+export { FirstMeaningfulPaintComputed as FirstMeaningfulPaint };
+declare const FirstMeaningfulPaintComputed: typeof FirstMeaningfulPaint & {
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class FirstMeaningfulPaint extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=first-meaningful-paint.d.ts.map