lighthouse 11.7.1 → 12.0.0

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

@@ -140,15 +140,6 @@ class NetworkAnalyzer {
     const {timing, connectionReused, record} = info;
     if (connectionReused) return;
 
-    // In LR, network records are missing connection timing, but we've smuggled it in via headers.
-    if (global.isLightrider && record.lrStatistics) {
-      if (record.protocol.startsWith('h3')) {
-        return record.lrStatistics.TCPMs;
-      } else {
-        return [record.lrStatistics.TCPMs / 2, record.lrStatistics.TCPMs / 2];
-      }
-    }
-
     const {connectStart, sslStart, sslEnd, connectEnd} = timing;
     if (connectEnd >= 0 && connectStart >= 0 && record.protocol.startsWith('h3')) {
       // These values are equal to sslStart and sslEnd for h3.
@@ -256,9 +247,7 @@ class NetworkAnalyzer {
    */
   static _estimateResponseTimeByOrigin(records, rttByOrigin) {
     return NetworkAnalyzer._estimateValueByOrigin(records, ({record, timing}) => {
-      // Lightrider does not have timings for sendEnd, but we do have this timing which should be
-      // close to the response time.
-      if (global.isLightrider && record.lrStatistics) return record.lrStatistics.requestMs;
+      if (record.serverResponseTime !== undefined) return record.serverResponseTime;
 
       if (!Number.isFinite(timing.receiveHeadersEnd) || timing.receiveHeadersEnd < 0) return;
       if (!Number.isFinite(timing.sendEnd) || timing.sendEnd < 0) return;

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

@@ -29,7 +29,6 @@ export class Simulator<T = any> {
     _layoutTaskMultiplier: number;
     /** @type {Array<Node>} */
     _cachedNodeListByStartPosition: Array<Node>;
-    _flexibleOrdering: boolean;
     _nodeTimings: SimulatorTimingMap;
     /** @type {Map<string, number>} */
     _numberInProgressByType: Map<string, number>;
@@ -131,17 +130,16 @@ export class Simulator<T = any> {
      * 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
+     * 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
+     * @param {{label?: string}=} options
      * @return {Lantern.Simulation.Result<T>}
      */
     simulate(graph: Node, options?: {
-        flexibleOrdering?: boolean;
         label?: string;
     } | undefined): Lantern.Simulation.Result<T>;
     /**

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

@@ -80,7 +80,6 @@ class Simulator {
     this._cachedNodeListByStartPosition = [];
 
     // Properties reset on every `.simulate` call but duplicated here for type checking
-    this._flexibleOrdering = false;
     this._nodeTimings = new SimulatorTimingMap();
     /** @type {Map<string, number>} */
     this._numberInProgressByType = new Map();
@@ -197,9 +196,7 @@ class Simulator {
    * @return {?TcpConnection}
    */
   _acquireConnection(record) {
-    return this._connectionPool.acquire(record, {
-      ignoreConnectionReused: this._flexibleOrdering,
-    });
+    return this._connectionPool.acquire(record);
   }
 
   /**
@@ -276,7 +273,7 @@ class Simulator {
       ? this._layoutTaskMultiplier
       : this._cpuSlowdownMultiplier;
     const totalDuration = Math.min(
-      Math.round(cpuNode.event.dur / 1000 * multiplier),
+      Math.round(cpuNode.duration / 1000 * multiplier),
       DEFAULT_MAXIMUM_CPU_TASK_DURATION
     );
     const estimatedTimeElapsed = totalDuration - timingData.timeElapsed;
@@ -425,13 +422,13 @@ class Simulator {
    * 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
+   * 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
+   * @param {{label?: string}=} options
    * @return {Lantern.Simulation.Result<T>}
    */
   simulate(graph, options) {
@@ -441,11 +438,9 @@ class Simulator {
 
     options = Object.assign({
       label: undefined,
-      flexibleOrdering: false,
     }, options);
 
     // initialize the necessary data containers
-    this._flexibleOrdering = !!options.flexibleOrdering;
     this._dns = new DNSCache({rtt: this._rtt});
     this._initializeConnectionPool(graph);
     this._initializeAuxiliaryData();
@@ -470,11 +465,9 @@ class Simulator {
       }
 
       if (!nodesInProgress.size) {
-        // interplay between fromDiskCache and connectionReused can be incorrect
-        // proceed with flexibleOrdering if we can, otherwise give up
-        if (this._flexibleOrdering) throw new Error('Failed to start a node');
-        this._flexibleOrdering = true;
-        continue;
+        // Interplay between fromDiskCache and connectionReused can be incorrect,
+        // have to give up.
+        throw new Error('Failed to start a node');
       }
 
       // set the available throughput for all connections based on # inflight

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

@@ -67,9 +67,6 @@ export class NetworkRequest<T = any> {
     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 */
@@ -80,6 +77,11 @@ export class NetworkRequest<T = any> {
     /** The chain of network requests that redirected to this one */
     redirects: NetworkRequest[] | undefined;
     timing: LH.Crdp.Network.ResourceTiming | undefined;
+    /**
+     * 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;
     resourceType: LH.Crdp.Network.ResourceType | undefined;
     mimeType: string;
     priority: LH.Crdp.Network.ResourcePriority;

package/core/lib/lantern-trace-saver.js

@@ -255,7 +255,6 @@ export default {
     'unlabeled',
     // These node timings should be nearly identical to the ones produced for Interactive
     'optimisticSpeedIndex',
-    'optimisticFlexSpeedIndex',
     'pessimisticSpeedIndex',
   ],
   convertNodeTimingsToTrace,

package/core/lib/lh-error.d.ts

@@ -105,6 +105,7 @@ export namespace UIStrings {
     const missingRequiredArtifact: string;
     const erroredRequiredArtifact: string;
     const oldChromeDoesNotSupportFeature: string;
+    const targetCrashed: string;
 }
 declare namespace ERRORS {
     namespace NO_SPEEDLINE_FRAMES {
@@ -340,6 +341,14 @@ declare namespace ERRORS {
         import message_30 = UIStrings.erroredRequiredArtifact;
         export { message_30 as message };
     }
+    namespace TARGET_CRASHED {
+        const code_31: string;
+        export { code_31 as code };
+        import message_31 = UIStrings.targetCrashed;
+        export { message_31 as message };
+        const lhrRuntimeError_22: boolean;
+        export { lhrRuntimeError_22 as lhrRuntimeError };
+    }
 }
 export {};
 //# sourceMappingURL=lh-error.d.ts.map

package/core/lib/lh-error.js

@@ -76,13 +76,13 @@ const UIStrings = {
   criTimeout: 'Timeout waiting for initial Debugger Protocol connection.',
   /**
    * @description Error message explaining that a resource that was required for testing was never collected. "artifactName" will be replaced with the name of the resource that wasn't collected.
-   * @example {WebAppManifest} artifactName
+   * @example {MainDocumentContent} artifactName
    * */
   missingRequiredArtifact: 'Required {artifactName} gatherer did not run.',
   /**
    * @description Error message explaining that there was an error while trying to collect a resource that was required for testing. "artifactName" will be replaced with the name of the resource that wasn't collected; "errorMessage" will be replaced with a string description of the error that occurred.
-   * @example {WebAppManifest} artifactName
-   * @example {Manifest invalid} errorMessage
+   * @example {MainDocumentContent} artifactName
+   * @example {Could not find main document} errorMessage
    * */
   erroredRequiredArtifact: 'Required {artifactName} gatherer encountered an error: {errorMessage}',
 
@@ -91,6 +91,9 @@ const UIStrings = {
    * @example {Largest Contentful Paint} featureName
    * */
   oldChromeDoesNotSupportFeature: 'This version of Chrome is too old to support \'{featureName}\'. Use a newer version to see full results.',
+
+  /** Error message explaining that the browser tab that Lighthouse is inspecting has crashed. */
+  targetCrashed: 'Browser tab has unexpectedly crashed.',
 };
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
@@ -423,6 +426,13 @@ const ERRORS = {
     message: UIStrings.erroredRequiredArtifact,
   },
 
+  /** The page has crashed and will no longer respond to 99% of CDP commmands. */
+  TARGET_CRASHED: {
+    code: 'TARGET_CRASHED',
+    message: UIStrings.targetCrashed,
+    lhrRuntimeError: true,
+  },
+
   // Hey! When adding a new error type, update lighthouse-result.proto too.
   // Only necessary for runtime errors, which come from artifacts or pageLoadErrors.
 };

package/core/lib/lighthouse-compatibility.js

@@ -108,19 +108,62 @@ function upgradeLhrForCompatibility(lhr) {
     }
   }
 
-  // This backcompat converts old LHRs (<9.0.0) to use the new "hidden" group.
-  // Old LHRs used "no group" to identify audits that should be hidden in performance instead of the "hidden" group.
-  // Newer LHRs use "no group" to identify opportunities and diagnostics whose groups are assigned by details type.
+  // This backcompat converts old LHRs to use the "hidden" and "diagnostics" groups.
+  // <9.0.0 LHRs used "no group" to identify audits that should be hidden in performance instead of the "hidden" group.
+  // <9.0.0 LHRs used "load-opportunities" for opportunity audits that are now grouped under "diagnostics".
+  // >=9.0.0 && <12.0.0 LHRs use "no group" to identify opportunities and diagnostics whose groups are assigned by details type.
+  // >=12.0.0 LHRs use the "hidden" group to identify hidden audits and "diagnostics" to identify diagnostics. "no group" is meaningless.
   const [majorVersion] = lhr.lighthouseVersion.split('.').map(Number);
   const perfCategory = lhr.categories['performance'];
-  if (majorVersion < 9 && perfCategory) {
-    if (!lhr.categoryGroups) lhr.categoryGroups = {};
-    lhr.categoryGroups['hidden'] = {title: ''};
+  if (perfCategory) {
+    if (majorVersion < 9) {
+      if (!lhr.categoryGroups) lhr.categoryGroups = {};
+      lhr.categoryGroups['hidden'] = {title: ''};
+      for (const auditRef of perfCategory.auditRefs) {
+        if (!auditRef.group) {
+          auditRef.group = 'hidden';
+        } else if (auditRef.group === 'load-opportunities') {
+          auditRef.group = 'diagnostics';
+        }
+      }
+    } else if (majorVersion < 12) {
+      for (const auditRef of perfCategory.auditRefs) {
+        if (!auditRef.group) {
+          auditRef.group = 'diagnostics';
+        }
+      }
+    }
+  }
+
+  if (majorVersion < 12 && perfCategory) {
+    /** @type {Map<string, string[]>} */
+    const metricRelevanceMap = new Map();
+
     for (const auditRef of perfCategory.auditRefs) {
-      if (!auditRef.group) {
-        auditRef.group = 'hidden';
-      } else if (['load-opportunities', 'diagnostics'].includes(auditRef.group)) {
-        delete auditRef.group;
+      /** @type {string[]|undefined} */
+      // @ts-expect-error Removed in v12
+      const relevantAudits = auditRef.relevantAudits;
+      if (!relevantAudits || !auditRef.acronym) continue;
+
+      for (const auditId of relevantAudits) {
+        const acronyms = metricRelevanceMap.get(auditId) || [];
+        acronyms.push(auditRef.acronym);
+        metricRelevanceMap.set(auditId, acronyms);
+      }
+    }
+
+    for (const [auditId, acronyms] of metricRelevanceMap) {
+      if (!acronyms.length) continue;
+
+      const audit = lhr.audits[auditId];
+      if (!audit) continue;
+
+      // Old versions can still define metric savings, let's not mess with it.
+      if (audit.metricSavings) continue;
+
+      audit.metricSavings = {};
+      for (const acronym of acronyms) {
+        audit.metricSavings[acronym] = 0;
       }
     }
   }

package/core/lib/navigation-error.js

@@ -150,6 +150,9 @@ function getPageLoadError(navigationError, context) {
   let finalRecord;
   if (mainRecord) {
     finalRecord = NetworkAnalyzer.resolveRedirects(mainRecord);
+  } else {
+    // We have no network requests to process, use the navError
+    return navigationError;
   }
 
   if (finalRecord?.mimeType === XHTML_MIME_TYPE) {

package/core/lib/network-request.d.ts

@@ -247,6 +247,7 @@ export class NetworkRequest {
      * is passed in via X-Headers similar to 'X-TotalFetchedSize'.
      */
     _updateTimingsForLightrider(): void;
+    serverResponseTime: number | undefined;
 }
 export namespace NetworkRequest {
     export { HEADER_TCP };

package/core/lib/network-request.js

@@ -536,6 +536,7 @@ class NetworkRequest {
       requestMs: requestMs,
       responseMs: responseMs,
     };
+    this.serverResponseTime = responseMs;
   }
 
   /**
@@ -574,8 +575,35 @@ class NetworkRequest {
    * @return {Lantern.NetworkRequest<NetworkRequest>}
    */
   static asLanternNetworkRequest(record) {
+    // In LR, network records are missing connection timing, but we've smuggled it in via headers.
+    let timing = record.timing;
+    let serverResponseTime;
+    if (global.isLightrider && record.lrStatistics) {
+      if (record.protocol.startsWith('h3')) {
+        // @ts-expect-error We don't need all the properties set.
+        timing = {
+          connectStart: 0,
+          connectEnd: record.lrStatistics.TCPMs,
+        };
+      } else {
+        // @ts-expect-error We don't need all the properties set.
+        timing = {
+          connectStart: 0,
+          sslStart: record.lrStatistics.TCPMs / 2,
+          connectEnd: record.lrStatistics.TCPMs,
+          sslEnd: record.lrStatistics.TCPMs,
+        };
+
+        // Lightrider does not have timings for sendEnd, but we do have this timing which should be
+        // close to the response time.
+        serverResponseTime = record.lrStatistics.requestMs;
+      }
+    }
+
     return {
       ...record,
+      timing,
+      serverResponseTime,
       record,
     };
   }

package/core/runner.js

@@ -106,7 +106,6 @@ class Runner {
           networkUserAgent: artifacts.NetworkUserAgent,
           hostUserAgent: artifacts.HostUserAgent,
           benchmarkIndex: artifacts.BenchmarkIndex,
-          benchmarkIndexes: artifacts.BenchmarkIndexes,
           credits,
         },
         audits: auditResultsById,
@@ -199,32 +198,27 @@ class Runner {
         data: sentryContext,
       });
 
-      /** @type {LH.Artifacts} */
-      let artifacts;
       if (settings.auditMode && !settings.gatherMode) {
         // No browser required, just load the artifacts from disk.
         const path = this._getDataSavePath(settings);
-        artifacts = assetSaver.loadArtifacts(path);
-      } else {
-        const runnerStatus = {msg: 'Gather phase', id: 'lh:runner:gather'};
-        log.time(runnerStatus, 'verbose');
-
-        artifacts = await gatherFn({
-          resolvedConfig: options.resolvedConfig,
-        });
-
-        log.timeEnd(runnerStatus);
-
-        // If `gather` is run multiple times before `audit`, the timing entries for each `gather` can pollute one another.
-        // We need to clear the timing entries at the end of gathering.
-        // Set artifacts.Timing again to ensure lh:runner:gather is included.
-        artifacts.Timing = log.takeTimeEntries();
-
-        // -G means save these to disk (e.g. ./latest-run).
-        if (settings.gatherMode) {
-          const path = this._getDataSavePath(settings);
-          await assetSaver.saveArtifacts(artifacts, path);
-        }
+        return assetSaver.loadArtifacts(path);
+      }
+
+      const runnerStatus = {msg: 'Gather phase', id: 'lh:runner:gather'};
+      log.time(runnerStatus, 'verbose');
+
+      const artifacts = await gatherFn({resolvedConfig: options.resolvedConfig});
+      log.timeEnd(runnerStatus);
+
+      // If `gather` is run multiple times before `audit`, the timing entries for each `gather` can pollute one another.
+      // We need to clear the timing entries at the end of gathering.
+      // Set artifacts.Timing again to ensure lh:runner:gather is included.
+      artifacts.Timing = log.takeTimeEntries();
+
+      // -G means save these to disk (e.g. ./latest-run).
+      if (settings.gatherMode) {
+        const path = this._getDataSavePath(settings);
+        await assetSaver.saveArtifacts(artifacts, path);
       }
 
       return artifacts;
@@ -304,7 +298,6 @@ class Runner {
         auditMode: undefined,
         output: undefined,
         channel: undefined,
-        budgets: undefined,
       };
       const normalizedGatherSettings = Object.assign({}, artifacts.settings, overrides);
       const normalizedAuditSettings = Object.assign({}, settings, overrides);