lighthouse 11.3.0-dev.20231205 → 11.3.0-dev.20231207

package/core/audits/bf-cache.d.ts

@@ -15,6 +15,7 @@ export namespace UIStrings {
     const supportPendingFailureType: string;
     const failureReasonColumn: string;
     const failureTypeColumn: string;
+    const warningHeadless: string;
     const displayValue: string;
 }
 import { Audit } from './audit.js';

package/core/audits/bf-cache.js

@@ -26,6 +26,8 @@ const UIStrings = {
   failureReasonColumn: 'Failure reason',
   /** Label for a column in a data table; entries in the column will be a string representing the type of failure preventing the back/forward cache from being used. */
   failureTypeColumn: 'Failure type',
+  /** Warning explaining that the back/forward cache results cannot be shown in the old Headless Chrome. "back/forward" refers to the back and forward buttons found in modern browsers. "Headless Chrome" is a product name and should not be translated. */
+  warningHeadless: 'Back/forward cache cannot be tested in old Headless Chrome (`--chrome-flags="--headless=old"`). To see audit results, use the new Headless Chrome (`--chrome-flags="--headless=new"`) or standard Chrome.',
   /**
    * @description [ICU Syntax] Label for an audit identifying the number of back/forward cache failure reasons found in the page.
    */
@@ -60,7 +62,7 @@ class BFCache extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation', 'timespan'],
       guidanceLevel: 2,
-      requiredArtifacts: ['BFCacheFailures'],
+      requiredArtifacts: ['BFCacheFailures', 'HostProduct'],
       scoreDisplayMode: Audit.SCORING_MODES.BINARY,
     };
   }
@@ -70,6 +72,14 @@ class BFCache extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts) {
+    if (/HeadlessChrome/.test(artifacts.HostProduct)) {
+      return {
+        score: null,
+        notApplicable: true,
+        warnings: [str_(UIStrings.warningHeadless)],
+      };
+    }
+
     const failures = artifacts.BFCacheFailures;
     if (!failures.length) return {score: 1};
 

package/core/audits/byte-efficiency/byte-efficiency-audit.d.ts

@@ -33,29 +33,6 @@ export class ByteEfficiencyAudit extends Audit {
      * @return {number}
      */
     static scoreForWastedMs(wastedMs: number): number;
-    /**
-     * Estimates the number of bytes this network record would have consumed on the network based on the
-     * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
-     *
-     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-     * @param {number} totalBytes Uncompressed size of the resource
-     * @param {LH.Crdp.Network.ResourceType=} resourceType
-     * @return {number}
-     */
-    static estimateTransferSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
-    /**
-     * Estimates the number of bytes the content of this network record would have consumed on the network based on the
-     * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
-     * minus the size of the response headers.
-     *
-     * This differs from `estimateTransferSize` only in that is subtracts the response headers from the estimate.
-     *
-     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-     * @param {number} totalBytes Uncompressed size of the resource
-     * @param {LH.Crdp.Network.ResourceType=} resourceType
-     * @return {number}
-     */
-    static estimateCompressedContentSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context
@@ -112,5 +89,4 @@ export class ByteEfficiencyAudit extends Audit {
     static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): ByteEfficiencyProduct | Promise<ByteEfficiencyProduct>;
 }
 import { Audit } from '../audit.js';
-import { NetworkRequest } from '../../lib/network-request.js';
 //# sourceMappingURL=byte-efficiency-audit.d.ts.map

package/core/audits/byte-efficiency/byte-efficiency-audit.js

@@ -13,7 +13,6 @@ import {PageDependencyGraph} from '../../computed/page-dependency-graph.js';
 import {LanternLargestContentfulPaint} from '../../computed/metrics/lantern-largest-contentful-paint.js';
 import {LanternFirstContentfulPaint} from '../../computed/metrics/lantern-first-contentful-paint.js';
 import {LCPImageRecord} from '../../computed/lcp-image-record.js';
-import {NetworkRequest} from '../../lib/network-request.js';
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, {});
 
@@ -59,107 +58,6 @@ class ByteEfficiencyAudit extends Audit {
     );
   }
 
-  /**
-   * Estimates the number of bytes this network record would have consumed on the network based on the
-   * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
-   *
-   * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-   * @param {number} totalBytes Uncompressed size of the resource
-   * @param {LH.Crdp.Network.ResourceType=} resourceType
-   * @return {number}
-   */
-  static estimateTransferSize(networkRecord, totalBytes, resourceType) {
-    if (!networkRecord) {
-      // We don't know how many bytes this asset used on the network, but we can guess it was
-      // roughly the size of the content gzipped.
-      // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
-      // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
-      switch (resourceType) {
-        case 'Stylesheet':
-          // Stylesheets tend to compress extremely well.
-          return Math.round(totalBytes * 0.2);
-        case 'Script':
-        case 'Document':
-          // Scripts and HTML compress fairly well too.
-          return Math.round(totalBytes * 0.33);
-        default:
-          // Otherwise we'll just fallback to the average savings in HTTPArchive
-          return Math.round(totalBytes * 0.5);
-      }
-    } else if (networkRecord.resourceType === resourceType) {
-      // This was a regular standalone asset, just use the transfer size.
-      return networkRecord.transferSize || 0;
-    } else {
-      // This was an asset that was inlined in a different resource type (e.g. HTML document).
-      // Use the compression ratio of the resource to estimate the total transferred bytes.
-      const transferSize = networkRecord.transferSize || 0;
-      const resourceSize = networkRecord.resourceSize || 0;
-      // Get the compression ratio, if it's an invalid number, assume no compression.
-      const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ?
-        (transferSize / resourceSize) : 1;
-      return Math.round(totalBytes * compressionRatio);
-    }
-  }
-
-  /**
-   * Estimates the number of bytes the content of this network record would have consumed on the network based on the
-   * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
-   * minus the size of the response headers.
-   *
-   * This differs from `estimateTransferSize` only in that is subtracts the response headers from the estimate.
-   *
-   * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-   * @param {number} totalBytes Uncompressed size of the resource
-   * @param {LH.Crdp.Network.ResourceType=} resourceType
-   * @return {number}
-   */
-  static estimateCompressedContentSize(networkRecord, totalBytes, resourceType) {
-    if (!networkRecord) {
-      // We don't know how many bytes this asset used on the network, but we can guess it was
-      // roughly the size of the content gzipped.
-      // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
-      // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
-      switch (resourceType) {
-        case 'Stylesheet':
-          // Stylesheets tend to compress extremely well.
-          return Math.round(totalBytes * 0.2);
-        case 'Script':
-        case 'Document':
-          // Scripts and HTML compress fairly well too.
-          return Math.round(totalBytes * 0.33);
-        default:
-          // Otherwise we'll just fallback to the average savings in HTTPArchive
-          return Math.round(totalBytes * 0.5);
-      }
-    }
-
-    // Get the size of the response body on the network.
-    let contentTransferSize = networkRecord.transferSize || 0;
-    if (!NetworkRequest.isContentEncoded(networkRecord)) {
-      // This is not encoded, so we can use resourceSize directly.
-      // This would be equivalent to transfer size minus headers transfer size, but transfer size
-      // may also include bytes for SSL connection etc.
-      contentTransferSize = networkRecord.resourceSize;
-    } else if (networkRecord.responseHeadersTransferSize) {
-      // Subtract the size of the encoded headers.
-      contentTransferSize =
-        Math.max(0, contentTransferSize - networkRecord.responseHeadersTransferSize);
-    }
-
-    if (networkRecord.resourceType === resourceType) {
-      // This was a regular standalone asset, just use the transfer size.
-      return contentTransferSize;
-    } else {
-      // This was an asset that was inlined in a different resource type (e.g. HTML document).
-      // Use the compression ratio of the resource to estimate the total transferred bytes.
-      const resourceSize = networkRecord.resourceSize || 0;
-      // Get the compression ratio, if it's an invalid number, assume no compression.
-      const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ?
-        (contentTransferSize / resourceSize) : 1;
-      return Math.round(totalBytes * compressionRatio);
-    }
-  }
-
   /**
    * @param {LH.Artifacts} artifacts
    * @param {LH.Audit.Context} context

package/core/audits/byte-efficiency/duplicated-javascript.d.ts

@@ -25,12 +25,6 @@ declare class DuplicatedJavascript extends ByteEfficiencyAudit {
         scriptUrl: string;
         resourceSize: number;
     }[]>>;
-    /**
-     *
-     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-     * @param {number} contentLength
-     */
-    static _estimateTransferRatio(networkRecord: LH.Artifacts.NetworkRequest | undefined, contentLength: number): number;
     /**
      * This audit highlights JavaScript modules that appear to be duplicated across all resources,
      * either within the same bundle or between different bundles. Each details item returned is

package/core/audits/byte-efficiency/duplicated-javascript.js

@@ -11,7 +11,7 @@
 import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {ModuleDuplication} from '../../computed/module-duplication.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {getRequestForScript} from '../../lib/script-helpers.js';
+import {estimateCompressionRatioForContent} from '../../lib/script-helpers.js';
 
 const UIStrings = {
   /** Imperative title of a Lighthouse audit that tells the user to remove duplicate JavaScript from their code. This is displayed in a list of audit titles that Lighthouse generates. */
@@ -103,17 +103,6 @@ class DuplicatedJavascript extends ByteEfficiencyAudit {
     return groupedDuplication;
   }
 
-  /**
-   *
-   * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-   * @param {number} contentLength
-   */
-  static _estimateTransferRatio(networkRecord, contentLength) {
-    const transferSize =
-      ByteEfficiencyAudit.estimateTransferSize(networkRecord, contentLength, 'Script');
-    return transferSize / contentLength;
-  }
-
   /**
    * This audit highlights JavaScript modules that appear to be duplicated across all resources,
    * either within the same bundle or between different bundles. Each details item returned is
@@ -132,7 +121,7 @@ class DuplicatedJavascript extends ByteEfficiencyAudit {
       await DuplicatedJavascript._getDuplicationGroupedByNodeModules(artifacts, context);
 
     /** @type {Map<string, number>} */
-    const transferRatioByUrl = new Map();
+    const compressionRatioByUrl = new Map();
 
     /** @type {Item[]} */
     const items = [];
@@ -145,10 +134,10 @@ class DuplicatedJavascript extends ByteEfficiencyAudit {
     for (const [source, sourceDatas] of duplication.entries()) {
       // One copy of this module is treated as the canonical version - the rest will have
       // non-zero `wastedBytes`. In the case of all copies being the same version, all sizes are
-      // equal and the selection doesn't matter. When the copies are different versions, it does
-      // matter. Ideally the newest version would be the canonical copy, but version information
-      // is not present. Instead, size is used as a heuristic for latest version. This makes the
-      // audit conserative in its estimation.
+      // equal and the selection doesn't matter (ignoring compression ratios). When the copies are
+      // different versions, it does matter. Ideally the newest version would be the canonical
+      // copy, but version information is not present. Instead, size is used as a heuristic for
+      // latest version. This makes the audit conserative in its estimation.
 
       /** @type {SubItem[]} */
       const subItems = [];
@@ -159,27 +148,9 @@ class DuplicatedJavascript extends ByteEfficiencyAudit {
         const scriptId = sourceData.scriptId;
         const script = artifacts.Scripts.find(script => script.scriptId === scriptId);
         const url = script?.url || '';
-
-        /** @type {number|undefined} */
-        let transferRatio = transferRatioByUrl.get(url);
-        if (transferRatio === undefined) {
-          if (!script || script.length === undefined) {
-            // This should never happen because we found the wasted bytes from bundles, which required contents in a Script.
-            continue;
-          }
-
-          const contentLength = script.length;
-          const networkRecord = getRequestForScript(networkRecords, script);
-          transferRatio = DuplicatedJavascript._estimateTransferRatio(networkRecord, contentLength);
-          transferRatioByUrl.set(url, transferRatio);
-        }
-
-        if (transferRatio === undefined) {
-          // Shouldn't happen for above reasons.
-          continue;
-        }
-
-        const transferSize = Math.round(sourceData.resourceSize * transferRatio);
+        const compressionRatio = estimateCompressionRatioForContent(
+          compressionRatioByUrl, url, artifacts, networkRecords);
+        const transferSize = Math.round(sourceData.resourceSize * compressionRatio);
 
         subItems.push({
           url,

package/core/audits/byte-efficiency/legacy-javascript.d.ts

@@ -60,19 +60,6 @@ declare class LegacyJavascript extends ByteEfficiencyAudit {
      * @return {number}
      */
     static estimateWastedBytes(matches: PatternMatchResult[]): number;
-    /**
-     * Utility function to estimate the ratio of the compression on the resource.
-     * This excludes the size of the response headers.
-     * Also caches the calculation.
-     *
-     * Note: duplicated-javascript does this exact thing. In the future, consider
-     * making a generic estimator on ByteEfficiencyAudit.
-     * @param {Map<string, number>} compressionRatioByUrl
-     * @param {string} url
-     * @param {LH.Artifacts} artifacts
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     */
-    static estimateCompressionRatioForContent(compressionRatioByUrl: Map<string, number>, url: string, artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<number>;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords

package/core/audits/byte-efficiency/legacy-javascript.js

@@ -24,7 +24,7 @@ import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {EntityClassification} from '../../computed/entity-classification.js';
 import {JSBundles} from '../../computed/js-bundles.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {getRequestForScript} from '../../lib/script-helpers.js';
+import {estimateCompressionRatioForContent} from '../../lib/script-helpers.js';
 import {LH_ROOT} from '../../../shared/root.js';
 
 const graphJson = fs.readFileSync(
@@ -390,40 +390,6 @@ class LegacyJavascript extends ByteEfficiencyAudit {
     return estimatedWastedBytes;
   }
 
-  /**
-   * Utility function to estimate the ratio of the compression on the resource.
-   * This excludes the size of the response headers.
-   * Also caches the calculation.
-   *
-   * Note: duplicated-javascript does this exact thing. In the future, consider
-   * making a generic estimator on ByteEfficiencyAudit.
-   * @param {Map<string, number>} compressionRatioByUrl
-   * @param {string} url
-   * @param {LH.Artifacts} artifacts
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   */
-  static async estimateCompressionRatioForContent(compressionRatioByUrl, url,
-      artifacts, networkRecords) {
-    let compressionRatio = compressionRatioByUrl.get(url);
-    if (compressionRatio !== undefined) return compressionRatio;
-
-    const script = artifacts.Scripts.find(script => script.url === url);
-
-    if (!script) {
-      // Can't find content, so just use 1.
-      compressionRatio = 1;
-    } else {
-      const networkRecord = getRequestForScript(networkRecords, script);
-      const contentLength = networkRecord?.resourceSize || script.length || 0;
-      const compressedSize =
-        ByteEfficiencyAudit.estimateCompressedContentSize(networkRecord, contentLength, 'Script');
-      compressionRatio = compressedSize / contentLength;
-    }
-
-    compressionRatioByUrl.set(url, compressionRatio);
-    return compressionRatio;
-  }
-
   /**
    * @param {LH.Artifacts} artifacts
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
@@ -451,7 +417,7 @@ class LegacyJavascript extends ByteEfficiencyAudit {
     const scriptToMatchResults =
       this.detectAcrossScripts(matcher, artifacts.Scripts, networkRecords, bundles);
     for (const [script, matches] of scriptToMatchResults.entries()) {
-      const compressionRatio = await this.estimateCompressionRatioForContent(
+      const compressionRatio = estimateCompressionRatioForContent(
         compressionRatioByUrl, script.url, artifacts, networkRecords);
       const wastedBytes = Math.round(this.estimateWastedBytes(matches) * compressionRatio);
       /** @type {typeof items[number]} */

package/core/audits/byte-efficiency/unminified-css.js

@@ -8,6 +8,7 @@ import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {UnusedCSS} from '../../computed/unused-css.js';
 import * as i18n from '../../lib/i18n/i18n.js';
 import {computeCSSTokenLength as computeTokenLength} from '../../lib/minification-estimator.js';
+import {estimateTransferSize} from '../../lib/script-helpers.js';
 
 const UIStrings = {
   /** Imperative title of a Lighthouse audit that tells the user to minify (remove whitespace) the page's CSS code. This is displayed in a list of audit titles that Lighthouse generates. */
@@ -65,8 +66,7 @@ class UnminifiedCSS extends ByteEfficiencyAudit {
       url = contentPreview;
     }
 
-    const totalBytes = ByteEfficiencyAudit.estimateTransferSize(networkRecord, content.length,
-      'Stylesheet');
+    const totalBytes = estimateTransferSize(networkRecord, content.length, 'Stylesheet');
     const wastedRatio = 1 - totalTokenLength / content.length;
     const wastedBytes = Math.round(totalBytes * wastedRatio);
 

package/core/audits/byte-efficiency/unminified-javascript.js

@@ -7,7 +7,7 @@
 import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import * as i18n from '../../lib/i18n/i18n.js';
 import {computeJSTokenLength as computeTokenLength} from '../../lib/minification-estimator.js';
-import {getRequestForScript, isInline} from '../../lib/script-helpers.js';
+import {estimateCompressedContentSize, getRequestForScript, isInline} from '../../lib/script-helpers.js';
 import {Util} from '../../../shared/util.js';
 
 const UIStrings = {
@@ -58,8 +58,7 @@ class UnminifiedJavaScript extends ByteEfficiencyAudit {
     const contentLength = scriptContent.length;
     const totalTokenLength = computeTokenLength(scriptContent);
 
-    const totalBytes = ByteEfficiencyAudit.estimateTransferSize(networkRecord, contentLength,
-      'Script');
+    const totalBytes = estimateCompressedContentSize(networkRecord, contentLength, 'Script');
     const wastedRatio = 1 - totalTokenLength / contentLength;
     const wastedBytes = Math.round(totalBytes * wastedRatio);
 

package/core/audits/byte-efficiency/unused-javascript.js

@@ -8,7 +8,7 @@ import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {UnusedJavascriptSummary} from '../../computed/unused-javascript-summary.js';
 import {JSBundles} from '../../computed/js-bundles.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {getRequestForScript} from '../../lib/script-helpers.js';
+import {estimateCompressionRatioForContent} from '../../lib/script-helpers.js';
 
 const UIStrings = {
   /** Imperative title of a Lighthouse audit that tells the user to reduce JavaScript that is never evaluated during page load. This is displayed in a list of audit titles that Lighthouse generates. */
@@ -86,27 +86,26 @@ class UnusedJavaScript extends ByteEfficiencyAudit {
       bundleSourceUnusedThreshold = UNUSED_BYTES_IGNORE_BUNDLE_SOURCE_THRESHOLD,
     } = context.options || {};
 
+    /** @type {Map<string, number>} */
+    const compressionRatioByUrl = new Map();
+
     const items = [];
     for (const [scriptId, scriptCoverage] of Object.entries(artifacts.JsUsage)) {
       const script = artifacts.Scripts.find(s => s.scriptId === scriptId);
       if (!script) continue; // This should never happen.
 
-      const networkRecord = getRequestForScript(networkRecords, script);
-      if (!networkRecord) continue;
-
       const bundle = bundles.find(b => b.script.scriptId === scriptId);
       const unusedJsSummary =
         await UnusedJavascriptSummary.request({scriptId, scriptCoverage, bundle}, context);
       if (unusedJsSummary.wastedBytes === 0 || unusedJsSummary.totalBytes === 0) continue;
 
-      const transfer = ByteEfficiencyAudit
-        .estimateTransferSize(networkRecord, unusedJsSummary.totalBytes, 'Script');
-      const transferRatio = transfer / unusedJsSummary.totalBytes;
+      const compressionRatio = estimateCompressionRatioForContent(
+        compressionRatioByUrl, script.url, artifacts, networkRecords);
       /** @type {LH.Audit.ByteEfficiencyItem} */
       const item = {
         url: script.url,
-        totalBytes: Math.round(transferRatio * unusedJsSummary.totalBytes),
-        wastedBytes: Math.round(transferRatio * unusedJsSummary.wastedBytes),
+        totalBytes: Math.round(compressionRatio * unusedJsSummary.totalBytes),
+        wastedBytes: Math.round(compressionRatio * unusedJsSummary.wastedBytes),
         wastedPercent: unusedJsSummary.wastedPercent,
       };
 
@@ -127,8 +126,8 @@ class UnusedJavaScript extends ByteEfficiencyAudit {
             const total = source === '(unmapped)' ? sizes.unmappedBytes : sizes.files[source];
             return {
               source,
-              unused: Math.round(unused * transferRatio),
-              total: Math.round(total * transferRatio),
+              unused: Math.round(unused * compressionRatio),
+              total: Math.round(total * compressionRatio),
             };
           })
           .filter(d => d.unused >= bundleSourceUnusedThreshold);

package/core/audits/resource-summary.d.ts

@@ -0,0 +1,11 @@
+export default ResourceSummary;
+declare class ResourceSummary extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=resource-summary.d.ts.map

package/core/audits/resource-summary.js

@@ -0,0 +1,86 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * 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 {Audit} from './audit.js';
+import {ResourceSummary as ComputedResourceSummary} from '../computed/resource-summary.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+const str_ = i18n.createIcuMessageFn(import.meta.url);
+
+class ResourceSummary extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'resource-summary',
+      title: 'Resources Summary',
+      description: 'Aggregates all network requests and groups them by type',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['devtoolsLogs', 'URL'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const summary = await ComputedResourceSummary
+      .request({devtoolsLog, URL: artifacts.URL, budgets: context.settings.budgets}, context);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'label', valueType: 'text', label: str_(i18n.UIStrings.columnResourceType)},
+      {key: 'requestCount', valueType: 'numeric', label: str_(i18n.UIStrings.columnRequests)},
+      {key: 'transferSize', valueType: 'bytes', label: str_(i18n.UIStrings.columnTransferSize)},
+    ];
+
+
+    /** @type {Record<LH.Budget.ResourceType, LH.IcuMessage>} */
+    const strMappings = {
+      'total': str_(i18n.UIStrings.totalResourceType),
+      'document': str_(i18n.UIStrings.documentResourceType),
+      'script': str_(i18n.UIStrings.scriptResourceType),
+      'stylesheet': str_(i18n.UIStrings.stylesheetResourceType),
+      'image': str_(i18n.UIStrings.imageResourceType),
+      'media': str_(i18n.UIStrings.mediaResourceType),
+      'font': str_(i18n.UIStrings.fontResourceType),
+      'other': str_(i18n.UIStrings.otherResourceType),
+      'third-party': str_(i18n.UIStrings.thirdPartyResourceType),
+    };
+
+    const types = /** @type {Array<LH.Budget.ResourceType>} */ (Object.keys(summary));
+    const rows = types.map(type => {
+      return {
+        // ResourceType is included as an "id" for ease of use.
+        // It does not appear directly in the table.
+        resourceType: type,
+        label: strMappings[type],
+        requestCount: summary[type].count,
+        transferSize: summary[type].transferSize,
+      };
+    });
+    // Force third-party to be last, descending by size otherwise
+    const thirdPartyRow = rows.find(r => r.resourceType === 'third-party') || [];
+    const otherRows = rows.filter(r => r.resourceType !== 'third-party')
+      .sort((a, b) => {
+        return b.transferSize - a.transferSize;
+      });
+    const tableItems = otherRows.concat(thirdPartyRow);
+
+    const tableDetails = Audit.makeTableDetails(headings, tableItems);
+
+    return {
+      details: tableDetails,
+      score: null,
+    };
+  }
+}
+
+export default ResourceSummary;

package/core/computed/unused-css.js

@@ -5,9 +5,9 @@
  */
 
 import {makeComputedArtifact} from './computed-artifact.js';
-import {ByteEfficiencyAudit} from '../audits/byte-efficiency/byte-efficiency-audit.js';
 import {NetworkRecords} from './network-records.js';
 import {Util} from '../../shared/util.js';
+import {estimateTransferSize} from '../lib/script-helpers.js';
 
 const PREVIEW_LENGTH = 100;
 
@@ -70,7 +70,7 @@ class UnusedCSS {
       usedUncompressedBytes += usedRule.endOffset - usedRule.startOffset;
     }
 
-    const totalTransferredBytes = ByteEfficiencyAudit.estimateTransferSize(
+    const totalTransferredBytes = estimateTransferSize(
         stylesheetInfo.networkRecord, totalUncompressedBytes, 'Stylesheet');
     const percentUnused = (totalUncompressedBytes - usedUncompressedBytes) / totalUncompressedBytes;
     const wastedBytes = Math.round(percentUnused * totalTransferredBytes);

package/core/config/default-config.js

@@ -215,6 +215,7 @@ const defaultConfig = {
     'metrics',
     'performance-budget',
     'timing-budget',
+    'resource-summary',
     'third-party-summary',
     'third-party-facades',
     'largest-contentful-paint-element',
@@ -499,6 +500,7 @@ const defaultConfig = {
         {id: 'screenshot-thumbnails', weight: 0, group: 'hidden'},
         {id: 'final-screenshot', weight: 0, group: 'hidden'},
         {id: 'script-treemap-data', weight: 0, group: 'hidden'},
+        {id: 'resource-summary', weight: 0, group: 'hidden'},
       ],
     },
     'accessibility': {

package/core/config/filters.js

@@ -20,6 +20,7 @@ const baseArtifactKeySource = {
   PageLoadError: '',
   HostFormFactor: '',
   HostUserAgent: '',
+  HostProduct: '',
   GatherContext: '',
 };
 

package/core/gather/base-artifacts.js

@@ -19,7 +19,7 @@ import {
  */
 async function getBaseArtifacts(resolvedConfig, driver, context) {
   const BenchmarkIndex = await getBenchmarkIndex(driver.executionContext);
-  const {userAgent} = await getBrowserVersion(driver.defaultSession);
+  const {userAgent, product} = await getBrowserVersion(driver.defaultSession);
 
   return {
     // Meta artifacts.
@@ -32,6 +32,7 @@ async function getBaseArtifacts(resolvedConfig, driver, context) {
     HostUserAgent: userAgent,
     HostFormFactor: userAgent.includes('Android') || userAgent.includes('Mobile') ?
       'mobile' : 'desktop',
+    HostProduct: product,
     // Contextual artifacts whose collection changes based on gather mode.
     URL: {
       finalDisplayedUrl: '',

package/core/lib/i18n/i18n.d.ts

@@ -69,9 +69,9 @@ export function lookupLocale(locales?: (string | string[]) | undefined, possible
  * Returns a function that generates `LH.IcuMessage` objects to localize the
  * messages in `fileStrings` and the shared `i18n.UIStrings`.
  * @param {string} filename
- * @param {Record<string, string>} fileStrings
+ * @param {Record<string, string>=} fileStrings
  */
-export function createIcuMessageFn(filename: string, fileStrings: Record<string, string>): (message: string, values?: Record<string, string | number> | undefined) => LH.IcuMessage;
+export function createIcuMessageFn(filename: string, fileStrings?: Record<string, string> | undefined): (message: string, values?: Record<string, string | number> | undefined) => LH.IcuMessage;
 /**
  * Returns true if the given value is a string or an LH.IcuMessage.
  * @param {unknown} value

package/core/lib/i18n/i18n.js

@@ -168,9 +168,9 @@ function lookupLocale(locales, possibleLocales) {
  * Returns a function that generates `LH.IcuMessage` objects to localize the
  * messages in `fileStrings` and the shared `i18n.UIStrings`.
  * @param {string} filename
- * @param {Record<string, string>} fileStrings
+ * @param {Record<string, string>=} fileStrings
  */
-function createIcuMessageFn(filename, fileStrings) {
+function createIcuMessageFn(filename, fileStrings = {}) {
   if (filename.startsWith('file://')) filename = url.fileURLToPath(filename);
 
   // In the common case, `filename` is an absolute path that needs to be transformed