lighthouse 9.5.0-dev.20230123 → 9.5.0-dev.20230125

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/network-requests.js

@@ -31,8 +31,8 @@ class NetworkRequests extends Audit {
   static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const records = await NetworkRecords.request(devtoolsLog, context);
-    const earliestStartTime = records.reduce(
-      (min, record) => Math.min(min, record.startTime),
+    const earliestRendererStartTime = records.reduce(
+      (min, record) => Math.min(min, record.rendererStartTime),
       Infinity
     );
 
@@ -47,8 +47,8 @@ class NetworkRequests extends Audit {
     }
 
     /** @param {number} time */
-    const normalizeTime = time => time < earliestStartTime || !Number.isFinite(time) ?
-      undefined : (time - earliestStartTime);
+    const normalizeTime = time => time < earliestRendererStartTime || !Number.isFinite(time) ?
+      undefined : (time - earliestRendererStartTime);
 
     const results = records.map(record => {
       const endTimeDeltaMs = record.lrStatistics?.endTimeDeltaMs;
@@ -64,6 +64,7 @@ class NetworkRequests extends Audit {
       return {
         url: UrlUtils.elideDataURI(record.url),
         protocol: record.protocol,
+        rendererStartTime: normalizeTime(record.rendererStartTime),
         startTime: normalizeTime(record.startTime),
         endTime: normalizeTime(record.endTime),
         finished: record.finished,
@@ -111,8 +112,8 @@ class NetworkRequests extends Audit {
     const tableDetails = Audit.makeTableDetails(headings, results);
 
     // Include starting timestamp to allow syncing requests with navStart/metric timestamps.
-    const networkStartTimeTs = Number.isFinite(earliestStartTime) ?
-        earliestStartTime * 1000 : undefined;
+    const networkStartTimeTs = Number.isFinite(earliestRendererStartTime) ?
+        earliestRendererStartTime * 1000 : undefined;
     tableDetails.debugData = {
       type: 'debugdata',
       networkStartTimeTs,

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

package/core/computed/entity-classification.js

@@ -0,0 +1,102 @@
+/**
+ * @license Copyright 2022 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 {makeComputedArtifact} from './computed-artifact.js';
+import {NetworkRecords} from './network-records.js';
+import {Util} from '../../shared/util.js';
+import UrlUtils from '../lib/url-utils.js';
+import thirdPartyWeb from '../lib/third-party-web.js';
+
+/** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
+
+class EntityClassification {
+  /**
+   * @param {EntityCache} entityCache
+   * @param {string} url
+   * @return {LH.Artifacts.Entity | undefined}
+   */
+  static makeUpAnEntity(entityCache, url) {
+    if (!UrlUtils.isValid(url)) return;
+    // We can make up an entity only for those URLs with a valid domain attached.
+    // So we further restrict from allowed URLs to (http/https).
+    if (!Util.createOrReturnURL(url).protocol.startsWith('http')) return;
+
+    const rootDomain = Util.getRootDomain(url);
+    if (!rootDomain) return;
+    if (entityCache.has(rootDomain)) return entityCache.get(rootDomain);
+
+    const unrecognizedEntity = {
+      name: rootDomain,
+      company: rootDomain,
+      category: '',
+      categories: [],
+      domains: [rootDomain],
+      averageExecutionTime: 0,
+      totalExecutionTime: 0,
+      totalOccurrences: 0,
+      isUnrecognized: true,
+    };
+    entityCache.set(rootDomain, unrecognizedEntity);
+    return unrecognizedEntity;
+  }
+
+  /**
+   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.EntityClassification>}
+   */
+  static async compute_(data, context) {
+    const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
+    /** @type {EntityCache} */
+    const madeUpEntityCache = new Map();
+    /** @type {Map<string, LH.Artifacts.Entity>} */
+    const entityByUrl = new Map();
+    /** @type {Map<LH.Artifacts.Entity, Set<string>>} */
+    const urlsByEntity = new Map();
+
+    for (const record of networkRecords) {
+      const {url} = record;
+      if (entityByUrl.has(url)) continue;
+
+      const entity = thirdPartyWeb.getEntity(url) ||
+        EntityClassification.makeUpAnEntity(madeUpEntityCache, url);
+      if (!entity) continue;
+
+      const entityURLs = urlsByEntity.get(entity) || new Set();
+      entityURLs.add(url);
+      urlsByEntity.set(entity, entityURLs);
+      entityByUrl.set(url, entity);
+    }
+
+    // When available, first party identification will be done via
+    // `mainDocumentUrl` (for navigations), and falls back to `finalDisplayedUrl` (for timespan/snapshot).
+    // See https://github.com/GoogleChrome/lighthouse/issues/13706
+    const firstPartyUrl = data.URL.mainDocumentUrl || data.URL.finalDisplayedUrl;
+    const firstParty = thirdPartyWeb.getEntity(firstPartyUrl) ||
+      EntityClassification.makeUpAnEntity(madeUpEntityCache, firstPartyUrl);
+
+    /**
+     * Convenience function to check if a URL belongs to first party.
+     * @param {string} url
+     * @return {boolean}
+     */
+    function isFirstParty(url) {
+      const entityUrl = entityByUrl.get(url);
+      if (!entityUrl) throw new Error('A url not in devtoolsLog was used for first-party check.');
+      return entityUrl === firstParty;
+    }
+
+    return {
+      entityByUrl,
+      urlsByEntity,
+      firstParty,
+      isFirstParty,
+    };
+  }
+}
+
+const EntityClassificationComputed = makeComputedArtifact(EntityClassification, null);
+export {EntityClassificationComputed as EntityClassification};

package/core/computed/metrics/responsiveness.js

@@ -87,8 +87,11 @@ class Responsiveness {
       return evt.name === 'EventTiming' && evt.ph !== 'e';
     });
 
-    if (candidates.length && !candidates.some(candidate => candidate.args.data?.frame)) {
-      // Full EventTiming data added in https://crrev.com/c/3632661
+    // If trace is from < m103, the timestamps cannot be trusted, so we craft a fallback
+    // <m103 traces (bad) had a   args.frame
+    // m103+ traces (good) have a args.data.frame (https://crrev.com/c/3632661)
+    // TODO(compat): remove FallbackTiming handling when we don't care about <m103
+    if (candidates.length && candidates.every(candidate => !candidate.args.data?.frame)) {
       return {
         name: 'FallbackTiming',
         duration: responsivenessEvent.args.data.maxDuration,

package/core/computed/page-dependency-graph.js

@@ -468,7 +468,7 @@ class PageDependencyGraph {
    * @return {URLArtifact}
    */
   static getDocumentUrls(devtoolsLog, networkRecords, processedTrace) {
-    const mainFrameId = processedTrace.mainFrameIds.frameId;
+    const mainFrameId = processedTrace.mainFrameInfo.frameId;
 
     /** @type {string|undefined} */
     let requestedUrl;

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

@@ -24,9 +24,10 @@ declare class ResourceSummary {
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
      * @param {LH.Artifacts.URL} URLArtifact
      * @param {LH.Util.ImmutableObject<LH.Budget[]|null>} budgets
+     * @param {LH.Artifacts.EntityClassification} classifiedEntities
      * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
      */
-    static summarize(networkRecords: Array<LH.Artifacts.NetworkRequest>, URLArtifact: LH.Artifacts.URL, budgets: LH.Util.ImmutableObject<LH.Budget[] | null>): Record<LH.Budget.ResourceType, ResourceEntry>;
+    static summarize(networkRecords: Array<LH.Artifacts.NetworkRequest>, URLArtifact: LH.Artifacts.URL, budgets: LH.Util.ImmutableObject<LH.Budget[] | null>, classifiedEntities: LH.Artifacts.EntityClassification): Record<LH.Budget.ResourceType, ResourceEntry>;
     /**
      * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, budgets: LH.Util.ImmutableObject<LH.Budget[]|null>}} data
      * @param {LH.Artifacts.ComputedContext} context
@@ -38,7 +39,8 @@ declare class ResourceSummary {
         budgets: LH.Util.ImmutableObject<LH.Budget[] | null>;
     }, context: LH.Artifacts.ComputedContext): Promise<Record<LH.Budget.ResourceType, ResourceEntry>>;
 }
-import { Util } from "../util.cjs";
+import { Util } from "../../shared/util.js";
 import { Budget } from "../config/budget.js";
 import { NetworkRequest } from "../lib/network-request.js";
+import { EntityClassification } from "./entity-classification.js";
 //# sourceMappingURL=resource-summary.d.ts.map

package/core/computed/resource-summary.js

@@ -4,11 +4,12 @@
  * 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 {EntityClassification} from './entity-classification.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {NetworkRecords} from './network-records.js';
 import {NetworkRequest} from '../lib/network-request.js';
 import {Budget} from '../config/budget.js';
-import {Util} from '../util.cjs';
+import {Util} from '../../shared/util.js';
 
 /** @typedef {{count: number, resourceSize: number, transferSize: number}} ResourceEntry */
 
@@ -35,9 +36,10 @@ class ResourceSummary {
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
    * @param {LH.Artifacts.URL} URLArtifact
    * @param {LH.Util.ImmutableObject<LH.Budget[]|null>} budgets
+   * @param {LH.Artifacts.EntityClassification} classifiedEntities
    * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
    */
-  static summarize(networkRecords, URLArtifact, budgets) {
+  static summarize(networkRecords, URLArtifact, budgets, classifiedEntities) {
     /** @type {Record<LH.Budget.ResourceType, ResourceEntry>} */
     const resourceSummary = {
       'stylesheet': {count: 0, resourceSize: 0, transferSize: 0},
@@ -56,8 +58,8 @@ class ResourceSummary {
     if (budget?.options?.firstPartyHostnames) {
       firstPartyHosts = budget.options.firstPartyHostnames;
     } else {
-      const rootDomain = Util.getRootDomain(URLArtifact.finalDisplayedUrl);
-      firstPartyHosts = [`*.${rootDomain}`];
+      firstPartyHosts = classifiedEntities.firstParty?.domains.map(domain => `*.${domain}`) ||
+        [`*.${Util.getRootDomain(URLArtifact.finalDisplayedUrl)}`];
     }
 
     networkRecords.filter(record => {
@@ -105,7 +107,8 @@ class ResourceSummary {
    */
   static async compute_(data, context) {
     const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
-    return ResourceSummary.summarize(networkRecords, data.URL, data.budgets);
+    const classifiedEntities = await EntityClassification.request(data, context);
+    return ResourceSummary.summarize(networkRecords, data.URL, data.budgets, classifiedEntities);
   }
 }
 

package/core/gather/gatherers/accessibility.js

@@ -61,10 +61,12 @@ async function runA11yChecks() {
       'frame-focusable-content': {enabled: false},
       'aria-roledescription': {enabled: false},
       'scrollable-region-focusable': {enabled: false},
-      // TODO(paulirish): create audits and enable these 3.
+      // TODO(paulirish): create audits and enable these 5.
       'input-button-name': {enabled: false},
       'role-img-alt': {enabled: false},
       'select-name': {enabled: false},
+      'link-in-text-block': {enabled: false},
+      'frame-title-unique': {enabled: false},
     },
   });