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

package/core/gather/navigation-runner.d.ts

@@ -0,0 +1,92 @@
+export type NavigationContext = {
+    driver: Driver;
+    page: LH.Puppeteer.Page;
+    resolvedConfig: LH.Config.ResolvedConfig;
+    navigation: LH.Config.NavigationDefn;
+    requestor: LH.NavigationRequestor;
+    baseArtifacts: LH.FRBaseArtifacts;
+    computedCache: Map<string, LH.ArbitraryEqualityMap>;
+};
+export type PhaseState = Omit<Parameters<typeof collectPhaseArtifacts>[0], 'phase'>;
+/**
+ * @param {LH.Puppeteer.Page|undefined} page
+ * @param {LH.NavigationRequestor|undefined} requestor
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.Gatherer.FRGatherResult>}
+ */
+export function navigationGather(page: LH.Puppeteer.Page | undefined, requestor: LH.NavigationRequestor | undefined, options?: {
+    config?: import("../../types/config.js").default | undefined;
+    flags?: import("../index.js").Flags | undefined;
+} | undefined): Promise<LH.Gatherer.FRGatherResult>;
+/**
+ * @param {{driver: Driver, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor}} args
+ * @return {Promise<{baseArtifacts: LH.FRBaseArtifacts}>}
+ */
+export function _setup({ driver, resolvedConfig, requestor }: {
+    driver: Driver;
+    resolvedConfig: LH.Config.ResolvedConfig;
+    requestor: LH.NavigationRequestor;
+}): Promise<{
+    baseArtifacts: LH.FRBaseArtifacts;
+}>;
+/**
+ * @param {NavigationContext} navigationContext
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
+ */
+export function _setupNavigation({ requestor, driver, navigation, resolvedConfig }: NavigationContext): Promise<{
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * @param {NavigationContext} navigationContext
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
+ */
+export function _navigate(navigationContext: NavigationContext): Promise<{
+    requestedUrl: string;
+    mainDocumentUrl: string;
+    navigationError: LH.LighthouseError | undefined;
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * @param {NavigationContext} navigationContext
+ * @return {ReturnType<typeof _computeNavigationResult>}
+ */
+export function _navigation(navigationContext: NavigationContext): ReturnType<typeof _computeNavigationResult>;
+/**
+ * @param {{driver: Driver, page: LH.Puppeteer.Page, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.FRBaseArtifacts, computedCache: NavigationContext['computedCache']}} args
+ * @return {Promise<{artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>}>}
+ */
+export function _navigations(args: {
+    driver: Driver;
+    page: LH.Puppeteer.Page;
+    resolvedConfig: LH.Config.ResolvedConfig;
+    requestor: LH.NavigationRequestor;
+    baseArtifacts: LH.FRBaseArtifacts;
+    computedCache: NavigationContext['computedCache'];
+}): Promise<{
+    artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>;
+}>;
+/**
+ * @param {{requestedUrl?: string, driver: Driver, resolvedConfig: LH.Config.ResolvedConfig}} args
+ */
+export function _cleanup({ requestedUrl, driver, resolvedConfig }: {
+    requestedUrl?: string;
+    driver: Driver;
+    resolvedConfig: LH.Config.ResolvedConfig;
+}): Promise<void>;
+import { Driver } from "./driver.js";
+import { collectPhaseArtifacts } from "./runner-helpers.js";
+import { LighthouseError } from "../lib/lh-error.js";
+/**
+ * @param {NavigationContext} navigationContext
+ * @param {PhaseState} phaseState
+ * @param {Awaited<ReturnType<typeof _setupNavigation>>} setupResult
+ * @param {Awaited<ReturnType<typeof _navigate>>} navigateResult
+ * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
+ */
+declare function _computeNavigationResult(navigationContext: NavigationContext, phaseState: PhaseState, setupResult: Awaited<ReturnType<typeof _setupNavigation>>, navigateResult: Awaited<ReturnType<typeof _navigate>>): Promise<{
+    artifacts: Partial<LH.GathererArtifacts>;
+    warnings: Array<LH.IcuMessage>;
+    pageLoadError: LH.LighthouseError | undefined;
+}>;
+export {};
+//# sourceMappingURL=navigation-runner.d.ts.map

package/core/gather/runner-helpers.d.ts

@@ -0,0 +1,39 @@
+export type CollectPhaseArtifactOptions = {
+    driver: import('./driver.js').Driver;
+    page: LH.Puppeteer.Page;
+    artifactDefinitions: Array<LH.Config.AnyArtifactDefn>;
+    artifactState: ArtifactState;
+    baseArtifacts: LH.FRBaseArtifacts;
+    phase: LH.Gatherer.FRGatherPhase;
+    gatherMode: LH.Gatherer.GatherMode;
+    computedCache: Map<string, LH.ArbitraryEqualityMap>;
+    settings: LH.Config.Settings;
+};
+export type IntermediateArtifacts = Record<string, Promise<any>>;
+export type ArtifactState = Record<CollectPhaseArtifactOptions['phase'], IntermediateArtifacts>;
+export type Dependencies = LH.Gatherer.FRTransitionalContext<LH.Gatherer.DependencyKey>['dependencies'];
+/** @return {ArtifactState} */
+export function getEmptyArtifactState(): ArtifactState;
+/**
+ * Awaits the result of artifact, catching errors to set the artifact to an error instead.
+ *
+ * @param {ArtifactState} artifactState
+ * @return {Promise<Partial<LH.GathererArtifacts>>}
+ */
+export function awaitArtifacts(artifactState: ArtifactState): Promise<Partial<LH.GathererArtifacts>>;
+/**
+ * Runs the gatherer methods for a particular navigation phase (startInstrumentation/getArtifact/etc).
+ * All gatherer method return values are stored on the artifact state object, organized by phase.
+ * This method collects required dependencies, runs the applicable gatherer methods, and saves the
+ * result on the artifact state object that was passed as part of `options`.
+ *
+ * @param {CollectPhaseArtifactOptions} options
+ */
+export function collectPhaseArtifacts(options: CollectPhaseArtifactOptions): Promise<void>;
+/**
+ * @param {LH.Config.AnyArtifactDefn} artifact
+ * @param {Record<string, LH.Gatherer.PhaseResult>} artifactsById
+ * @return {Promise<Dependencies>}
+ */
+export function collectArtifactDependencies(artifact: LH.Config.AnyArtifactDefn, artifactsById: Record<string, LH.Gatherer.PhaseResult>): Promise<Dependencies>;
+//# sourceMappingURL=runner-helpers.d.ts.map

package/core/gather/session.d.ts

@@ -0,0 +1,50 @@
+export type CrdpEventMessageEmitter = LH.Protocol.StrictEventEmitterClass<LH.CrdpEvents>;
+declare const ProtocolSession_base: CrdpEventMessageEmitter;
+/** @implements {LH.Gatherer.FRProtocolSession} */
+export class ProtocolSession extends ProtocolSession_base implements LH.Gatherer.FRProtocolSession {
+    /**
+     * @param {LH.Puppeteer.CDPSession} cdpSession
+     */
+    constructor(cdpSession: LH.Puppeteer.CDPSession);
+    _cdpSession: import("../../types/puppeteer.js").default.CDPSession;
+    /** @type {LH.Crdp.Target.TargetInfo|undefined} */
+    _targetInfo: LH.Crdp.Target.TargetInfo | undefined;
+    /** @type {number|undefined} */
+    _nextProtocolTimeout: number | undefined;
+    /**
+     * Re-emit protocol events from the underlying CDPSession.
+     * @template {keyof LH.CrdpEvents} E
+     * @param {E} method
+     * @param {LH.CrdpEvents[E]} params
+     */
+    _handleProtocolEvent<E extends keyof import("puppeteer-core").ProtocolMapping.Events>(method: E, ...params: import("puppeteer-core").ProtocolMapping.Events[E]): void;
+    id(): string;
+    /** @param {LH.Crdp.Target.TargetInfo} targetInfo */
+    setTargetInfo(targetInfo: LH.Crdp.Target.TargetInfo): void;
+    /**
+     * @return {boolean}
+     */
+    hasNextProtocolTimeout(): boolean;
+    /**
+     * @return {number}
+     */
+    getNextProtocolTimeout(): number;
+    /**
+     * @param {number} ms
+     */
+    setNextProtocolTimeout(ms: number): void;
+    /**
+     * @template {keyof LH.CrdpCommands} C
+     * @param {C} method
+     * @param {LH.CrdpCommands[C]['paramsType']} params
+     * @return {Promise<LH.CrdpCommands[C]['returnType']>}
+     */
+    sendCommand<C extends keyof import("puppeteer-core").ProtocolMapping.Commands>(method: C, ...params: import("puppeteer-core").ProtocolMapping.Commands[C]["paramsType"]): Promise<import("puppeteer-core").ProtocolMapping.Commands[C]["returnType"]>;
+    /**
+     * Disposes of a session so that it can no longer talk to Chrome.
+     * @return {Promise<void>}
+     */
+    dispose(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=session.d.ts.map

package/core/gather/snapshot-runner.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.Gatherer.FRGatherResult>}
+ */
+export function snapshotGather(page: LH.Puppeteer.Page, options?: {
+    config?: import("../../types/config.js").default | undefined;
+    flags?: import("../index.js").Flags | undefined;
+} | undefined): Promise<LH.Gatherer.FRGatherResult>;
+//# sourceMappingURL=snapshot-runner.d.ts.map

package/core/gather/timespan-runner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<{endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>}>}
+ */
+export function startTimespanGather(page: LH.Puppeteer.Page, options?: {
+    config?: import("../../types/config.js").default | undefined;
+    flags?: import("../index.js").Flags | undefined;
+} | undefined): Promise<{
+    endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>;
+}>;
+//# sourceMappingURL=timespan-runner.d.ts.map

package/core/index.d.cts

@@ -0,0 +1,4 @@
+export = lighthouse;
+/** @type {import('./index.js')['default']} */
+declare const lighthouse: typeof import("./index.js")['default'];
+//# sourceMappingURL=index.d.cts.map

package/core/index.d.ts

@@ -0,0 +1,88 @@
+export default lighthouse;
+export { Audit } from "./audits/audit.js";
+export { default as Gatherer } from "./gather/base-gatherer.js";
+export { NetworkRecords } from "./computed/network-records.js";
+export { default as defaultConfig } from "./config/default-config.js";
+export { default as desktopConfig } from "./config/desktop-config.js";
+export * from "../types/lh.js";
+export type Connection = import('./legacy/gather/connections/connection.js').Connection;
+/** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
+/**
+ * Run Lighthouse.
+ * @param {string=} url The URL to test. Optional if running in auditMode.
+ * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
+ *   they will override any settings in the config.
+ * @param {LH.Config=} config Configuration for the Lighthouse run. If
+ *   not present, the default config is used.
+ * @param {LH.Puppeteer.Page=} page
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+declare function lighthouse(url?: string | undefined, flags?: LH.Flags | undefined, config?: LH.Config | undefined, page?: LH.Puppeteer.Page | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * Run Lighthouse using the legacy navigation runner.
+ * This is left in place for any clients that don't support FR navigations yet (e.g. Lightrider)
+ * @deprecated
+ * @param {string=} url The URL to test. Optional if running in auditMode.
+ * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
+ *   they will override any settings in the config.
+ * @param {LH.Config=} config Configuration for the Lighthouse run. If
+ *   not present, the default config is used.
+ * @param {Connection=} userConnection
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function legacyNavigation(url?: string | undefined, flags?: LH.Flags | undefined, config?: LH.Config | undefined, userConnection?: Connection | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {LH.UserFlow.Options} [options]
+ */
+export function startFlow(page: LH.Puppeteer.Page, options?: LH.UserFlow.Options | undefined): Promise<UserFlow>;
+/**
+ * @param {LH.Puppeteer.Page|undefined} page
+ * @param {LH.NavigationRequestor|undefined} requestor
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function navigation(page: LH.Puppeteer.Page | undefined, requestor: LH.NavigationRequestor | undefined, options?: {
+    config?: LH.Config | undefined;
+    flags?: LH.Flags | undefined;
+} | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<{endTimespan: () => Promise<LH.RunnerResult|undefined>}>}
+ */
+export function startTimespan(page: LH.Puppeteer.Page, options?: {
+    config?: LH.Config | undefined;
+    flags?: LH.Flags | undefined;
+} | undefined): Promise<{
+    endTimespan: () => Promise<LH.RunnerResult | undefined>;
+}>;
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function snapshot(page: LH.Puppeteer.Page, options?: {
+    config?: LH.Config | undefined;
+    flags?: LH.Flags | undefined;
+} | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * @template {LH.Result|LH.FlowResult} R
+ * @param {R} result
+ * @param {[R] extends [LH.Result] ? LH.OutputMode : Exclude<LH.OutputMode, 'csv'>} [format]
+ * @return {string}
+ */
+export function generateReport<R extends LH.Result | LH.FlowResult>(result: R, format?: ([R] extends [LH.Result] ? LH.OutputMode : "json" | "html") | undefined): string;
+/**
+ * @param {LH.UserFlow.FlowArtifacts} flowArtifacts
+ * @param {LH.Config} [config]
+ */
+export function auditFlowArtifacts(flowArtifacts: LH.UserFlow.FlowArtifacts, config?: LH.Config | undefined): Promise<{
+    steps: LH.FlowResult.Step[];
+    name: string;
+}>;
+export function getAuditList(): string[];
+export const traceCategories: string[];
+import * as LH from "../types/lh.js";
+import { UserFlow } from "./user-flow.js";
+//# sourceMappingURL=index.d.ts.map

package/core/index.js

@@ -16,6 +16,7 @@ import {ReportGenerator} from '../report/generator/report-generator.js';
 import {startTimespanGather} from './gather/timespan-runner.js';
 import {snapshotGather} from './gather/snapshot-runner.js';
 import {navigationGather} from './gather/navigation-runner.js';
+import * as LH from '../types/lh.js';
 
 /** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
 
@@ -157,6 +158,7 @@ export {default as Gatherer} from './gather/base-gatherer.js';
 export {NetworkRecords} from './computed/network-records.js';
 export {default as defaultConfig} from './config/default-config.js';
 export {default as desktopConfig} from './config/desktop-config.js';
+export * from '../types/lh.js';
 export {
   legacyNavigation,
   startFlow,

package/core/legacy/config/config.d.ts

@@ -0,0 +1,107 @@
+export type GathererConstructor = typeof import('../../gather/gatherers/gatherer.js').Gatherer;
+export type Gatherer = InstanceType<GathererConstructor>;
+/**
+ * @implements {LH.Config.LegacyResolvedConfig}
+ */
+export class LegacyResolvedConfig implements LH.Config.LegacyResolvedConfig {
+    /**
+     * Resolves the provided config (inherits from extended config, if set), resolves
+     * all referenced modules, and validates.
+     * @param {LH.Config=} config If not provided, uses the default config.
+     * @param {LH.Flags=} flags
+     * @return {Promise<LegacyResolvedConfig>}
+     */
+    static fromJson(config?: LH.Config | undefined, flags?: LH.Flags | undefined): Promise<LegacyResolvedConfig>;
+    /**
+     * @param {LH.Config} baseJSON The JSON of the configuration to extend
+     * @param {LH.Config} extendJSON The JSON of the extensions
+     * @return {LH.Config}
+     */
+    static extendConfigJSON(baseJSON: LH.Config, extendJSON: LH.Config): LH.Config;
+    /**
+     * @param {LH.Config['passes']} passes
+     * @return {?Array<Required<LH.Config.PassJson>>}
+     */
+    static augmentPassesWithDefaults(passes: LH.Config['passes']): Array<Required<LH.Config.PassJson>> | null;
+    /**
+     * Observed throttling methods (devtools/provided) require at least 5s of quiet for the metrics to
+     * be computed. This method adjusts the quiet thresholds to the required minimums if necessary.
+     * @param {LH.Config.Settings} settings
+     * @param {?Array<Required<LH.Config.PassJson>>} passes
+     */
+    static adjustDefaultPassForThrottling(settings: LH.Config.Settings, passes: Array<Required<LH.Config.PassJson>> | null): void;
+    /**
+     * Filter out any unrequested items from the config, based on requested categories or audits.
+     * @param {LegacyResolvedConfig} config
+     */
+    static filterConfigIfNeeded(config: LegacyResolvedConfig): void;
+    /**
+     * Filter out any unrequested categories or audits from the categories object.
+     * @param {LegacyResolvedConfig['categories']} oldCategories
+     * @param {LH.Config.Settings} settings
+     * @return {{categories: LegacyResolvedConfig['categories'], requestedAuditNames: Set<string>}}
+     */
+    static filterCategoriesAndAudits(oldCategories: LegacyResolvedConfig['categories'], settings: LH.Config.Settings): {
+        categories: LegacyResolvedConfig['categories'];
+        requestedAuditNames: Set<string>;
+    };
+    /**
+     * From some requested audits, return names of all required and optional artifacts
+     * @param {LegacyResolvedConfig['audits']} audits
+     * @return {Set<string>}
+     */
+    static getGatherersRequestedByAudits(audits: LegacyResolvedConfig['audits']): Set<string>;
+    /**
+     * Filters to only requested passes and gatherers, returning a new passes array.
+     * @param {LegacyResolvedConfig['passes']} passes
+     * @param {Set<string>} requestedGatherers
+     * @return {LegacyResolvedConfig['passes']}
+     */
+    static generatePassesNeededByGatherers(passes: LegacyResolvedConfig['passes'], requestedGatherers: Set<string>): LegacyResolvedConfig['passes'];
+    /**
+     * Take an array of audits and audit paths and require any paths (possibly
+     * relative to the optional `configDir`) using `resolveModulePath`,
+     * leaving only an array of AuditDefns.
+     * @param {LH.Config['audits']} audits
+     * @param {string=} configDir
+     * @return {Promise<LegacyResolvedConfig['audits']>}
+     */
+    static requireAudits(audits: LH.Config['audits'], configDir?: string | undefined): Promise<LegacyResolvedConfig['audits']>;
+    /**
+     * Takes an array of passes with every property now initialized except the
+     * gatherers and requires them, (relative to the optional `configDir` if
+     * provided) using `resolveModulePath`, returning an array of full Passes.
+     * @param {?Array<Required<LH.Config.PassJson>>} passes
+     * @param {string=} configDir
+     * @return {Promise<LegacyResolvedConfig['passes']>}
+     */
+    static requireGatherers(passes: Array<Required<LH.Config.PassJson>> | null, configDir?: string | undefined): Promise<LegacyResolvedConfig['passes']>;
+    /**
+     * @deprecated `Config.fromJson` should be used instead.
+     * @constructor
+     * @param {LH.Config} config
+     * @param {{settings: LH.Config.Settings, passes: ?LH.Config.Pass[], audits: ?LH.Config.AuditDefn[]}} opts
+     */
+    constructor(config: LH.Config, opts: {
+        settings: LH.Config.Settings;
+        passes: LH.Config.Pass[] | null;
+        audits: LH.Config.AuditDefn[] | null;
+    });
+    /** @type {LH.Config.Settings} */
+    settings: LH.Config.Settings;
+    /** @type {?Array<LH.Config.Pass>} */
+    passes: Array<LH.Config.Pass> | null;
+    /** @type {?Array<LH.Config.AuditDefn>} */
+    audits: Array<LH.Config.AuditDefn> | null;
+    /** @type {?Record<string, LH.Config.Category>} */
+    categories: Record<string, LH.Config.Category> | null;
+    /** @type {?Record<string, LH.Config.Group>} */
+    groups: Record<string, LH.Config.Group> | null;
+    /**
+     * Provides a cleaned-up, stringified version of this config. Gatherer and
+     * Audit `implementation` and `instance` do not survive this process.
+     * @return {string}
+     */
+    getPrintString(): string;
+}
+//# sourceMappingURL=config.d.ts.map

package/core/legacy/config/legacy-default-config.d.ts

@@ -0,0 +1,4 @@
+export default legacyDefaultConfig;
+/** @type {LH.Config} */
+declare const legacyDefaultConfig: LH.Config;
+//# sourceMappingURL=legacy-default-config.d.ts.map

package/core/legacy/gather/connections/connection.d.ts

@@ -0,0 +1,75 @@
+export type ProtocolEventRecord = {
+    'protocolevent': [LH.Protocol.RawEventMessage];
+};
+export type CrdpEventMessageEmitter = LH.Protocol.StrictEventEmitter<ProtocolEventRecord>;
+export type CommandInfo = LH.CrdpCommands[keyof LH.CrdpCommands];
+export type CommandCallback = {
+    resolve: (arg0: Promise<CommandInfo['returnType']>) => void;
+    method: keyof LH.CrdpCommands;
+};
+/**
+ * @typedef {{'protocolevent': [LH.Protocol.RawEventMessage]}} ProtocolEventRecord
+ * @typedef {LH.Protocol.StrictEventEmitter<ProtocolEventRecord>} CrdpEventMessageEmitter
+ * @typedef {LH.CrdpCommands[keyof LH.CrdpCommands]} CommandInfo
+ * @typedef {{resolve: function(Promise<CommandInfo['returnType']>): void, method: keyof LH.CrdpCommands}} CommandCallback
+ */
+export class Connection {
+    _lastCommandId: number;
+    /** @type {Map<number, CommandCallback>} */
+    _callbacks: Map<number, CommandCallback>;
+    _eventEmitter: CrdpEventMessageEmitter | null;
+    /**
+     * @return {Promise<void>}
+     */
+    connect(): Promise<void>;
+    /**
+     * @return {Promise<void>}
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @return {Promise<string>}
+     */
+    wsEndpoint(): Promise<string>;
+    /**
+     * Call protocol methods
+     * @template {keyof LH.CrdpCommands} C
+     * @param {C} method
+     * @param {string|undefined} sessionId
+     * @param {LH.CrdpCommands[C]['paramsType']} paramArgs,
+     * @return {Promise<LH.CrdpCommands[C]['returnType']>}
+     */
+    sendCommand<C extends keyof LH.CrdpCommands>(method: C, sessionId: string | undefined, ...paramArgs: LH.CrdpCommands[C]["paramsType"]): Promise<LH.CrdpCommands[C]["returnType"]>;
+    /**
+     * Bind listeners for connection events.
+     * @param {'protocolevent'} eventName
+     * @param {function(LH.Protocol.RawEventMessage): void} cb
+     */
+    on(eventName: 'protocolevent', cb: (arg0: LH.Protocol.RawEventMessage) => void): void;
+    /**
+     * Unbind listeners for connection events.
+     * @param {'protocolevent'} eventName
+     * @param {function(LH.Protocol.RawEventMessage): void} cb
+     */
+    off(eventName: 'protocolevent', cb: (arg0: LH.Protocol.RawEventMessage) => void): void;
+    /**
+     * @param {string} message
+     * @protected
+     */
+    protected sendRawMessage(message: string): void;
+    /**
+     * @param {string} message
+     * @return {void}
+     * @protected
+     */
+    protected handleRawMessage(message: string): void;
+    /**
+     * @param {LH.Protocol.RawEventMessage} eventMessage
+     */
+    emitProtocolEvent(eventMessage: LH.Protocol.RawEventMessage): void;
+    /**
+     * @protected
+     */
+    protected dispose(): void;
+}
+import * as LH from "../../../../types/lh.js";
+//# sourceMappingURL=connection.d.ts.map

package/core/legacy/gather/connections/connection.js

@@ -8,6 +8,7 @@ import {EventEmitter} from 'events';
 
 import log from 'lighthouse-logger';
 
+import * as LH from '../../../../types/lh.js';
 import {LighthouseError} from '../../../lib/lh-error.js';
 
 // TODO(bckenny): CommandCallback properties should be tied by command type after

package/core/legacy/gather/connections/cri.d.ts

@@ -0,0 +1,27 @@
+export class CriConnection extends Connection {
+    /**
+     * @param {number=} port Optional port number. Defaults to 9222;
+     * @param {string=} hostname Optional hostname. Defaults to localhost.
+     * @constructor
+     */
+    constructor(port?: number | undefined, hostname?: string | undefined);
+    port: number;
+    hostname: string;
+    _ws: WebSocket | null;
+    _pageId: string | null;
+    /**
+     * @param {LH.DevToolsJsonTarget} response
+     * @return {Promise<void>}
+     * @private
+     */
+    private _connectToSocket;
+    /**
+     * @param {string} command
+     * @return {Promise<LH.DevToolsJsonTarget | Array<LH.DevToolsJsonTarget> | {message: string}>}
+     * @private
+     */
+    private _runJsonCommand;
+}
+import { Connection } from "./connection.js";
+import WebSocket from "ws";
+//# sourceMappingURL=cri.d.ts.map

package/core/legacy/gather/connections/raw.d.ts

@@ -0,0 +1,20 @@
+export type Port = {
+    on: (eventName: 'message' | 'close', cb: ((arg: string) => void) | (() => void)) => void;
+    send: (message: string) => void;
+    close: () => void;
+};
+/**
+ * @typedef {object} Port
+ * @property {(eventName: 'message'|'close', cb: ((arg: string) => void) | (() => void)) => void} on
+ * @property {(message: string) => void} send
+ * @property {() => void} close
+ */
+export class RawConnection extends Connection {
+    /**
+     * @param {Port} port
+     */
+    constructor(port: Port);
+    _port: Port;
+}
+import { Connection } from "./connection.js";
+//# sourceMappingURL=raw.d.ts.map