lighthouse 12.0.0-dev.20240602 → 12.0.0-dev.20240604

package/core/lib/lantern/simulator/connection-pool.js

@@ -27,7 +27,7 @@ export class ConnectionPool {
     /** @type {Map<string, TcpConnection[]>} */
     this._connectionsByOrigin = new Map();
     /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
-    this._connectionsByRecord = new Map();
+    this._connectionsByRequest = new Map();
     this._connectionsInUse = new Set();
     this._connectionReusedByRequestId = NetworkAnalyzer.estimateIfConnectionWasReused(records, {
       forceCoarseEstimates: true,
@@ -49,16 +49,16 @@ export class ConnectionPool {
     const serverResponseTimeByOrigin = this._options.serverResponseTimeByOrigin;
 
     const recordsByOrigin = NetworkAnalyzer.groupByOrigin(this._records);
-    for (const [origin, records] of recordsByOrigin.entries()) {
+    for (const [origin, requests] of recordsByOrigin.entries()) {
       const connections = [];
       const additionalRtt = additionalRttByOrigin.get(origin) || 0;
       const responseTime = serverResponseTimeByOrigin.get(origin) || DEFAULT_SERVER_RESPONSE_TIME;
 
-      for (const record of records) {
-        if (connectionReused.get(record.requestId)) continue;
+      for (const request of requests) {
+        if (connectionReused.get(request.requestId)) continue;
 
-        const isTLS = TLS_SCHEMES.includes(record.parsedURL.scheme);
-        const isH2 = record.protocol === 'h2';
+        const isTLS = TLS_SCHEMES.includes(request.parsedURL.scheme);
+        const isH2 = request.protocol === 'h2';
         const connection = new TcpConnection(
           this._options.rtt + additionalRtt,
           this._options.throughput,
@@ -106,47 +106,47 @@ export class ConnectionPool {
   }
 
   /**
-   * This method finds an available connection to the origin specified by the network record or null
+   * This method finds an available connection to the origin specified by the network request or null
    * if no connection was available. If returned, connection will not be available for other network
    * records until release is called.
    *
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    * @return {?TcpConnection}
    */
-  acquire(record) {
-    if (this._connectionsByRecord.has(record)) throw new Error('Record already has a connection');
+  acquire(request) {
+    if (this._connectionsByRequest.has(request)) throw new Error('Record already has a connection');
 
-    const origin = record.parsedURL.securityOrigin;
+    const origin = request.parsedURL.securityOrigin;
     const connections = this._connectionsByOrigin.get(origin) || [];
     const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections);
 
     if (!connectionToUse) return null;
 
     this._connectionsInUse.add(connectionToUse);
-    this._connectionsByRecord.set(record, connectionToUse);
+    this._connectionsByRequest.set(request, connectionToUse);
     return connectionToUse;
   }
 
   /**
-   * Return the connection currently being used to fetch a record. If no connection
-   * currently being used for this record, an error will be thrown.
+   * Return the connection currently being used to fetch a request. If no connection
+   * currently being used for this request, an error will be thrown.
    *
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    * @return {TcpConnection}
    */
-  acquireActiveConnectionFromRecord(record) {
-    const activeConnection = this._connectionsByRecord.get(record);
-    if (!activeConnection) throw new Error('Could not find an active connection for record');
+  acquireActiveConnectionFromRequest(request) {
+    const activeConnection = this._connectionsByRequest.get(request);
+    if (!activeConnection) throw new Error('Could not find an active connection for request');
 
     return activeConnection;
   }
 
   /**
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    */
-  release(record) {
-    const connection = this._connectionsByRecord.get(record);
-    this._connectionsByRecord.delete(record);
+  release(request) {
+    const connection = this._connectionsByRequest.get(request);
+    this._connectionsByRequest.delete(request);
     this._connectionsInUse.delete(connection);
   }
 }

package/core/lib/lantern/simulator/dns-cache.d.ts

@@ -25,7 +25,7 @@ export class DNSCache {
      */
     _updateCacheResolvedAtIfNeeded(request: Lantern.NetworkRequest, resolvedAt: number): void;
     /**
-     * Forcefully sets the DNS resolution time for a record.
+     * Forcefully sets the DNS resolution time for a request.
      * Useful for testing and alternate execution simulations.
      *
      * @param {string} domain

package/core/lib/lantern/simulator/dns-cache.js

@@ -58,7 +58,7 @@ class DNSCache {
   }
 
   /**
-   * Forcefully sets the DNS resolution time for a record.
+   * Forcefully sets the DNS resolution time for a request.
    * Useful for testing and alternate execution simulations.
    *
    * @param {string} domain

package/core/lib/lantern/simulator/network-analyzer.d.ts

@@ -46,14 +46,14 @@ export class NetworkAnalyzer {
      * @return {Map<string, Summary>}
      */
     static summarize(values: Map<string, number[]>): Map<string, Summary>;
-    /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+    /** @typedef {{request: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
     /**
-     * @param {Lantern.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} requests
      * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
      * @return {Map<string, number[]>}
      */
-    static _estimateValueByOrigin(records: Lantern.NetworkRequest[], iteratee: (e: {
-        record: Lantern.NetworkRequest;
+    static _estimateValueByOrigin(requests: Lantern.NetworkRequest[], iteratee: (e: {
+        request: 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: Lantern.NetworkRequest;
+        request: 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: Lantern.NetworkRequest;
+        request: 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: Lantern.NetworkRequest;
+        request: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -110,7 +110,7 @@ export class NetworkAnalyzer {
      * @return {number|undefined}
      */
     static _estimateRTTViaHeadersEndTiming(info: {
-        record: Lantern.NetworkRequest;
+        request: Lantern.NetworkRequest;
         timing: LH.Crdp.Network.ResourceTiming;
         connectionReused?: boolean | undefined;
     }): number | undefined;
@@ -123,10 +123,10 @@ export class NetworkAnalyzer {
      */
     static _estimateResponseTimeByOrigin(records: Lantern.NetworkRequest[], rttByOrigin: Map<string, number>): Map<string, number[]>;
     /**
-     * @param {Lantern.NetworkRequest[]} records
+     * @param {Lantern.NetworkRequest[]} requests
      * @return {boolean}
      */
-    static canTrustConnectionInformation(records: Lantern.NetworkRequest[]): boolean;
+    static canTrustConnectionInformation(requests: Lantern.NetworkRequest[]): boolean;
     /**
      * Returns a map of requestId -> connectionReused, estimating the information if the information
      * available in the records themselves appears untrustworthy.
@@ -160,9 +160,9 @@ export class NetworkAnalyzer {
         rttByOrigin?: Map<string, number> | undefined;
     }) | undefined): Map<string, Summary>;
     /**
-     * Computes the average throughput for the given records in bits/second.
+     * Computes the average throughput for the given requests in bits/second.
      * Excludes data URI, failed or otherwise incomplete, and cached requests.
-     * Returns Infinity if there were no analyzable network records.
+     * Returns Infinity if there were no analyzable network requests.
      *
      * @param {Lantern.NetworkRequest[]} records
      * @return {number}

package/core/lib/lantern/simulator/network-analyzer.js

@@ -88,30 +88,30 @@ class NetworkAnalyzer {
     return summaryByKey;
   }
 
-  /** @typedef {{record: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
+  /** @typedef {{request: Lantern.NetworkRequest, timing: LH.Crdp.Network.ResourceTiming, connectionReused?: boolean}} RequestInfo */
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} requests
    * @param {(e: RequestInfo) => number | number[] | undefined} iteratee
    * @return {Map<string, number[]>}
    */
-  static _estimateValueByOrigin(records, iteratee) {
-    const connectionWasReused = NetworkAnalyzer.estimateIfConnectionWasReused(records);
-    const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
+  static _estimateValueByOrigin(requests, iteratee) {
+    const connectionWasReused = NetworkAnalyzer.estimateIfConnectionWasReused(requests);
+    const groupedByOrigin = NetworkAnalyzer.groupByOrigin(requests);
 
     const estimates = new Map();
-    for (const [origin, originRecords] of groupedByOrigin.entries()) {
+    for (const [origin, originRequests] of groupedByOrigin.entries()) {
       /** @type {number[]} */
       let originEstimates = [];
 
-      for (const record of originRecords) {
-        const timing = record.timing;
+      for (const request of originRequests) {
+        const timing = request.timing;
         if (!timing) continue;
 
         const value = iteratee({
-          record,
+          request,
           timing,
-          connectionReused: connectionWasReused.get(record.requestId),
+          connectionReused: connectionWasReused.get(request.requestId),
         });
         if (typeof value !== 'undefined') {
           originEstimates = originEstimates.concat(value);
@@ -137,11 +137,11 @@ class NetworkAnalyzer {
    * @return {number[]|number|undefined}
    */
   static _estimateRTTViaConnectionTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (connectionReused) return;
 
     const {connectStart, sslStart, sslEnd, connectEnd} = timing;
-    if (connectEnd >= 0 && connectStart >= 0 && record.protocol.startsWith('h3')) {
+    if (connectEnd >= 0 && connectStart >= 0 && request.protocol.startsWith('h3')) {
       // These values are equal to sslStart and sslEnd for h3.
       return connectEnd - connectStart;
     } else if (sslStart >= 0 && sslEnd >= 0 && sslStart !== connectStart) {
@@ -161,17 +161,17 @@ class NetworkAnalyzer {
    * @return {number|undefined}
    */
   static _estimateRTTViaDownloadTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (connectionReused) return;
 
     // Only look at downloads that went past the initial congestion window
-    if (record.transferSize <= INITIAL_CWD) return;
+    if (request.transferSize <= INITIAL_CWD) return;
     if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
 
     // Compute the amount of time downloading everything after the first congestion window took
-    const totalTime = record.networkEndTime - record.networkRequestTime;
+    const totalTime = request.networkEndTime - request.networkRequestTime;
     const downloadTimeAfterFirstByte = totalTime - timing.receiveHeadersEnd;
-    const numberOfRoundTrips = Math.log2(record.transferSize / INITIAL_CWD);
+    const numberOfRoundTrips = Math.log2(request.transferSize / INITIAL_CWD);
 
     // Ignore requests that required a high number of round trips since bandwidth starts to play
     // a larger role than latency
@@ -190,7 +190,7 @@ class NetworkAnalyzer {
    * @return {number|undefined}
    */
   static _estimateRTTViaSendStartTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (connectionReused) return;
 
     if (!Number.isFinite(timing.sendStart) || timing.sendStart < 0) return;
@@ -198,8 +198,8 @@ class NetworkAnalyzer {
     // Assume everything before sendStart was just DNS + (SSL)? + TCP handshake
     // 1 RT for DNS, 1 RT (maybe) for SSL, 1 RT for TCP
     let roundTrips = 1;
-    if (!record.protocol.startsWith('h3')) roundTrips += 1; // TCP
-    if (record.parsedURL.scheme === 'https') roundTrips += 1;
+    if (!request.protocol.startsWith('h3')) roundTrips += 1; // TCP
+    if (request.parsedURL.scheme === 'https') roundTrips += 1;
     return timing.sendStart / roundTrips;
   }
 
@@ -213,12 +213,12 @@ class NetworkAnalyzer {
    * @return {number|undefined}
    */
   static _estimateRTTViaHeadersEndTiming(info) {
-    const {timing, connectionReused, record} = info;
+    const {timing, connectionReused, request} = info;
     if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
-    if (!record.resourceType) return;
+    if (!request.resourceType) return;
 
     const serverResponseTimePercentage =
-      SERVER_RESPONSE_PERCENTAGE_OF_TTFB[record.resourceType] ||
+      SERVER_RESPONSE_PERCENTAGE_OF_TTFB[request.resourceType] ||
       DEFAULT_SERVER_RESPONSE_PERCENTAGE;
     const estimatedServerResponseTime = timing.receiveHeadersEnd * serverResponseTimePercentage;
 
@@ -230,8 +230,8 @@ class NetworkAnalyzer {
     // TTFB = DNS + (SSL)? + TCP handshake + 1 RT for request + server response time
     if (!connectionReused) {
       roundTrips += 1; // DNS
-      if (!record.protocol.startsWith('h3')) roundTrips += 1; // TCP
-      if (record.parsedURL.scheme === 'https') roundTrips += 1; // SSL
+      if (!request.protocol.startsWith('h3')) roundTrips += 1; // TCP
+      if (request.parsedURL.scheme === 'https') roundTrips += 1; // SSL
     }
 
     // subtract out our estimated server response time
@@ -246,28 +246,28 @@ class NetworkAnalyzer {
    * @return {Map<string, number[]>}
    */
   static _estimateResponseTimeByOrigin(records, rttByOrigin) {
-    return NetworkAnalyzer._estimateValueByOrigin(records, ({record, timing}) => {
-      if (record.serverResponseTime !== undefined) return record.serverResponseTime;
+    return NetworkAnalyzer._estimateValueByOrigin(records, ({request, timing}) => {
+      if (request.serverResponseTime !== undefined) return request.serverResponseTime;
 
       if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
       if (!Number.isFinite(timing.sendEnd) || timing.sendEnd < 0) return;
 
       const ttfb = timing.receiveHeadersEnd - timing.sendEnd;
-      const origin = record.parsedURL.securityOrigin;
+      const origin = request.parsedURL.securityOrigin;
       const rtt = rttByOrigin.get(origin) || rttByOrigin.get(NetworkAnalyzer.SUMMARY) || 0;
       return Math.max(ttfb - rtt, 0);
     });
   }
 
   /**
-   * @param {Lantern.NetworkRequest[]} records
+   * @param {Lantern.NetworkRequest[]} requests
    * @return {boolean}
    */
-  static canTrustConnectionInformation(records) {
+  static canTrustConnectionInformation(requests) {
     const connectionIdWasStarted = new Map();
-    for (const record of records) {
-      const started = connectionIdWasStarted.get(record.connectionId) || !record.connectionReused;
-      connectionIdWasStarted.set(record.connectionId, started);
+    for (const request of requests) {
+      const started = connectionIdWasStarted.get(request.connectionId) || !request.connectionReused;
+      connectionIdWasStarted.set(request.connectionId, started);
     }
 
     // We probably can't trust the network information if all the connection IDs were the same
@@ -289,10 +289,10 @@ class NetworkAnalyzer {
 
     // Check if we can trust the connection information coming from the protocol
     if (!forceCoarseEstimates && NetworkAnalyzer.canTrustConnectionInformation(records)) {
-      return new Map(records.map(record => [record.requestId, !!record.connectionReused]));
+      return new Map(records.map(request => [request.requestId, !!request.connectionReused]));
     }
 
-    // Otherwise we're on our own, a record may not have needed a fresh connection if...
+    // Otherwise we're on our own, a request may not have needed a fresh connection if...
     //   - It was not the first request to the domain
     //   - It was H2
     //   - It was after the first request to the domain ended
@@ -300,13 +300,13 @@ class NetworkAnalyzer {
     const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
     for (const [_, originRecords] of groupedByOrigin.entries()) {
       const earliestReusePossible = originRecords
-        .map(record => record.networkEndTime)
+        .map(request => request.networkEndTime)
         .reduce((a, b) => Math.min(a, b), Infinity);
 
-      for (const record of originRecords) {
+      for (const request of originRecords) {
         connectionWasReused.set(
-          record.requestId,
-          record.networkRequestTime >= earliestReusePossible || record.protocol === 'h2'
+          request.requestId,
+          request.networkRequestTime >= earliestReusePossible || request.protocol === 'h2'
         );
       }
 
@@ -343,7 +343,7 @@ class NetworkAnalyzer {
     const groupedByOrigin = NetworkAnalyzer.groupByOrigin(records);
 
     const estimatesByOrigin = new Map();
-    for (const [origin, originRecords] of groupedByOrigin.entries()) {
+    for (const [origin, originRequests] of groupedByOrigin.entries()) {
       /** @type {number[]} */
       const originEstimates = [];
 
@@ -352,14 +352,14 @@ class NetworkAnalyzer {
        */
       // eslint-disable-next-line no-inner-declarations
       function collectEstimates(estimator, multiplier = 1) {
-        for (const record of originRecords) {
-          const timing = record.timing;
+        for (const request of originRequests) {
+          const timing = request.timing;
           if (!timing) continue;
 
           const estimates = estimator({
-            record,
+            request,
             timing,
-            connectionReused: connectionWasReused.get(record.requestId),
+            connectionReused: connectionWasReused.get(request.requestId),
           });
           if (estimates === undefined) continue;
 
@@ -427,9 +427,9 @@ class NetworkAnalyzer {
 
 
   /**
-   * Computes the average throughput for the given records in bits/second.
+   * Computes the average throughput for the given requests in bits/second.
    * Excludes data URI, failed or otherwise incomplete, and cached requests.
-   * Returns Infinity if there were no analyzable network records.
+   * Returns Infinity if there were no analyzable network requests.
    *
    * @param {Lantern.NetworkRequest[]} records
    * @return {number}
@@ -438,21 +438,21 @@ class NetworkAnalyzer {
     let totalBytes = 0;
 
     // We will measure throughput by summing the total bytes downloaded by the total time spent
-    // downloading those bytes. We slice up all the network records into start/end boundaries, so
+    // downloading those bytes. We slice up all the network requests into start/end boundaries, so
     // it's easier to deal with the gaps in downloading.
-    const timeBoundaries = records.reduce((boundaries, record) => {
-      const scheme = record.parsedURL?.scheme;
+    const timeBoundaries = records.reduce((boundaries, request) => {
+      const scheme = request.parsedURL?.scheme;
       // Requests whose bodies didn't come over the network or didn't completely finish will mess
       // with the computation, just skip over them.
-      if (scheme === 'data' || record.failed || !record.finished ||
-          record.statusCode > 300 || !record.transferSize) {
+      if (scheme === 'data' || request.failed || !request.finished ||
+          request.statusCode > 300 || !request.transferSize) {
         return boundaries;
       }
 
       // If we've made it this far, all the times we need should be valid (i.e. not undefined/-1).
-      totalBytes += record.transferSize;
-      boundaries.push({time: record.responseHeadersEndTime / 1000, isStart: true});
-      boundaries.push({time: record.networkEndTime / 1000, isStart: false});
+      totalBytes += request.transferSize;
+      boundaries.push({time: request.responseHeadersEndTime / 1000, isStart: true});
+      boundaries.push({time: request.networkEndTime / 1000, isStart: false});
       return boundaries;
     }, /** @type {Array<{time: number, isStart: boolean}>} */([])).sort((a, b) => a.time - b.time);
 

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

@@ -10,11 +10,11 @@ export class Simulator<T = any> {
     /**
      * @param {Lantern.Simulation.Settings} settings
      */
-    static createSimulator(settings: Lantern.Simulation.Settings): Promise<Simulator<any>>;
+    static createSimulator(settings: Lantern.Simulation.Settings): Simulator<any>;
     /** @return {Map<string, Map<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.
+     * We attempt to start nodes by their observed start time using the request 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
@@ -73,10 +73,10 @@ export class Simulator<T = any> {
      */
     _markNodeAsComplete(node: Node, endTime: number, connectionTiming?: import("./simulator-timing-map.js").ConnectionTiming | undefined): void;
     /**
-     * @param {Lantern.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} request
      * @return {?TcpConnection}
      */
-    _acquireConnection(record: Lantern.NetworkRequest): TcpConnection | null;
+    _acquireConnection(request: Lantern.NetworkRequest): TcpConnection | null;
     /**
      * @return {Node[]}
      */
@@ -136,7 +136,7 @@ export class Simulator<T = any> {
      *
      * 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
+     * wait around for a warm connection to be available if the original request was fetched on a warm
      * connection).
      *
      * @param {Node} graph

package/core/lib/lantern/simulator/simulator.js

@@ -34,7 +34,7 @@ const NodeState = {
   Complete: 3,
 };
 
-/** @type {Record<NetworkNode['record']['priority'], number>} */
+/** @type {Record<NetworkNode['request']['priority'], number>} */
 const PriorityStartTimePenalty = {
   VeryHigh: 0,
   High: 0.25,
@@ -53,7 +53,7 @@ class Simulator {
   /**
    * @param {Lantern.Simulation.Settings} settings
    */
-  static async createSimulator(settings) {
+  static createSimulator(settings) {
     const {throttlingMethod, throttling, precomputedLanternData, networkAnalysis} = settings;
 
     /** @type {Lantern.Simulation.Options} */
@@ -248,11 +248,11 @@ class Simulator {
   }
 
   /**
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    * @return {?TcpConnection}
    */
-  _acquireConnection(record) {
-    return this._connectionPool.acquire(record);
+  _acquireConnection(request) {
+    return this._connectionPool.acquire(request);
   }
 
   /**
@@ -342,7 +342,7 @@ class Simulator {
    * @return {number}
    */
   _estimateNetworkTimeRemaining(networkNode) {
-    const record = networkNode.request;
+    const request = networkNode.request;
     const timingData = this._nodeTimings.getNetworkStarted(networkNode);
 
     let timeElapsed = 0;
@@ -350,23 +350,23 @@ class Simulator {
       // Rough access time for seeking to location on disk and reading sequentially.
       // 8ms per seek + 20ms/MB
       // @see http://norvig.com/21-days.html#answers
-      const sizeInMb = (record.resourceSize || 0) / 1024 / 1024;
+      const sizeInMb = (request.resourceSize || 0) / 1024 / 1024;
       timeElapsed = 8 + 20 * sizeInMb - timingData.timeElapsed;
     } else if (networkNode.isNonNetworkProtocol) {
       // Estimates for the overhead of a data URL in Chromium and the decoding time for base64-encoded data.
       // 2ms per request + 10ms/MB
       // @see traces on https://dopiaza.org/tools/datauri/examples/index.php
-      const sizeInMb = (record.resourceSize || 0) / 1024 / 1024;
+      const sizeInMb = (request.resourceSize || 0) / 1024 / 1024;
       timeElapsed = 2 + 10 * sizeInMb - timingData.timeElapsed;
     } else {
-      const connection = this._connectionPool.acquireActiveConnectionFromRecord(record);
-      const dnsResolutionTime = this._dns.getTimeUntilResolution(record, {
+      const connection = this._connectionPool.acquireActiveConnectionFromRequest(request);
+      const dnsResolutionTime = this._dns.getTimeUntilResolution(request, {
         requestedAt: timingData.startTime,
         shouldUpdateCache: true,
       });
       const timeAlreadyElapsed = timingData.timeElapsed;
       const calculation = connection.simulateDownloadUntil(
-        record.transferSize - timingData.bytesDownloaded,
+        request.transferSize - timingData.bytesDownloaded,
         {timeAlreadyElapsed, dnsResolutionTime, maximumTimeToElapse: Infinity}
       );
 
@@ -410,14 +410,14 @@ 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.request;
-    const connection = this._connectionPool.acquireActiveConnectionFromRecord(record);
-    const dnsResolutionTime = this._dns.getTimeUntilResolution(record, {
+    const request = node.request;
+    const connection = this._connectionPool.acquireActiveConnectionFromRequest(request);
+    const dnsResolutionTime = this._dns.getTimeUntilResolution(request, {
       requestedAt: timingData.startTime,
       shouldUpdateCache: true,
     });
     const calculation = connection.simulateDownloadUntil(
-      record.transferSize - timingData.bytesDownloaded,
+      request.transferSize - timingData.bytesDownloaded,
       {
         dnsResolutionTime,
         timeAlreadyElapsed: timingData.timeElapsed,
@@ -430,7 +430,7 @@ class Simulator {
 
     if (isFinished) {
       connection.setWarmed(true);
-      this._connectionPool.release(record);
+      this._connectionPool.release(request);
       this._markNodeAsComplete(node, totalElapsedTime, calculation.connectionTiming);
     } else {
       timingData.timeElapsed += calculation.timeElapsed;
@@ -480,7 +480,7 @@ class Simulator {
    *
    * 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
+   * wait around for a warm connection to be available if the original request was fetched on a warm
    * connection).
    *
    * @param {Node} graph
@@ -580,7 +580,7 @@ class Simulator {
   }
 
   /**
-   * We attempt to start nodes by their observed start time using the record priority as a tie breaker.
+   * We attempt to start nodes by their observed start time using the request 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

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

@@ -38,12 +38,13 @@ type LightriderStatistics = {
 
 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.
+     * Implementation-specifc canoncial data structure that this Lantern NetworkRequest
+     * was derived from.
+     * Users of Lantern create a NetworkRequest matching this interface,
+     * but can store the source-of-truth for their network model in this property.
+     * This is then accessible as a read-only property on NetworkNode.
      */
-    record?: T;
+    rawRequest?: T;
 
     requestId: string;
     connectionId: number;
@@ -67,11 +68,14 @@ export class NetworkRequest<T = any> {
     resourceSize: number;
     fromDiskCache: boolean;
     fromMemoryCache: boolean;
+    isLinkPreload: boolean;
     finished: boolean;
+    failed: boolean;
     statusCode: number;
+    /** The network request that redirected to this one */
+    redirectSource: NetworkRequest<T> | undefined;
     /** 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 */
@@ -81,12 +85,12 @@ export class NetworkRequest<T = any> {
      * Optional value for how long the server took to respond to this request.
      * When not provided, the server response time is derived from the timing object.
      */
-    serverResponseTime: number | undefined;
+    serverResponseTime?: number;
     resourceType: LH.Crdp.Network.ResourceType | undefined;
     mimeType: string;
     priority: LH.Crdp.Network.ResourcePriority;
     frameId: string | undefined;
-    sessionTargetType: LH.Protocol.TargetType | undefined;
+    fromWorker: boolean;
 }
 
 export namespace Simulation {