lighthouse 11.6.0 → 11.7.0

package/core/lib/{dependency-graph → lantern}/simulator/network-analyzer.d.ts

@@ -32,10 +32,10 @@ export class NetworkAnalyzer {
      */
     static get SUMMARY(): string;
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
-     * @return {Map<string, LH.Artifacts.NetworkRequest[]>}
+     * @param {Lantern.NetworkRequest[]} records
+     * @return {Map<string, Lantern.NetworkRequest[]>}
      */
-    static groupByOrigin(records: LH.Artifacts.NetworkRequest[]): Map<string, LH.Artifacts.NetworkRequest[]>;
+    static groupByOrigin(records: Lantern.NetworkRequest[]): Map<string, Lantern.NetworkRequest[]>;
     /**
      * @param {number[]} values
      * @return {Summary}
@@ -46,14 +46,14 @@ export class NetworkAnalyzer {
      * @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 */
+    /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.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;
+    static _estimateValueByOrigin(records: Lantern.NetworkRequest[], iteratee: (e: {
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }) => number | number[] | undefined): Map<string, number[]>;
@@ -69,7 +69,7 @@ export class NetworkAnalyzer {
      * @return {number[]|number|undefined}
      */
     static _estimateRTTViaConnectionTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number[] | number | undefined;
@@ -82,7 +82,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaDownloadTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -96,7 +96,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaSendStartTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -110,32 +110,32 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaHeadersEndTiming(info: {
-        record: LH.Artifacts.NetworkRequest;
+        record: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
     /**
      * Given the RTT to each origin, estimates the observed server response times.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {Map<string, number>} rttByOrigin
      * @return {Map<string, number[]>}
      */
-    static _estimateResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
+    static _estimateResponseTimeByOrigin(records: Lantern.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
     /**
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @return {boolean}
      */
-    static canTrustConnectionInformation(records: LH.Artifacts.NetworkRequest[]): boolean;
+    static canTrustConnectionInformation(records: Lantern.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 {Lantern.NetworkRequest[]} records
      * @param {{forceCoarseEstimates: boolean}} [options]
      * @return {Map<string, boolean>}
      */
-    static estimateIfConnectionWasReused(records: LH.Artifacts.NetworkRequest[], options?: {
+    static estimateIfConnectionWasReused(records: Lantern.NetworkRequest[], options?: {
         forceCoarseEstimates: boolean;
     } | undefined): Map<string, boolean>;
     /**
@@ -143,20 +143,20 @@ export class NetworkAnalyzer {
      * Attempts to use the most accurate information first and falls back to coarser estimates when it
      * is unavailable.
      *
-     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} records
      * @param {RTTEstimateOptions} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateRTTByOrigin(records: LH.Artifacts.NetworkRequest[], options?: RTTEstimateOptions | undefined): Map<string, Summary>;
+    static estimateRTTByOrigin(records: Lantern.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 {Lantern.NetworkRequest[]} records
      * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
      * @return {Map<string, Summary>}
      */
-    static estimateServerResponseTimeByOrigin(records: LH.Artifacts.NetworkRequest[], options?: (RTTEstimateOptions & {
+    static estimateServerResponseTimeByOrigin(records: Lantern.NetworkRequest[], options?: (RTTEstimateOptions & {
         rttByOrigin?: Map<string, number> | undefined;
     }) | undefined): Map<string, Summary>;
     /**
@@ -164,29 +164,33 @@ export class NetworkAnalyzer {
      * 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
+     * @param {Array<Lantern.NetworkRequest>} networkRecords
      * @return {number}
      */
-    static estimateThroughput(networkRecords: Array<LH.Artifacts.NetworkRequest>): number;
+    static estimateThroughput(networkRecords: Array<Lantern.NetworkRequest>): number;
     /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @template {Lantern.NetworkRequest} T
+     * @param {Array<T>} records
      * @param {string} resourceUrl
-     * @return {LH.Artifacts.NetworkRequest|undefined}
+     * @return {T|undefined}
      */
-    static findResourceForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    static findResourceForUrl<T extends Lantern.NetworkRequest<any>>(records: T[], resourceUrl: string): T | undefined;
     /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @template {Lantern.NetworkRequest} T
+     * @param {Array<T>} records
      * @param {string} resourceUrl
-     * @return {LH.Artifacts.NetworkRequest|undefined}
+     * @return {T|undefined}
      */
-    static findLastDocumentForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    static findLastDocumentForUrl<T_1 extends Lantern.NetworkRequest<any>>(records: T_1[], resourceUrl: string): T_1 | undefined;
     /**
      * Resolves redirect chain given a main document.
      * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
      *
-     * @param {LH.Artifacts.NetworkRequest} request
-     * @return {LH.Artifacts.NetworkRequest}
+     * @template {Lantern.NetworkRequest} T
+     * @param {T} request
+     * @return {T}
      */
-    static resolveRedirects(request: LH.Artifacts.NetworkRequest): LH.Artifacts.NetworkRequest;
+    static resolveRedirects<T_2 extends Lantern.NetworkRequest<any>>(request: T_2): T_2;
 }
+import * as Lantern from '../types/lantern.js';
 //# sourceMappingURL=network-analyzer.d.ts.map

package/core/lib/{dependency-graph → lantern}/simulator/network-analyzer.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as Lantern from '../types/lantern.js';
 import UrlUtils from '../../url-utils.js';
 
 const INITIAL_CWD = 14 * 1024;
@@ -31,8 +32,8 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   * @return {Map<string, LH.Artifacts.NetworkRequest[]>}
+   * @param {Lantern.NetworkRequest[]} records
+   * @return {Map<string, Lantern.NetworkRequest[]>}
    */
   static groupByOrigin(records) {
     const grouped = new Map();
@@ -87,10 +88,10 @@ class NetworkAnalyzer {
     return summaryByKey;
   }
 
-  /** @typedef {{record: LH.Artifacts.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+  /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
 
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} records
    * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
    * @return {Map<string, number[]>}
    */
@@ -249,7 +250,7 @@ class NetworkAnalyzer {
   /**
    * Given the RTT to each origin, estimates the observed server response times.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} records
    * @param {Map<string, number>} rttByOrigin
    * @return {Map<string, number[]>}
    */
@@ -270,7 +271,7 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} records
    * @return {boolean}
    */
   static canTrustConnectionInformation(records) {
@@ -290,7 +291,7 @@ class NetworkAnalyzer {
    * 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 {Lantern.NetworkRequest[]} records
    * @param {{forceCoarseEstimates: boolean}} [options]
    * @return {Map<string, boolean>}
    */
@@ -334,7 +335,7 @@ class NetworkAnalyzer {
    * Attempts to use the most accurate information first and falls back to coarser estimates when it
    * is unavailable.
    *
-   * @param {LH.Artifacts.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} records
    * @param {RTTEstimateOptions} [options]
    * @return {Map<string, Summary>}
    */
@@ -415,7 +416,7 @@ class NetworkAnalyzer {
    * 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 {Lantern.NetworkRequest[]} records
    * @param {RTTEstimateOptions & {rttByOrigin?: Map<string, number>}} [options]
    * @return {Map<string, Summary>}
    */
@@ -441,7 +442,7 @@ class NetworkAnalyzer {
    * 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
+   * @param {Array<Lantern.NetworkRequest>} networkRecords
    * @return {number}
    */
   static estimateThroughput(networkRecords) {
@@ -494,9 +495,10 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} records
+   * @template {Lantern.NetworkRequest} T
+   * @param {Array<T>} records
    * @param {string} resourceUrl
-   * @return {LH.Artifacts.NetworkRequest|undefined}
+   * @return {T|undefined}
    */
   static findResourceForUrl(records, resourceUrl) {
     // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
@@ -507,9 +509,10 @@ class NetworkAnalyzer {
   }
 
   /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} records
+   * @template {Lantern.NetworkRequest} T
+   * @param {Array<T>} records
    * @param {string} resourceUrl
-   * @return {LH.Artifacts.NetworkRequest|undefined}
+   * @return {T|undefined}
    */
   static findLastDocumentForUrl(records, resourceUrl) {
     // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
@@ -526,11 +529,12 @@ class NetworkAnalyzer {
    * Resolves redirect chain given a main document.
    * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
    *
-   * @param {LH.Artifacts.NetworkRequest} request
-   * @return {LH.Artifacts.NetworkRequest}
+   * @template {Lantern.NetworkRequest} T
+   * @param {T} request
+   * @return {T}
    */
   static resolveRedirects(request) {
-    while (request.redirectDestination) request = request.redirectDestination;
+    while (request.redirectDestination) request = /** @type {T} */(request.redirectDestination);
     return request;
   }
 }

package/core/lib/{dependency-graph → lantern}/simulator/simulator.d.ts

@@ -3,9 +3,12 @@ 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 {
+/**
+ * @template [T=any]
+ */
+export class Simulator<T = any> {
     /** @return {Map<string, Map<Node, CompleteNodeTiming>>} */
-    static get ALL_NODE_TIMINGS(): Map<string, Map<import("../base-node.js").Node, CompleteNodeTiming>>;
+    static get ALL_NODE_TIMINGS(): Map<string, Map<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
@@ -14,11 +17,11 @@ export class Simulator {
      */
     static _computeNodeStartPosition(node: Node): number;
     /**
-     * @param {LH.Gatherer.Simulation.Options} [options]
+     * @param {Lantern.Simulation.Options} [options]
      */
-    constructor(options?: LH.Gatherer.Simulation.Options | undefined);
-    /** @type {Required<LH.Gatherer.Simulation.Options>} */
-    _options: Required<LH.Gatherer.Simulation.Options>;
+    constructor(options?: Lantern.Simulation.Options | undefined);
+    /** @type {Required<Lantern.Simulation.Options>} */
+    _options: Required<Lantern.Simulation.Options>;
     _rtt: number;
     _throughput: number;
     _maximumConcurrentRequests: number;
@@ -67,10 +70,10 @@ export class Simulator {
      */
     _markNodeAsComplete(node: Node, endTime: number, connectionTiming?: import("./simulator-timing-map.js").ConnectionTiming | undefined): void;
     /**
-     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} record
      * @return {?TcpConnection}
      */
-    _acquireConnection(record: LH.Artifacts.NetworkRequest): TcpConnection | null;
+    _acquireConnection(record: Lantern.NetworkRequest): TcpConnection | null;
     /**
      * @return {Node[]}
      */
@@ -114,16 +117,16 @@ export class Simulator {
      */
     _updateProgressMadeInTimePeriod(node: Node, timePeriodLength: number, totalElapsedTime: number): number | void;
     /**
-     * @return {{nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
+     * @return {{nodeTimings: Map<Node, Lantern.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
      */
     _computeFinalNodeTimings(): {
-        nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>;
+        nodeTimings: Map<Node, Lantern.Simulation.NodeTiming>;
         completeNodeTimings: Map<Node, CompleteNodeTiming>;
     };
     /**
-     * @return {Required<LH.Gatherer.Simulation.Options>}
+     * @return {Required<Lantern.Simulation.Options>}
      */
-    getOptions(): Required<LH.Gatherer.Simulation.Options>;
+    getOptions(): Required<Lantern.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.
@@ -135,18 +138,18 @@ export class Simulator {
      *
      * @param {Node} graph
      * @param {{flexibleOrdering?: boolean, label?: string}=} options
-     * @return {LH.Gatherer.Simulation.Result}
+     * @return {Lantern.Simulation.Result<T>}
      */
     simulate(graph: Node, options?: {
         flexibleOrdering?: boolean;
         label?: string;
-    } | undefined): LH.Gatherer.Simulation.Result;
+    } | undefined): Lantern.Simulation.Result<T>;
     /**
      * @param {number} wastedBytes
      */
     computeWastedMsFromWastedBytes(wastedBytes: number): number;
 }
-import * as LH from '../../../../types/lh.js';
+import * as Lantern from '../types/lantern.js';
 import { SimulatorTimingMap } from './simulator-timing-map.js';
 import { DNSCache } from './dns-cache.js';
 import { ConnectionPool } from './connection-pool.js';

package/core/lib/{dependency-graph → lantern}/simulator/simulator.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as LH from '../../../../types/lh.js';
+import * as Lantern from '../types/lantern.js';
 import {BaseNode} from '../base-node.js';
 import {TcpConnection} from './tcp-connection.js';
 import {ConnectionPool} from './connection-pool.js';
@@ -46,12 +46,15 @@ const PriorityStartTimePenalty = {
 /** @type {Map<string, Map<Node, CompleteNodeTiming>>} */
 const ALL_SIMULATION_NODE_TIMINGS = new Map();
 
+/**
+ * @template [T=any]
+ */
 class Simulator {
   /**
-   * @param {LH.Gatherer.Simulation.Options} [options]
+   * @param {Lantern.Simulation.Options} [options]
    */
   constructor(options) {
-    /** @type {Required<LH.Gatherer.Simulation.Options>} */
+    /** @type {Required<Lantern.Simulation.Options>} */
     this._options = Object.assign(
       {
         rtt: mobileSlow4G.rttMs,
@@ -101,11 +104,11 @@ class Simulator {
    * @param {Node} graph
    */
   _initializeConnectionPool(graph) {
-    /** @type {LH.Artifacts.NetworkRequest[]} */
+    /** @type {Lantern.NetworkRequest[]} */
     const records = [];
     graph.getRootNode().traverse(node => {
       if (node.type === BaseNode.TYPES.NETWORK) {
-        records.push(node.record);
+        records.push(node.request);
       }
     });
 
@@ -190,7 +193,7 @@ class Simulator {
   }
 
   /**
-   * @param {LH.Artifacts.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} record
    * @return {?TcpConnection}
    */
   _acquireConnection(record) {
@@ -228,7 +231,7 @@ class Simulator {
       // Start a network request if we're not at max requests and a connection is available
       const numberOfActiveRequests = this._numberInProgress(node.type);
       if (numberOfActiveRequests >= this._maximumConcurrentRequests) return;
-      const connection = this._acquireConnection(node.record);
+      const connection = this._acquireConnection(node.request);
       if (!connection) return;
     }
 
@@ -286,7 +289,7 @@ class Simulator {
    * @return {number}
    */
   _estimateNetworkTimeRemaining(networkNode) {
-    const record = networkNode.record;
+    const record = networkNode.request;
     const timingData = this._nodeTimings.getNetworkStarted(networkNode);
 
     let timeElapsed = 0;
@@ -354,7 +357,7 @@ class Simulator {
     if (node.type !== BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
     if (!('bytesDownloaded' in timingData)) throw new Error('Invalid timing data');
 
-    const record = node.record;
+    const record = node.request;
     const connection = this._connectionPool.acquireActiveConnectionFromRecord(record);
     const dnsResolutionTime = this._dns.getTimeUntilResolution(record, {
       requestedAt: timingData.startTime,
@@ -384,7 +387,7 @@ class Simulator {
   }
 
   /**
-   * @return {{nodeTimings: Map<Node, LH.Gatherer.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
+   * @return {{nodeTimings: Map<Node, Lantern.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
    */
   _computeFinalNodeTimings() {
     /** @type {Array<[Node, CompleteNodeTiming]>} */
@@ -395,8 +398,8 @@ class Simulator {
     // Most consumers will want the entries sorted by startTime, so insert them in that order
     completeNodeTimingEntries.sort((a, b) => a[1].startTime - b[1].startTime);
 
-    // Trimmed version of type `LH.Gatherer.Simulation.NodeTiming`.
-    /** @type {Array<[Node, LH.Gatherer.Simulation.NodeTiming]>} */
+    // Trimmed version of type `Lantern.Simulation.NodeTiming`.
+    /** @type {Array<[Node, Lantern.Simulation.NodeTiming]>} */
     const nodeTimingEntries = completeNodeTimingEntries.map(([node, timing]) => {
       return [node, {
         startTime: timing.startTime,
@@ -412,7 +415,7 @@ class Simulator {
   }
 
   /**
-   * @return {Required<LH.Gatherer.Simulation.Options>}
+   * @return {Required<Lantern.Simulation.Options>}
    */
   getOptions() {
     return this._options;
@@ -429,7 +432,7 @@ class Simulator {
    *
    * @param {Node} graph
    * @param {{flexibleOrdering?: boolean, label?: string}=} options
-   * @return {LH.Gatherer.Simulation.Result}
+   * @return {Lantern.Simulation.Result<T>}
    */
   simulate(graph, options) {
     if (BaseNode.hasCycle(graph)) {
@@ -535,7 +538,7 @@ class Simulator {
    */
   static _computeNodeStartPosition(node) {
     if (node.type === 'cpu') return node.startTime;
-    return node.startTime + (PriorityStartTimePenalty[node.record.priority] * 1000 * 1000 || 0);
+    return node.startTime + (PriorityStartTimePenalty[node.request.priority] * 1000 * 1000 || 0);
   }
 }
 

package/core/lib/lantern/types/lantern.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as LH from '../../../../types/lh.js';
+
+type ParsedURL = {
+    /**
+     * Equivalent to a `new URL(url).protocol` BUT w/o the trailing colon (:)
+     */
+    scheme: string;
+    /**
+     * Equivalent to a `new URL(url).hostname`
+     */
+    host: string;
+    securityOrigin: string;
+};
+type LightriderStatistics = {
+    /**
+     * The difference in networkEndTime between the observed Lighthouse networkEndTime and Lightrider's derived networkEndTime.
+     */
+    endTimeDeltaMs: number;
+    /**
+     * The time spent making a TCP connection (connect + SSL). Note: this is poorly named.
+     */
+    TCPMs: number;
+    /**
+     * The time spent requesting a resource from a remote server, we use this to approx RTT. Note: this is poorly names, it really should be "server response time".
+     */
+    requestMs: number;
+    /**
+     * Time to receive the entire response payload starting the clock on receiving the first fragment (first non-header byte).
+     */
+    responseMs: number;
+};
+
+export class NetworkRequest<T = any> {
+    /**
+     * The canonical network record.
+     * Users of Lantern must create NetworkRequests matching this interface,
+     * but can store the source-of-truth for their network model in this `record`
+     * property. This is then accessible as a read-only property on NetworkNode.
+     */
+    record?: T;
+
+    requestId: string;
+    connectionId: string;
+    connectionReused: boolean;
+    url: string;
+    protocol: string;
+    parsedURL: ParsedURL;
+    documentURL: string;
+    /** When the renderer process initially discovers a network request, in milliseconds. */
+    rendererStartTime: number;
+    /**
+     * When the network service is about to handle a request, ie. just before going to the
+     * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
+     */
+    networkRequestTime: number;
+    /** When the last byte of the response headers is received, in milliseconds. */
+    responseHeadersEndTime: number;
+    /** When the last byte of the response body is received, in milliseconds. */
+    networkEndTime: number;
+    transferSize: number;
+    resourceSize: number;
+    fromDiskCache: boolean;
+    fromMemoryCache: boolean;
+    // TODO(15841): remove from lantern.
+    /** Extra timing information available only when run in Lightrider. */
+    lrStatistics: LightriderStatistics | undefined;
+    finished: boolean;
+    statusCode: number;
+    /** The network request that this one redirected to */
+    redirectDestination: NetworkRequest<T> | undefined;
+    failed: boolean;
+    initiator: LH.Crdp.Network.Initiator;
+    initiatorRequest: NetworkRequest<T> | undefined;
+    /** The chain of network requests that redirected to this one */
+    redirects: NetworkRequest[] | undefined;
+    timing: LH.Crdp.Network.ResourceTiming | undefined;
+    resourceType: LH.Crdp.Network.ResourceType | undefined;
+    mimeType: string;
+    priority: LH.Crdp.Network.ResourcePriority;
+    frameId: string | undefined;
+    sessionTargetType: LH.Protocol.TargetType | undefined;
+}
+
+export namespace Simulation {
+    type GraphNode<T> = import('../base-node.js').Node<T>;
+    type GraphNetworkNode<T> = import('../network-node.js').NetworkNode<T>;
+    type GraphCPUNode = import('../cpu-node.js').CPUNode;
+    type Simulator<T> = import('../simulator/simulator.js').Simulator<T>;
+
+    interface MetricCoefficients {
+        intercept: number;
+        optimistic: number;
+        pessimistic: number;
+    }
+
+    interface Options {
+        rtt?: number;
+        throughput?: number;
+        observedThroughput: number;
+        maximumConcurrentRequests?: number;
+        cpuSlowdownMultiplier?: number;
+        layoutTaskMultiplier?: number;
+        additionalRttByOrigin?: Map<string, number>;
+        serverResponseTimeByOrigin?: Map<string, number>;
+    }
+
+    interface NodeTiming {
+        startTime: number;
+        endTime: number;
+        duration: number;
+    }
+
+    interface Result<T = any> {
+        timeInMs: number;
+        nodeTimings: Map<GraphNode<T>, NodeTiming>;
+    }
+
+    interface MetricComputationDataInput {
+        simulator: Simulator<any>;
+        graph: GraphNode<any>;
+        processedNavigation: LH.Artifacts.ProcessedNavigation;
+    }
+}

package/core/lib/lantern/types/lantern.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export {};

package/core/lib/lantern-trace-saver.d.ts

@@ -3,15 +3,15 @@ declare namespace _default {
     export { convertNodeTimingsToTrace };
 }
 export default _default;
-export type Node = import('./dependency-graph/base-node.js').Node;
-export type CompleteNodeTiming = import('./dependency-graph/simulator/simulator.js').CompleteNodeTiming;
+export type Node = import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>;
+export type CompleteNodeTiming = import('./lantern/simulator/simulator.js').CompleteNodeTiming;
 /**
  * @license
  * Copyright 2018 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-/** @typedef {import('./dependency-graph/base-node.js').Node} Node */
-/** @typedef {import('./dependency-graph/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
+/** @typedef {import('./lantern/base-node.js').Node<LH.Artifacts.NetworkRequest>} Node */
+/** @typedef {import('./lantern/simulator/simulator.js').CompleteNodeTiming} CompleteNodeTiming */
 /**
  * @param {Map<Node, CompleteNodeTiming>} nodeTimings
  * @return {LH.Trace}