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

package/core/lib/dependency-graph/simulator/network-analyzer.d.ts

@@ -0,0 +1,166 @@
+export type Summary = {
+    min: number;
+    max: number;
+    avg: number;
+    median: number;
+};
+export type 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 | undefined;
+    /**
+     * Coarse estimates include lots of extra time and noise multiply by some factor to deflate the estimates a bit.
+     */
+    coarseEstimateMultiplier?: number | undefined;
+    /**
+     * Useful for testing to isolate the different methods of estimation.
+     */
+    useDownloadEstimates?: boolean | undefined;
+    /**
+     * Useful for testing to isolate the different methods of estimation.
+     */
+    useSendStartEstimates?: boolean | undefined;
+    /**
+     * Useful for testing to isolate the different methods of estimation.
+     */
+    useHeadersEndEstimates?: boolean | undefined;
+};
+export class NetworkAnalyzer {
+    /**
+     * @return {string}
+     */
+    static get SUMMARY(): string;
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @return {Map<string, LH.Artifacts.NetworkRequest[]>}
+     */
+    static groupByOrigin(records: LH.Artifacts.NetworkRequest[]): Map<string, LH.Artifacts.NetworkRequest[]>;
+    /**
+     * @param {number[]} values
+     * @return {Summary}
+     */
+    static getSummary(values: number[]): Summary;
+    /**
+     * @param {Map<string,number[]>} values
+     * @return {Map<string, Summary>}
+     */
+    static summarize(values: Map<string, number[]>): Map<string, Summary>;
+    /** @typedef {{record: LH.Artifacts.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
+     * @return {Map<string, number[]>}
+     */
+    static _estimateValueByOrigin(records: LH.Artifacts.NetworkRequest[], iteratee: (e: {
+        record: LH.Artifacts.NetworkRequest;
+        timing: LH.Crdp.Network.ResourceTiming;
+        connectionReused?: boolean | undefined;
+    }) => number | number[] | undefined): Map<string, number[]>;
+    /**
+     * Estimates the observed RTT to each origin based on how long the TCP handshake took.
+     * This is the most accurate and preferred method of measurement when the data is available.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @return {Map<string, number[]>}
+     */
+    static _estimateRTTByOriginViaTCPTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    /**
+     * 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.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @return {Map<string, number[]>}
+     */
+    static _estimateRTTByOriginViaDownloadTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    /**
+     * 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.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @return {Map<string, number[]>}
+     */
+    static _estimateRTTByOriginViaSendStartTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    /**
+     * 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 :(
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @return {Map<string, number[]>}
+     */
+    static _estimateRTTByOriginViaHeadersEndTiming(records: LH.Artifacts.NetworkRequest[]): Map<string, number[]>;
+    /**
+     * Given the RTT to each origin, estimates the observed server response times.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Map<string, number>} rttByOrigin
+     * @return {Map<string, number[]>}
+     */
+    static _estimateResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @return {boolean}
+     */
+    static canTrustConnectionInformation(records: LH.Artifacts.NetworkRequest[]): boolean;
+    /**
+     * Returns a map of requestId -> connectionReused, estimating the information if the information
+     * available in the records themselves appears untrustworthy.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {{forceCoarseEstimates: boolean}} [options]
+     * @return {Map<string, boolean>}
+     */
+    static estimateIfConnectionWasReused(records: LH.Artifacts.NetworkRequest[], options?: {
+        forceCoarseEstimates: boolean;
+    } | undefined): 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.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {RTTEstimateOptions} [options]
+     * @return {Map<string, Summary>}
+     */
+    static estimateRTTByOrigin(records: LH.Artifacts.NetworkRequest[], options?: RTTEstimateOptions | undefined): 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.
+     *
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
+     * @return {Map<string, Summary>}
+     */
+    static estimateServerResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], options?: (RTTEstimateOptions & {
+        rttByOrigin?: Map<string, number> | undefined;
+    }) | undefined): Map<string, Summary>;
+    /**
+     * Computes the average throughput for the given records in bits/second.
+     * Excludes data URI, failed or otherwise incomplete, and cached requests.
+     * Returns Infinity if there were no analyzable network records.
+     *
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {number}
+     */
+    static estimateThroughput(networkRecords: Array<LH.Artifacts.NetworkRequest>): number;
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @param {string} resourceUrl
+     * @return {LH.Artifacts.NetworkRequest|undefined}
+     */
+    static findResourceForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    /**
+     * Resolves redirect chain given a main document.
+     * See: {@link NetworkAnalyzer.findResourceForUrl}) for how to retrieve main document.
+     *
+     * @param {LH.Artifacts.NetworkRequest} request
+     * @return {LH.Artifacts.NetworkRequest}
+     */
+    static resolveRedirects(request: LH.Artifacts.NetworkRequest): LH.Artifacts.NetworkRequest;
+}
+//# sourceMappingURL=network-analyzer.d.ts.map

package/core/lib/dependency-graph/simulator/simulator-timing-map.d.ts

@@ -0,0 +1,153 @@
+export type Node = import('../base-node.js').Node;
+export type NetworkNode = import('../network-node.js').NetworkNode;
+export type CpuNode = import('../cpu-node.js').CPUNode;
+export type NodeTimingComplete = {
+    startTime: number;
+    endTime: number;
+    /**
+     * Helpful for debugging.
+     */
+    queuedTime: number;
+    estimatedTimeElapsed: number;
+    timeElapsed: number;
+    timeElapsedOvershoot: number;
+    bytesDownloaded: number;
+};
+export type NodeTimingQueued = Pick<NodeTimingComplete, 'queuedTime'>;
+export type CpuNodeTimingStarted = NodeTimingQueued & Pick<NodeTimingComplete, 'startTime' | 'timeElapsed'>;
+export type NetworkNodeTimingStarted = CpuNodeTimingStarted & Pick<NodeTimingComplete, 'timeElapsedOvershoot' | 'bytesDownloaded'>;
+export type CpuNodeTimingInProgress = CpuNodeTimingStarted & Pick<NodeTimingComplete, 'estimatedTimeElapsed'>;
+export type NetworkNodeTimingInProgress = NetworkNodeTimingStarted & Pick<NodeTimingComplete, 'estimatedTimeElapsed'>;
+export type CpuNodeTimingComplete = CpuNodeTimingInProgress & Pick<NodeTimingComplete, 'endTime'>;
+export type NetworkNodeTimingComplete = NetworkNodeTimingInProgress & Pick<NodeTimingComplete, 'endTime'> & {
+    connectionTiming: ConnectionTiming;
+};
+export type NodeTimingData = NodeTimingQueued | CpuNodeTimingStarted | NetworkNodeTimingStarted | CpuNodeTimingInProgress | NetworkNodeTimingInProgress | CpuNodeTimingComplete | NetworkNodeTimingComplete;
+/**
+ * A breakdown of network connection timings.
+ */
+export type ConnectionTiming = {
+    dnsResolutionTime?: number | undefined;
+    connectionTime?: number | undefined;
+    sslTime?: number | undefined;
+    timeToFirstByte: number;
+};
+/**
+ * @fileoverview
+ *
+ * This class encapsulates the type-related validation logic for moving timing information for nodes
+ * through the different simulation phases. Methods here ensure that the invariants of simulation hold
+ * as nodes are queued, partially simulated, and completed.
+ */
+/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../network-node.js').NetworkNode} NetworkNode */
+/** @typedef {import('../cpu-node.js').CPUNode} CpuNode */
+/**
+ * @typedef NodeTimingComplete
+ * @property {number} startTime
+ * @property {number} endTime
+ * @property {number} queuedTime Helpful for debugging.
+ * @property {number} estimatedTimeElapsed
+ * @property {number} timeElapsed
+ * @property {number} timeElapsedOvershoot
+ * @property {number} bytesDownloaded
+ */
+/** @typedef {Pick<NodeTimingComplete, 'queuedTime'>} NodeTimingQueued */
+/** @typedef {NodeTimingQueued & Pick<NodeTimingComplete, 'startTime'|'timeElapsed'>} CpuNodeTimingStarted */
+/** @typedef {CpuNodeTimingStarted & Pick<NodeTimingComplete, 'timeElapsedOvershoot'|'bytesDownloaded'>} NetworkNodeTimingStarted */
+/** @typedef {CpuNodeTimingStarted & Pick<NodeTimingComplete, 'estimatedTimeElapsed'>} CpuNodeTimingInProgress */
+/** @typedef {NetworkNodeTimingStarted & Pick<NodeTimingComplete, 'estimatedTimeElapsed'>} NetworkNodeTimingInProgress */
+/** @typedef {CpuNodeTimingInProgress & Pick<NodeTimingComplete, 'endTime'>} CpuNodeTimingComplete */
+/** @typedef {NetworkNodeTimingInProgress & Pick<NodeTimingComplete, 'endTime'> & {connectionTiming: ConnectionTiming}} NetworkNodeTimingComplete */
+/** @typedef {NodeTimingQueued | CpuNodeTimingStarted | NetworkNodeTimingStarted | CpuNodeTimingInProgress | NetworkNodeTimingInProgress | CpuNodeTimingComplete | NetworkNodeTimingComplete} NodeTimingData */
+/**
+ * @typedef ConnectionTiming A breakdown of network connection timings.
+ * @property {number} [dnsResolutionTime]
+ * @property {number} [connectionTime]
+ * @property {number} [sslTime]
+ * @property {number} timeToFirstByte
+ */
+export class SimulatorTimingMap {
+    /** @type {Map<Node, NodeTimingData>} */
+    _nodeTimings: Map<Node, NodeTimingData>;
+    /** @return {Array<Node>} */
+    getNodes(): Array<Node>;
+    /**
+     * @param {Node} node
+     * @param {{queuedTime: number}} values
+     */
+    setReadyToStart(node: Node, values: {
+        queuedTime: number;
+    }): void;
+    /**
+     * @param {Node} node
+     * @param {{startTime: number}} values
+     */
+    setInProgress(node: Node, values: {
+        startTime: number;
+    }): void;
+    /**
+     * @param {Node} node
+     * @param {{endTime: number, connectionTiming?: ConnectionTiming}} values
+     */
+    setCompleted(node: Node, values: {
+        endTime: number;
+        connectionTiming?: ConnectionTiming;
+    }): void;
+    /**
+     * @param {CpuNode} node
+     * @param {{timeElapsed: number}} values
+     */
+    setCpu(node: CpuNode, values: {
+        timeElapsed: number;
+    }): void;
+    /**
+     * @param {CpuNode} node
+     * @param {{estimatedTimeElapsed: number}} values
+     */
+    setCpuEstimated(node: CpuNode, values: {
+        estimatedTimeElapsed: number;
+    }): void;
+    /**
+     * @param {NetworkNode} node
+     * @param {{timeElapsed: number, timeElapsedOvershoot: number, bytesDownloaded: number}} values
+     */
+    setNetwork(node: NetworkNode, values: {
+        timeElapsed: number;
+        timeElapsedOvershoot: number;
+        bytesDownloaded: number;
+    }): void;
+    /**
+     * @param {NetworkNode} node
+     * @param {{estimatedTimeElapsed: number}} values
+     */
+    setNetworkEstimated(node: NetworkNode, values: {
+        estimatedTimeElapsed: number;
+    }): void;
+    /**
+     * @param {Node} node
+     * @return {NodeTimingQueued}
+     */
+    getQueued(node: Node): NodeTimingQueued;
+    /**
+     * @param {CpuNode} node
+     * @return {CpuNodeTimingStarted}
+     */
+    getCpuStarted(node: CpuNode): CpuNodeTimingStarted;
+    /**
+     * @param {NetworkNode} node
+     * @return {NetworkNodeTimingStarted}
+     */
+    getNetworkStarted(node: NetworkNode): NetworkNodeTimingStarted;
+    /**
+     * @param {Node} node
+     * @return {CpuNodeTimingInProgress | NetworkNodeTimingInProgress}
+     */
+    getInProgress(node: Node): CpuNodeTimingInProgress | NetworkNodeTimingInProgress;
+    /**
+     * @param {Node} node
+     * @return {CpuNodeTimingComplete | NetworkNodeTimingComplete}
+     */
+    getCompleted(node: Node): CpuNodeTimingComplete | NetworkNodeTimingComplete;
+}
+//# sourceMappingURL=simulator-timing-map.d.ts.map

package/core/lib/dependency-graph/simulator/simulator-timing-map.js

@@ -16,8 +16,8 @@ import {BaseNode} from '../base-node.js';
 
 
 /** @typedef {import('../base-node.js').Node} Node */
-/** @typedef {import('../network-node').NetworkNode} NetworkNode */
-/** @typedef {import('../cpu-node').CPUNode} CpuNode */
+/** @typedef {import('../network-node.js').NetworkNode} NetworkNode */
+/** @typedef {import('../cpu-node.js').CPUNode} CpuNode */
 
 /**
  * @typedef NodeTimingComplete

package/core/lib/dependency-graph/simulator/simulator.d.ts

@@ -0,0 +1,154 @@
+export type Node = import('../base-node.js').Node;
+export type NetworkNode = import('../network-node.js').NetworkNode;
+export type CpuNode = import('../cpu-node.js').CPUNode;
+export type CompleteNodeTiming = import('./simulator-timing-map.js').CpuNodeTimingComplete | import('./simulator-timing-map.js').NetworkNodeTimingComplete;
+export type ConnectionTiming = import('./simulator-timing-map.js').ConnectionTiming;
+export class Simulator {
+    /** @return {Map<string, Map<Node, CompleteNodeTiming>>} */
+    static get ALL_NODE_TIMINGS(): Map<string, Map<import("../base-node.js").Node, CompleteNodeTiming>>;
+    /**
+     * We attempt to start nodes by their observed start time using the record priority as a tie breaker.
+     * When simulating, just because a low priority image started 5ms before a high priority image doesn't mean
+     * it would have happened like that when the network was slower.
+     * @param {Node} node
+     */
+    static _computeNodeStartPosition(node: Node): number;
+    /**
+     * @param {LH.Gatherer.Simulation.Options} [options]
+     */
+    constructor(options?: LH.Gatherer.Simulation.Options | undefined);
+    /** @type {Required<LH.Gatherer.Simulation.Options>} */
+    _options: Required<LH.Gatherer.Simulation.Options>;
+    _rtt: number;
+    _throughput: number;
+    _maximumConcurrentRequests: number;
+    _cpuSlowdownMultiplier: number;
+    _layoutTaskMultiplier: number;
+    /** @type {Array<Node>} */
+    _cachedNodeListByStartPosition: Array<Node>;
+    _flexibleOrdering: boolean;
+    _nodeTimings: SimulatorTimingMap;
+    /** @type {Map<string, number>} */
+    _numberInProgressByType: Map<string, number>;
+    /** @type {Record<number, Set<Node>>} */
+    _nodes: Record<number, Set<Node>>;
+    _dns: DNSCache;
+    /** @type {ConnectionPool} */
+    _connectionPool: ConnectionPool;
+    /** @return {number} */
+    get rtt(): number;
+    /**
+     * @param {Node} graph
+     */
+    _initializeConnectionPool(graph: Node): void;
+    /**
+     * Initializes the various state data structures such _nodeTimings and the _node Sets by state.
+     */
+    _initializeAuxiliaryData(): void;
+    /**
+     * @param {string} type
+     * @return {number}
+     */
+    _numberInProgress(type: string): number;
+    /**
+     * @param {Node} node
+     * @param {number} queuedTime
+     */
+    _markNodeAsReadyToStart(node: Node, queuedTime: number): void;
+    /**
+     * @param {Node} node
+     * @param {number} startTime
+     */
+    _markNodeAsInProgress(node: Node, startTime: number): void;
+    /**
+     * @param {Node} node
+     * @param {number} endTime
+     * @param {ConnectionTiming} [connectionTiming] Optional network connection information.
+     */
+    _markNodeAsComplete(node: Node, endTime: number, connectionTiming?: import("./simulator-timing-map.js").ConnectionTiming | undefined): void;
+    /**
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {?TcpConnection}
+     */
+    _acquireConnection(record: LH.Artifacts.NetworkRequest): TcpConnection | null;
+    /**
+     * @return {Node[]}
+     */
+    _getNodesSortedByStartPosition(): Node[];
+    /**
+     * @param {Node} node
+     * @param {number} totalElapsedTime
+     */
+    _startNodeIfPossible(node: Node, totalElapsedTime: number): void;
+    /**
+     * Updates each connection in use with the available throughput based on the number of network requests
+     * currently in flight.
+     */
+    _updateNetworkCapacity(): void;
+    /**
+     * Estimates the number of milliseconds remaining given current condidtions before the node is complete.
+     * @param {Node} node
+     * @return {number}
+     */
+    _estimateTimeRemaining(node: Node): number;
+    /**
+     * @param {CpuNode} cpuNode
+     * @return {number}
+     */
+    _estimateCPUTimeRemaining(cpuNode: CpuNode): number;
+    /**
+     * @param {NetworkNode} networkNode
+     * @return {number}
+     */
+    _estimateNetworkTimeRemaining(networkNode: NetworkNode): number;
+    /**
+     * Computes and returns the minimum estimated completion time of the nodes currently in progress.
+     * @return {number}
+     */
+    _findNextNodeCompletionTime(): number;
+    /**
+     * Given a time period, computes the progress toward completion that the node made durin that time.
+     * @param {Node} node
+     * @param {number} timePeriodLength
+     * @param {number} totalElapsedTime
+     */
+    _updateProgressMadeInTimePeriod(node: Node, timePeriodLength: number, totalElapsedTime: number): number | void;
+    /**
+     * @return {{nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
+     */
+    _computeFinalNodeTimings(): {
+        nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>;
+        completeNodeTimings: Map<Node, CompleteNodeTiming>;
+    };
+    /**
+     * @return {Required<LH.Gatherer.Simulation.Options>}
+     */
+    getOptions(): Required<LH.Gatherer.Simulation.Options>;
+    /**
+     * Estimates the time taken to process all of the graph's nodes, returns the overall time along with
+     * each node annotated by start/end times.
+     *
+     * If flexibleOrdering is set, simulator/connection pool are allowed to deviate from what was
+     * observed in the trace/devtoolsLog and start requests as soon as they are queued (i.e. do not
+     * wait around for a warm connection to be available if the original record was fetched on a warm
+     * connection).
+     *
+     * @param {Node} graph
+     * @param {{flexibleOrdering?: boolean, label?: string}=} options
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    simulate(graph: Node, options?: {
+        flexibleOrdering?: boolean;
+        label?: string;
+    } | undefined): LH.Gatherer.Simulation.Result;
+    /**
+     * @param {number} wastedBytes
+     */
+    computeWastedMsFromWastedBytes(wastedBytes: number): number;
+}
+import * as LH from "../../../../types/lh.js";
+import { SimulatorTimingMap } from "./simulator-timing-map.js";
+import { DNSCache } from "./dns-cache.js";
+import { ConnectionPool } from "./connection-pool.js";
+import { TcpConnection } from "./tcp-connection.js";
+//# sourceMappingURL=simulator.d.ts.map

package/core/lib/dependency-graph/simulator/simulator.js

@@ -4,6 +4,7 @@
  * 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.
  */
 
+import * as LH from '../../../../types/lh.js';
 import {BaseNode} from '../base-node.js';
 import {TcpConnection} from './tcp-connection.js';
 import {ConnectionPool} from './connection-pool.js';
@@ -14,8 +15,8 @@ import * as constants from '../../../config/constants.js';
 const mobileSlow4G = constants.throttling.mobileSlow4G;
 
 /** @typedef {import('../base-node.js').Node} Node */
-/** @typedef {import('../network-node').NetworkNode} NetworkNode */
-/** @typedef {import('../cpu-node').CPUNode} CpuNode */
+/** @typedef {import('../network-node.js').NetworkNode} NetworkNode */
+/** @typedef {import('../cpu-node.js').CPUNode} CpuNode */
 /** @typedef {import('./simulator-timing-map.js').CpuNodeTimingComplete | import('./simulator-timing-map.js').NetworkNodeTimingComplete} CompleteNodeTiming */
 /** @typedef {import('./simulator-timing-map.js').ConnectionTiming} ConnectionTiming */
 

package/core/lib/dependency-graph/simulator/tcp-connection.d.ts

@@ -0,0 +1,89 @@
+export type ConnectionTiming = import('./simulator-timing-map.js').ConnectionTiming;
+export type DownloadOptions = {
+    dnsResolutionTime?: number | undefined;
+    timeAlreadyElapsed?: number | undefined;
+    maximumTimeToElapse?: number | undefined;
+};
+export type DownloadResults = {
+    roundTrips: number;
+    timeElapsed: number;
+    bytesDownloaded: number;
+    extraBytesDownloaded: number;
+    congestionWindow: number;
+    connectionTiming: ConnectionTiming;
+};
+export class TcpConnection {
+    /**
+     * @param {number} rtt
+     * @param {number} availableThroughput
+     * @return {number}
+     */
+    static maximumSaturatedConnections(rtt: number, availableThroughput: number): number;
+    /**
+     * @param {number} rtt
+     * @param {number} throughput
+     * @param {number=} serverLatency
+     * @param {boolean=} ssl
+     * @param {boolean=} h2
+     */
+    constructor(rtt: number, throughput: number, serverLatency?: number | undefined, ssl?: boolean | undefined, h2?: boolean | undefined);
+    _warmed: boolean;
+    _ssl: boolean;
+    _h2: boolean;
+    _rtt: number;
+    _throughput: number;
+    _serverLatency: number;
+    _congestionWindow: number;
+    _h2OverflowBytesDownloaded: number;
+    /**
+     * @return {number}
+     */
+    _computeMaximumCongestionWindowInSegments(): number;
+    /**
+     * @param {number} throughput
+     */
+    setThroughput(throughput: number): void;
+    /**
+     * @param {number} congestion
+     */
+    setCongestionWindow(congestion: number): void;
+    /**
+     * @param {boolean} warmed
+     */
+    setWarmed(warmed: boolean): void;
+    /**
+     * @return {boolean}
+     */
+    isWarm(): boolean;
+    /**
+     * @return {boolean}
+     */
+    isH2(): boolean;
+    /**
+     * @return {number}
+     */
+    get congestionWindow(): number;
+    /**
+     * Sets the number of excess bytes that are available to this connection on future downloads, only
+     * applies to H2 connections.
+     * @param {number} bytes
+     */
+    setH2OverflowBytesDownloaded(bytes: number): void;
+    /**
+     * @return {TcpConnection}
+     */
+    clone(): TcpConnection;
+    /**
+     * Simulates a network download of a particular number of bytes over an optional maximum amount of time
+     * and returns information about the ending state.
+     *
+     * See https://hpbn.co/building-blocks-of-tcp/#three-way-handshake and
+     *  https://hpbn.co/transport-layer-security-tls/#tls-handshake for details.
+     *
+     * @param {number} bytesToDownload
+     * @param {DownloadOptions} [options]
+     * @return {DownloadResults}
+     */
+    simulateDownloadUntil(bytesToDownload: number, options?: DownloadOptions | undefined): DownloadResults;
+}
+//# sourceMappingURL=tcp-connection.d.ts.map

package/core/lib/deprecations-strings.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @param {LH.Crdp.Audits.DeprecationIssueDetails} issueDetails
+ */
+declare function getDescription(issueDetails: LH.Crdp.Audits.DeprecationIssueDetails): {
+    file: string;
+    substitutions: Map<string, import("../index.js").IcuMessage>;
+    links: {
+        link: string;
+        linkTitle: import("../index.js").IcuMessage;
+    }[];
+    message: import("../index.js").IcuMessage;
+};
+export namespace UIStrings {
+    const feature: string;
+    const milestone: string;
+    const title: string;
+    const authorizationCoveredByWildcard: string;
+    const canRequestURLHTTPContainingNewline: string;
+    const chromeLoadTimesConnectionInfo: string;
+    const chromeLoadTimesFirstPaintAfterLoadTime: string;
+    const chromeLoadTimesWasAlternateProtocolAvailable: string;
+    const cookieWithTruncatingChar: string;
+    const crossOriginAccessBasedOnDocumentDomain: string;
+    const crossOriginWindowApi: string;
+    const cssSelectorInternalMediaControlsOverlayCastButton: string;
+    const deprecationExample: string;
+    const documentDomainSettingWithoutOriginAgentClusterHeader: string;
+    const eventPath: string;
+    const expectCTHeader: string;
+    const geolocationInsecureOrigin: string;
+    const geolocationInsecureOriginDeprecatedNotRemoved: string;
+    const getUserMediaInsecureOrigin: string;
+    const hostCandidateAttributeGetter: string;
+    const identityInCanMakePaymentEvent: string;
+    const insecurePrivateNetworkSubresourceRequest: string;
+    const localCSSFileExtensionRejected: string;
+    const mediaSourceAbortRemove: string;
+    const mediaSourceDurationTruncatingBuffered: string;
+    const noSysexWebMIDIWithoutPermission: string;
+    const notificationInsecureOrigin: string;
+    const notificationPermissionRequestedIframe: string;
+    const obsoleteWebRtcCipherSuite: string;
+    const openWebDatabaseInsecureContext: string;
+    const paymentInstruments: string;
+    const paymentRequestCSPViolation: string;
+    const persistentQuotaType: string;
+    const pictureSourceSrc: string;
+    const vendorSpecificApi: string;
+    const prefixedStorageInfo: string;
+    const deprecatedWithReplacement: string;
+    const requestedSubresourceWithEmbeddedCredentials: string;
+    const rtcConstraintEnableDtlsSrtpFalse: string;
+    const rtcConstraintEnableDtlsSrtpTrue: string;
+    const rtcPeerConnectionComplexPlanBSdpUsingDefaultSdpSemantics: string;
+    const rtcPeerConnectionSdpSemanticsPlanB: string;
+    const rtcpMuxPolicyNegotiate: string;
+    const sharedArrayBufferConstructedWithoutIsolation: string;
+    const textToSpeech_DisallowedByAutoplay: string;
+    const v8SharedArrayBufferConstructedInExtensionWithoutIsolation: string;
+    const xhrJSONEncodingDetection: string;
+    const xmlHttpRequestSynchronousInNonWorkerOutsideBeforeUnload: string;
+    const xrSupportsSession: string;
+    const overflowVisibleOnReplacedElement: string;
+}
+export { getDescription as getIssueDetailDescription };
+//# sourceMappingURL=deprecations-strings.d.ts.map