lighthouse 9.5.0-dev.20230122 → 9.5.0-dev.20230124

package/.codecov.yml

@@ -20,8 +20,3 @@ coverage:
     patch:
       default:
         if_not_found: success
-
-# docs:
-#   https://docs.codecov.com/docs/ignoring-paths
-ignore:
-- "core/util.cjs" # file is a copy of report/renderer/util.js

package/core/audits/audit.js

@@ -7,7 +7,7 @@
 import * as LH from '../../types/lh.js';
 import {isUnderTest} from '../lib/lh-env.js';
 import * as statistics from '../lib/statistics.js';
-import {Util} from '../util.cjs';
+import {Util} from '../../shared/util.js';
 
 const DEFAULT_PASS = 'defaultPass';
 

package/core/audits/bf-cache.js

@@ -15,7 +15,7 @@ const UIStrings = {
   /** Title of a diagnostic Lighthouse audit that identifies when the back/forward cache is being used. "back/forward" refers to the back and forward buttons found in modern browsers. This title is shown to users if the page attempted to restore from the back/forward cache but the back/forward cache was not used. */
   failureTitle: 'Page prevented back/forward cache restoration',
   /** Description of a diagnostic Lighthouse audit that identifies when the back/forward cache is being used. "back/forward" refers to the back and forward buttons found in modern browsers. */
-  description: 'Many navigations are performed by going back to a previous page, or forwards again. The back/forward cache (bfcache) can speed up these return navigations. [Learn more about the bfcache](https://web.dev/bfcache/)',
+  description: 'Many navigations are performed by going back to a previous page, or forwards again. The back/forward cache (bfcache) can speed up these return navigations. [Learn more about the bfcache](https://developer.chrome.com/docs/lighthouse/performance/bf-cache/)',
   /** Failure type for an error that the user should be able to address themselves. Shown in a table column with other failure types. */
   actionableFailureType: 'Actionable',
   /** Failure type for an error that the user cannot address in the page's code. Shown in a table column with other failure types. */

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

@@ -78,6 +78,7 @@ export namespace UIStrings {
     const title: string;
     const description: string;
 }
+import { Audit } from "../audit.js";
 import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
 /**
  * Takes a list of patterns (consisting of a name identifier and a RegExp expression string)

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

@@ -19,10 +19,11 @@
 
 import fs from 'fs';
 
+import {Audit} from '../audit.js';
 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 thirdPartyWeb from '../../lib/third-party-web.js';
 import {getRequestForScript} from '../../lib/script-helpers.js';
 import {LH_ROOT} from '../../../root.js';
 
@@ -401,7 +402,10 @@ class LegacyJavascript extends ByteEfficiencyAudit {
    * @return {Promise<ByteEfficiencyProduct>}
    */
   static async audit_(artifacts, networkRecords, context) {
-    const mainDocumentEntity = thirdPartyWeb.getEntity(artifacts.URL.finalDisplayedUrl);
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const classifiedEntities = await EntityClassification.request(
+      {URL: artifacts.URL, devtoolsLog}, context);
+
     const bundles = await JSBundles.request(artifacts, context);
 
     /** @type {Item[]} */
@@ -450,7 +454,7 @@ class LegacyJavascript extends ByteEfficiencyAudit {
     const wastedBytesByUrl = new Map();
     for (const item of items) {
       // Only estimate savings if first party code has legacy code.
-      if (thirdPartyWeb.isFirstParty(item.url, mainDocumentEntity)) {
+      if (classifiedEntities.isFirstParty(item.url)) {
         wastedBytesByUrl.set(item.url, item.wastedBytes);
       }
     }

package/core/audits/dobetterweb/uses-http2.d.ts

@@ -22,9 +22,10 @@ declare class UsesHTTP2Audit extends Audit {
      * for the same origin at the exact same time.
      *
      * @param {LH.Artifacts.NetworkRequest} networkRequest
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
      * @return {boolean}
      */
-    static isStaticAsset(networkRequest: LH.Artifacts.NetworkRequest): boolean;
+    static isStaticAsset(networkRequest: LH.Artifacts.NetworkRequest, classifiedEntities: LH.Artifacts.EntityClassification): boolean;
     /**
      * Determine the set of resources that aren't HTTP/2 but should be.
      * We're a little conservative about what we surface for a few reasons:
@@ -45,9 +46,10 @@ declare class UsesHTTP2Audit extends Audit {
      *      https://www.cachefly.com/http-2-is-not-a-magic-bullet/
      *
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
      * @return {Array<{url: string, protocol: string}>}
      */
-    static determineNonHttp2Resources(networkRecords: Array<LH.Artifacts.NetworkRequest>): Array<{
+    static determineNonHttp2Resources(networkRecords: Array<LH.Artifacts.NetworkRequest>, classifiedEntities: LH.Artifacts.EntityClassification): Array<{
         url: string;
         protocol: string;
     }>;
@@ -66,4 +68,5 @@ export namespace UIStrings {
 }
 import { Audit } from "../audit.js";
 import { NetworkRequest } from "../../lib/network-request.js";
+import { EntityClassification } from "../../computed/entity-classification.js";
 //# sourceMappingURL=uses-http2.d.ts.map

package/core/audits/dobetterweb/uses-http2.js

@@ -13,7 +13,7 @@
 /** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
 
 import {Audit} from '../audit.js';
-import ThirdParty from '../../lib/third-party-web.js';
+import {EntityClassification} from '../../computed/entity-classification.js';
 import UrlUtils from '../../lib/url-utils.js';
 import {ByteEfficiencyAudit} from '../byte-efficiency/byte-efficiency-audit.js';
 import {LanternInteractive} from '../../computed/metrics/lantern-interactive.js';
@@ -120,16 +120,19 @@ class UsesHTTP2Audit extends Audit {
    * for the same origin at the exact same time.
    *
    * @param {LH.Artifacts.NetworkRequest} networkRequest
+   * @param {LH.Artifacts.EntityClassification} classifiedEntities
    * @return {boolean}
    */
-  static isStaticAsset(networkRequest) {
+  static isStaticAsset(networkRequest, classifiedEntities) {
     if (!STATIC_RESOURCE_TYPES.has(networkRequest.resourceType)) return false;
 
     // Resources from third-parties that are less than 100 bytes are usually tracking pixels, not actual resources.
     // They can masquerade as static types though (gifs, documents, etc)
     if (networkRequest.resourceSize < 100) {
-      const entity = ThirdParty.getEntity(networkRequest.url);
-      if (entity) return false;
+      // This logic needs to be revisited.
+      // See https://github.com/GoogleChrome/lighthouse/issues/14661
+      const entity = classifiedEntities.entityByUrl.get(networkRequest.url);
+      if (entity && !entity.isUnrecognized) return false;
     }
 
     return true;
@@ -155,9 +158,10 @@ class UsesHTTP2Audit extends Audit {
    *      https://www.cachefly.com/http-2-is-not-a-magic-bullet/
    *
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+   * @param {LH.Artifacts.EntityClassification} classifiedEntities
    * @return {Array<{url: string, protocol: string}>}
    */
-  static determineNonHttp2Resources(networkRecords) {
+  static determineNonHttp2Resources(networkRecords, classifiedEntities) {
     /** @type {Array<{url: string, protocol: string}>} */
     const nonHttp2Resources = [];
 
@@ -166,7 +170,7 @@ class UsesHTTP2Audit extends Audit {
     /** @type {Map<string, Array<LH.Artifacts.NetworkRequest>>} */
     const groupedByOrigin = new Map();
     for (const record of networkRecords) {
-      if (!UsesHTTP2Audit.isStaticAsset(record)) continue;
+      if (!UsesHTTP2Audit.isStaticAsset(record, classifiedEntities)) continue;
       if (UrlUtils.isLikeLocalhost(record.parsedURL.host)) continue;
       const existing = groupedByOrigin.get(record.parsedURL.securityOrigin) || [];
       existing.push(record);
@@ -203,7 +207,8 @@ class UsesHTTP2Audit extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const resources = UsesHTTP2Audit.determineNonHttp2Resources(networkRecords);
+    const classifiedEntities = await EntityClassification.request({URL, devtoolsLog}, context);
+    const resources = UsesHTTP2Audit.determineNonHttp2Resources(networkRecords, classifiedEntities);
 
     let displayValue;
     if (resources.length > 0) {

package/core/audits/screenshot-thumbnails.d.ts

@@ -7,9 +7,10 @@ declare class ScreenshotThumbnails extends Audit {
      * ratio of the original thumbnail.
      *
      * @param {ReturnType<SpeedlineFrame['getParsedImage']>} imageData
+     * @param {number} scaledWidth
      * @return {{width: number, height: number, data: Uint8Array}}
      */
-    static scaleImageToThumbnail(imageData: ReturnType<SpeedlineFrame['getParsedImage']>): {
+    static scaleImageToThumbnail(imageData: ReturnType<SpeedlineFrame['getParsedImage']>, scaledWidth: number): {
         width: number;
         height: number;
         data: Uint8Array;

package/core/audits/screenshot-thumbnails.js

@@ -10,8 +10,7 @@ import {Audit} from './audit.js';
 import {LighthouseError} from '../lib/lh-error.js';
 import {Speedline} from '../computed/speedline.js';
 
-const NUMBER_OF_THUMBNAILS = 10;
-const THUMBNAIL_WIDTH = 120;
+const NUMBER_OF_THUMBNAILS = 8;
 
 /** @typedef {LH.Artifacts.Speedline['frames'][0]} SpeedlineFrame */
 
@@ -34,10 +33,10 @@ class ScreenshotThumbnails extends Audit {
    * ratio of the original thumbnail.
    *
    * @param {ReturnType<SpeedlineFrame['getParsedImage']>} imageData
+   * @param {number} scaledWidth
    * @return {{width: number, height: number, data: Uint8Array}}
    */
-  static scaleImageToThumbnail(imageData) {
-    const scaledWidth = THUMBNAIL_WIDTH;
+  static scaleImageToThumbnail(imageData, scaledWidth) {
     const scaleFactor = imageData.width / scaledWidth;
     const scaledHeight = Math.floor(imageData.height / scaleFactor);
 
@@ -79,6 +78,8 @@ class ScreenshotThumbnails extends Audit {
 
     // Make the minimum time range 3s so sites that load super quickly don't get a single screenshot
     const minimumTimelineDuration = context.options.minimumTimelineDuration || 3000;
+    const numberOfThumbnails = context.options.numberOfThumbnails || NUMBER_OF_THUMBNAILS;
+    const thumbnailWidth = context.options.thumbnailWidth || null;
 
     const thumbnails = [];
     const analyzedFrames = speedline.frames.filter(frame => !frame.isProgressInterpolated());
@@ -91,13 +92,13 @@ class ScreenshotThumbnails extends Audit {
       throw new LighthouseError(LighthouseError.errors.INVALID_SPEEDLINE);
     }
 
-    for (let i = 1; i <= NUMBER_OF_THUMBNAILS; i++) {
-      const targetTimestamp = speedline.beginning + timelineEnd * i / NUMBER_OF_THUMBNAILS;
+    for (let i = 1; i <= numberOfThumbnails; i++) {
+      const targetTimestamp = speedline.beginning + timelineEnd * i / numberOfThumbnails;
 
       /** @type {SpeedlineFrame} */
       // @ts-expect-error - there will always be at least one frame by this point. TODO: use nonnullable assertion in TS2.9
       let frameForTimestamp = null;
-      if (i === NUMBER_OF_THUMBNAILS) {
+      if (i === numberOfThumbnails) {
         frameForTimestamp = analyzedFrames[analyzedFrames.length - 1];
       } else {
         analyzedFrames.forEach(frame => {
@@ -111,11 +112,15 @@ class ScreenshotThumbnails extends Audit {
       const cachedThumbnail = cachedThumbnails.get(frameForTimestamp);
       if (cachedThumbnail) {
         base64Data = cachedThumbnail;
-      } else {
+      } else if (thumbnailWidth !== null) {
         const imageData = frameForTimestamp.getParsedImage();
-        const thumbnailImageData = ScreenshotThumbnails.scaleImageToThumbnail(imageData);
+        const thumbnailImageData =
+          ScreenshotThumbnails.scaleImageToThumbnail(imageData, thumbnailWidth);
         base64Data = jpeg.encode(thumbnailImageData, 90).data.toString('base64');
         cachedThumbnails.set(frameForTimestamp, base64Data);
+      } else {
+        base64Data = frameForTimestamp.getImage().toString('base64');
+        cachedThumbnails.set(frameForTimestamp, base64Data);
       }
       thumbnails.push({
         timing: Math.round(targetTimestamp - speedline.beginning),

package/core/audits/third-party-facades.d.ts

@@ -15,10 +15,10 @@ declare class ThirdPartyFacades extends Audit {
     static condenseItems(items: import('./third-party-summary.js').URLSummary[]): void;
     /**
      * @param {Map<string, import('./third-party-summary.js').Summary>} byURL
-     * @param {ThirdPartyEntity | undefined} mainEntity
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
      * @return {FacadableProduct[]}
      */
-    static getProductsWithFacade(byURL: Map<string, import('./third-party-summary.js').Summary>, mainEntity: ThirdPartyEntity | undefined): FacadableProduct[];
+    static getProductsWithFacade(byURL: Map<string, import('./third-party-summary.js').Summary>, classifiedEntities: LH.Artifacts.EntityClassification): FacadableProduct[];
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context
@@ -38,4 +38,5 @@ export namespace UIStrings {
     const categorySocial: string;
 }
 import { Audit } from "./audit.js";
+import { EntityClassification } from "../computed/entity-classification.js";
 //# sourceMappingURL=third-party-facades.d.ts.map

package/core/audits/third-party-facades.js

@@ -21,9 +21,9 @@
 
 import {Audit} from './audit.js';
 import * as i18n from '../lib/i18n/i18n.js';
+import {EntityClassification} from '../computed/entity-classification.js';
 import thirdPartyWeb from '../lib/third-party-web.js';
 import {NetworkRecords} from '../computed/network-records.js';
-import {MainResource} from '../computed/main-resource.js';
 import {MainThreadTasks} from '../computed/main-thread-tasks.js';
 import ThirdPartySummary from './third-party-summary.js';
 
@@ -121,15 +121,15 @@ class ThirdPartyFacades extends Audit {
 
   /**
    * @param {Map<string, import('./third-party-summary.js').Summary>} byURL
-   * @param {ThirdPartyEntity | undefined} mainEntity
+   * @param {LH.Artifacts.EntityClassification} classifiedEntities
    * @return {FacadableProduct[]}
    */
-  static getProductsWithFacade(byURL, mainEntity) {
+  static getProductsWithFacade(byURL, classifiedEntities) {
     /** @type {Map<string, FacadableProduct>} */
     const facadableProductMap = new Map();
     for (const url of byURL.keys()) {
-      const entity = thirdPartyWeb.getEntity(url);
-      if (!entity || thirdPartyWeb.isFirstParty(url, mainEntity)) continue;
+      const entity = classifiedEntities.entityByUrl.get(url);
+      if (!entity || classifiedEntities.isFirstParty(url)) continue;
 
       const product = thirdPartyWeb.getProduct(url);
       if (!product || !product.facades || !product.facades.length) continue;
@@ -151,14 +151,15 @@ class ThirdPartyFacades extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
-    const mainEntity = thirdPartyWeb.getEntity(mainResource.url);
+    const classifiedEntities = await EntityClassification.request(
+      {URL: artifacts.URL, devtoolsLog}, context);
     const tasks = await MainThreadTasks.request(trace, context);
     const multiplier = settings.throttlingMethod === 'simulate' ?
       settings.throttling.cpuSlowdownMultiplier : 1;
-    const summaries = ThirdPartySummary.getSummaries(networkRecords, tasks, multiplier);
+    const summaries = ThirdPartySummary.getSummaries(networkRecords, tasks, multiplier,
+      classifiedEntities);
     const facadableProducts =
-      ThirdPartyFacades.getProductsWithFacade(summaries.byURL, mainEntity);
+      ThirdPartyFacades.getProductsWithFacade(summaries.byURL, classifiedEntities);
 
     /** @type {LH.Audit.Details.TableItem[]} */
     const results = [];
@@ -188,6 +189,8 @@ class ThirdPartyFacades extends Audit {
         transferSize: entitySummary.transferSize,
         blockingTime: entitySummary.blockingTime,
         subItems: {type: 'subitems', items},
+        // Add entity manually since facades don't have a single `url`.
+        entity: entity.name,
       });
     }
 

package/core/audits/third-party-summary.d.ts

@@ -1,5 +1,4 @@
 export default ThirdPartySummary;
-export type ThirdPartyEntity = import("third-party-web").IEntity;
 export type Summary = {
     mainThreadTime: number;
     transferSize: number;
@@ -14,7 +13,7 @@ export type SummaryMaps = {
     /**
      * Map of impact summaries for each entity.
      */
-    byEntity: Map<ThirdPartyEntity, Summary>;
+    byEntity: Map<LH.Artifacts.Entity, Summary>;
     /**
      * Map of impact summaries for each URL.
      */
@@ -22,7 +21,7 @@ export type SummaryMaps = {
     /**
      * Map of URLs under each entity.
      */
-    urls: Map<ThirdPartyEntity, string[]>;
+    urls: Map<LH.Artifacts.Entity, string[]>;
 };
 declare class ThirdPartySummary extends Audit {
     /**
@@ -30,16 +29,17 @@ declare class ThirdPartySummary extends Audit {
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
      * @param {Array<LH.Artifacts.TaskNode>} mainThreadTasks
      * @param {number} cpuMultiplier
+     * @param {LH.Artifacts.EntityClassification} entityClassification
      * @return {SummaryMaps}
      */
-    static getSummaries(networkRecords: Array<LH.Artifacts.NetworkRequest>, mainThreadTasks: Array<LH.Artifacts.TaskNode>, cpuMultiplier: number): SummaryMaps;
+    static getSummaries(networkRecords: Array<LH.Artifacts.NetworkRequest>, mainThreadTasks: Array<LH.Artifacts.TaskNode>, cpuMultiplier: number, entityClassification: LH.Artifacts.EntityClassification): SummaryMaps;
     /**
-     * @param {ThirdPartyEntity} entity
+     * @param {LH.Artifacts.Entity} entity
      * @param {SummaryMaps} summaries
      * @param {Summary} stats
      * @return {Array<URLSummary>}
      */
-    static makeSubItems(entity: ThirdPartyEntity, summaries: SummaryMaps, stats: Summary): Array<URLSummary>;
+    static makeSubItems(entity: LH.Artifacts.Entity, summaries: SummaryMaps, stats: Summary): Array<URLSummary>;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context
@@ -55,4 +55,5 @@ export namespace UIStrings {
     const displayValue: string;
 }
 import { Audit } from "./audit.js";
+import { EntityClassification } from "../computed/entity-classification.js";
 //# sourceMappingURL=third-party-summary.d.ts.map

package/core/audits/third-party-summary.js

@@ -5,8 +5,8 @@
  */
 
 import {Audit} from './audit.js';
+import {EntityClassification} from '../computed/entity-classification.js';
 import * as i18n from '../lib/i18n/i18n.js';
-import thirdPartyWeb from '../lib/third-party-web.js';
 import {NetworkRecords} from '../computed/network-records.js';
 import {MainThreadTasks} from '../computed/main-thread-tasks.js';
 import {getJavaScriptURLs, getAttributableURLForTask} from '../lib/tracehouse/task-summary.js';
@@ -33,8 +33,6 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 // A page passes when all third-party code blocks for less than 250 ms.
 const PASS_THRESHOLD_IN_MS = 250;
 
-/** @typedef {import("third-party-web").IEntity} ThirdPartyEntity */
-
 /**
  * @typedef Summary
  * @property {number} mainThreadTime
@@ -50,9 +48,9 @@ const PASS_THRESHOLD_IN_MS = 250;
  */
 
 /** @typedef SummaryMaps
- * @property {Map<ThirdPartyEntity, Summary>} byEntity Map of impact summaries for each entity.
+ * @property {Map<LH.Artifacts.Entity, Summary>} byEntity Map of impact summaries for each entity.
  * @property {Map<string, Summary>} byURL Map of impact summaries for each URL.
- * @property {Map<ThirdPartyEntity, string[]>} urls Map of URLs under each entity.
+ * @property {Map<LH.Artifacts.Entity, string[]>} urls Map of URLs under each entity.
  */
 
 /**
@@ -83,12 +81,13 @@ class ThirdPartySummary extends Audit {
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
    * @param {Array<LH.Artifacts.TaskNode>} mainThreadTasks
    * @param {number} cpuMultiplier
+   * @param {LH.Artifacts.EntityClassification} entityClassification
    * @return {SummaryMaps}
    */
-  static getSummaries(networkRecords, mainThreadTasks, cpuMultiplier) {
+  static getSummaries(networkRecords, mainThreadTasks, cpuMultiplier, entityClassification) {
     /** @type {Map<string, Summary>} */
     const byURL = new Map();
-    /** @type {Map<ThirdPartyEntity, Summary>} */
+    /** @type {Map<LH.Artifacts.Entity, Summary>} */
     const byEntity = new Map();
     const defaultSummary = {mainThreadTime: 0, blockingTime: 0, transferSize: 0};
 
@@ -114,11 +113,11 @@ class ThirdPartySummary extends Audit {
       byURL.set(attributableURL, urlSummary);
     }
 
-    // Map each URL's stat to a particular third party entity.
-    /** @type {Map<ThirdPartyEntity, string[]>} */
+    // Map each URL's stat to a particular entity.
+    /** @type {Map<LH.Artifacts.Entity, string[]>} */
     const urls = new Map();
     for (const [url, urlSummary] of byURL.entries()) {
-      const entity = thirdPartyWeb.getEntity(url);
+      const entity = entityClassification.entityByUrl.get(url);
       if (!entity) {
         byURL.delete(url);
         continue;
@@ -139,7 +138,7 @@ class ThirdPartySummary extends Audit {
   }
 
   /**
-   * @param {ThirdPartyEntity} entity
+   * @param {LH.Artifacts.Entity} entity
    * @param {SummaryMaps} summaries
    * @param {Summary} stats
    * @return {Array<URLSummary>}
@@ -197,18 +196,21 @@ class ThirdPartySummary extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const mainEntity = thirdPartyWeb.getEntity(artifacts.URL.finalDisplayedUrl);
+    const classifiedEntities = await EntityClassification.request(
+      {URL: artifacts.URL, devtoolsLog}, context);
+    const firstPartyEntity = classifiedEntities.firstParty;
     const tasks = await MainThreadTasks.request(trace, context);
     const multiplier = settings.throttlingMethod === 'simulate' ?
       settings.throttling.cpuSlowdownMultiplier : 1;
 
-    const summaries = ThirdPartySummary.getSummaries(networkRecords, tasks, multiplier);
+    const summaries = ThirdPartySummary.getSummaries(
+      networkRecords, tasks, multiplier, classifiedEntities);
     const overallSummary = {wastedBytes: 0, wastedMs: 0};
 
     const results = Array.from(summaries.byEntity.entries())
       // Don't consider the page we're on to be third-party.
       // e.g. Facebook SDK isn't a third-party script on facebook.com
-      .filter(([entity]) => !(mainEntity && mainEntity.name === entity.name))
+      .filter(([entity]) => !(firstPartyEntity && firstPartyEntity === entity))
       .map(([entity, stats]) => {
         overallSummary.wastedBytes += stats.transferSize;
         overallSummary.wastedMs += stats.blockingTime;

package/core/audits/valid-source-maps.d.ts

@@ -3,14 +3,15 @@ declare class ValidSourceMaps extends Audit {
     /**
      * Returns true if the size of the script exceeds a static threshold.
      * @param {LH.Artifacts.Script} script
-     * @param {string} finalURL
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
      * @return {boolean}
      */
-    static isLargeFirstPartyJS(script: LH.Artifacts.Script, finalURL: string): boolean;
+    static isLargeFirstPartyJS(script: LH.Artifacts.Script, classifiedEntities: LH.Artifacts.EntityClassification): boolean;
     /**
      * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
      */
-    static audit(artifacts: LH.Artifacts): Promise<{
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
         score: number;
         details: import("../../types/lhr/audit-details.js").default.Table;
     }>;
@@ -24,4 +25,5 @@ export namespace UIStrings {
     const missingSourceMapItemsWarningMesssage: string;
 }
 import { Audit } from "./audit.js";
+import { EntityClassification } from "../computed/entity-classification.js";
 //# sourceMappingURL=valid-source-maps.d.ts.map

package/core/audits/valid-source-maps.js

@@ -4,8 +4,8 @@
  * 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 thirdPartyWeb from '../lib/third-party-web.js';
 import {Audit} from './audit.js';
+import {EntityClassification} from '../computed/entity-classification.js';
 import * as i18n from '../lib/i18n/i18n.js';
 
 const UIStrings = {
@@ -43,31 +43,33 @@ class ValidSourceMaps extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      requiredArtifacts: ['Scripts', 'SourceMaps', 'URL'],
+      requiredArtifacts: ['Scripts', 'SourceMaps', 'URL', 'devtoolsLogs'],
     };
   }
 
   /**
    * Returns true if the size of the script exceeds a static threshold.
    * @param {LH.Artifacts.Script} script
-   * @param {string} finalURL
+   * @param {LH.Artifacts.EntityClassification} classifiedEntities
    * @return {boolean}
    */
-  static isLargeFirstPartyJS(script, finalURL) {
+  static isLargeFirstPartyJS(script, classifiedEntities) {
     if (!script.length) return false;
 
     const isLargeJS = script.length >= LARGE_JS_BYTE_THRESHOLD;
-    const isFirstPartyJS = script.url ?
-      thirdPartyWeb.isFirstParty(script.url, thirdPartyWeb.getEntity(finalURL)) : false;
-
+    const isFirstPartyJS = script.url ? classifiedEntities.isFirstParty(script.url) : false;
     return isLargeJS && isFirstPartyJS;
   }
 
   /**
    * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
    */
-  static async audit(artifacts) {
+  static async audit(artifacts, context) {
     const {SourceMaps} = artifacts;
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const classifiedEntities = await EntityClassification.request(
+      {URL: artifacts.URL, devtoolsLog}, context);
 
     /** @type {Set<string>} */
     const isMissingMapForLargeFirstPartyScriptUrl = new Set();
@@ -77,7 +79,7 @@ class ValidSourceMaps extends Audit {
     for (const script of artifacts.Scripts) {
       const sourceMap = SourceMaps.find(m => m.scriptId === script.scriptId);
       const errors = [];
-      const isLargeFirstParty = this.isLargeFirstPartyJS(script, artifacts.URL.finalDisplayedUrl);
+      const isLargeFirstParty = this.isLargeFirstPartyJS(script, classifiedEntities);
 
       if (isLargeFirstParty && (!sourceMap || !sourceMap.map)) {
         missingMapsForLargeFirstPartyFile = true;

package/core/computed/entity-classification.d.ts

@@ -0,0 +1,29 @@
+export { EntityClassificationComputed as EntityClassification };
+export type EntityCache = Map<string, LH.Artifacts.Entity>;
+declare const EntityClassificationComputed: typeof EntityClassification & {
+    request: (dependencies: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.EntityClassification>;
+};
+/** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
+declare class EntityClassification {
+    /**
+     * @param {EntityCache} entityCache
+     * @param {string} url
+     * @return {LH.Artifacts.Entity | undefined}
+     */
+    static makeUpAnEntity(entityCache: EntityCache, url: string): LH.Artifacts.Entity | undefined;
+    /**
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.EntityClassification>}
+     */
+    static compute_(data: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.EntityClassification>;
+}
+//# sourceMappingURL=entity-classification.d.ts.map