lighthouse 10.2.0 → 10.3.0-dev.20230614

package/core/audits/server-response-time.d.ts

@@ -2,8 +2,9 @@ export default ServerResponseTime;
 declare class ServerResponseTime extends Audit {
     /**
      * @param {LH.Artifacts.NetworkRequest} record
+     * @return {number|null}
      */
-    static calculateResponseTime(record: LH.Artifacts.NetworkRequest): number;
+    static calculateResponseTime(record: LH.Artifacts.NetworkRequest): number | null;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context

package/core/audits/server-response-time.js

@@ -43,10 +43,15 @@ class ServerResponseTime extends Audit {
 
   /**
    * @param {LH.Artifacts.NetworkRequest} record
+   * @return {number|null}
    */
   static calculateResponseTime(record) {
-    const timing = record.timing;
-    return timing ? timing.receiveHeadersEnd - timing.sendEnd : 0;
+    // Lightrider does not have timings for sendEnd, but we do have this timing which should be
+    // close to the response time.
+    if (global.isLightrider && record.lrStatistics) return record.lrStatistics.requestMs;
+
+    if (!record.timing) return null;
+    return record.timing.receiveHeadersStart - record.timing.sendEnd;
   }
 
   /**
@@ -61,6 +66,10 @@ class ServerResponseTime extends Audit {
     const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
 
     const responseTime = ServerResponseTime.calculateResponseTime(mainResource);
+    if (responseTime === null) {
+      throw new Error('no timing found for main resource');
+    }
+
     const passed = responseTime < TOO_SLOW_THRESHOLD_MS;
     const displayValue = str_(UIStrings.displayValue, {timeInMs: responseTime});
 
@@ -70,10 +79,11 @@ class ServerResponseTime extends Audit {
       {key: 'responseTime', valueType: 'timespanMs', label: str_(i18n.UIStrings.columnTimeSpent)},
     ];
 
+    const overallSavingsMs = Math.max(responseTime - TARGET_MS, 0);
     const details = Audit.makeOpportunityDetails(
       headings,
       [{url: mainResource.url, responseTime}],
-      {overallSavingsMs: responseTime - TARGET_MS}
+      {overallSavingsMs}
     );
 
     return {
@@ -82,6 +92,10 @@ class ServerResponseTime extends Audit {
       score: Number(passed),
       displayValue,
       details,
+      metricSavings: {
+        FCP: overallSavingsMs,
+        LCP: overallSavingsMs,
+      },
     };
   }
 }

package/core/audits/uses-rel-preconnect.js

@@ -72,7 +72,7 @@ class UsesRelPreconnectAudit extends Audit {
    * @return {boolean}
    */
   static hasValidTiming(record) {
-    return !!record.timing && record.timing.connectEnd > 0 && record.timing.connectStart > 0;
+    return !!record.timing && record.timing.connectEnd >= 0 && record.timing.connectStart >= 0;
   }
 
   /**
@@ -81,11 +81,27 @@ class UsesRelPreconnectAudit extends Audit {
    * @return {boolean}
    */
   static hasAlreadyConnectedToOrigin(record) {
-    return (
-      !!record.timing &&
+    if (!record.timing) return false;
+
+    // When these values are given as -1, that means the page has
+    // a connection for this origin and paid these costs already.
+    if (
+      record.timing.dnsStart === -1 && record.timing.dnsEnd === -1 &&
+      record.timing.connectStart === -1 && record.timing.connectEnd === -1
+    ) {
+      return true;
+    }
+
+    // Less understood: if the connection setup took no time at all, consider
+    // it the same as the above. It is unclear if this is correct, or is even possible.
+    if (
       record.timing.dnsEnd - record.timing.dnsStart === 0 &&
       record.timing.connectEnd - record.timing.connectStart === 0
-    );
+    ) {
+      return true;
+    }
+
+    return false;
   }
 
   /**

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

@@ -10,12 +10,25 @@ declare const EntityClassificationComputed: typeof EntityClassification & {
 };
 /** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
 declare class EntityClassification {
+    /**
+     * @param {EntityCache} entityCache
+     * @param {string} url
+     * @param {string=} extensionName
+     * @return {LH.Artifacts.Entity}
+     */
+    static makeupChromeExtensionEntity_(entityCache: EntityCache, url: string, extensionName?: string | undefined): LH.Artifacts.Entity;
     /**
      * @param {EntityCache} entityCache
      * @param {string} url
      * @return {LH.Artifacts.Entity | undefined}
      */
-    static makeUpAnEntity(entityCache: EntityCache, url: string): LH.Artifacts.Entity | undefined;
+    static _makeUpAnEntity(entityCache: EntityCache, url: string): LH.Artifacts.Entity | undefined;
+    /**
+     * Preload Chrome extensions found in the devtoolsLog into cache.
+     * @param {EntityCache} entityCache
+     * @param {LH.DevtoolsLog} devtoolsLog
+     */
+    static _preloadChromeExtensionsToCache(entityCache: EntityCache, devtoolsLog: import("../index.js").DevtoolsLog): void;
     /**
      * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
      * @param {LH.Artifacts.ComputedContext} context

package/core/computed/entity-classification.js

@@ -13,16 +13,51 @@ import thirdPartyWeb from '../lib/third-party-web.js';
 /** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
 
 class EntityClassification {
+  /**
+   * @param {EntityCache} entityCache
+   * @param {string} url
+   * @param {string=} extensionName
+   * @return {LH.Artifacts.Entity}
+   */
+  static makeupChromeExtensionEntity_(entityCache, url, extensionName) {
+    const origin = Util.getChromeExtensionOrigin(url);
+    const host = new URL(origin).host;
+    const name = extensionName || host;
+
+    const cachedEntity = entityCache.get(origin);
+    if (cachedEntity) return cachedEntity;
+
+    const chromeExtensionEntity = {
+      name,
+      company: name,
+      category: 'Chrome Extension',
+      homepage: 'https://chromewebstore.google.com/detail/' + host,
+      categories: [],
+      domains: [],
+      averageExecutionTime: 0,
+      totalExecutionTime: 0,
+      totalOccurrences: 0,
+    };
+
+    entityCache.set(origin, chromeExtensionEntity);
+    return chromeExtensionEntity;
+  }
+
   /**
    * @param {EntityCache} entityCache
    * @param {string} url
    * @return {LH.Artifacts.Entity | undefined}
    */
-  static makeUpAnEntity(entityCache, url) {
+  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 parsedUrl = Util.createOrReturnURL(url);
+    if (parsedUrl.protocol === 'chrome-extension:') {
+      return EntityClassification.makeupChromeExtensionEntity_(entityCache, url);
+    }
+
+    // Make up an entity only for valid http/https URLs.
+    if (!parsedUrl.protocol.startsWith('http')) return;
 
     const rootDomain = Util.getRootDomain(url);
     if (!rootDomain) return;
@@ -43,6 +78,24 @@ class EntityClassification {
     return unrecognizedEntity;
   }
 
+  /**
+   * Preload Chrome extensions found in the devtoolsLog into cache.
+   * @param {EntityCache} entityCache
+   * @param {LH.DevtoolsLog} devtoolsLog
+   */
+  static _preloadChromeExtensionsToCache(entityCache, devtoolsLog) {
+    for (const entry of devtoolsLog.values()) {
+      if (entry.method !== 'Runtime.executionContextCreated') continue;
+
+      const origin = entry.params.context.origin;
+      if (!origin.startsWith('chrome-extension:')) continue;
+      if (entityCache.has(origin)) continue;
+
+      EntityClassification.makeupChromeExtensionEntity_(entityCache, origin,
+        entry.params.context.name);
+    }
+  }
+
   /**
    * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -57,12 +110,14 @@ class EntityClassification {
     /** @type {Map<LH.Artifacts.Entity, Set<string>>} */
     const urlsByEntity = new Map();
 
+    EntityClassification._preloadChromeExtensionsToCache(madeUpEntityCache, data.devtoolsLog);
+
     for (const record of networkRecords) {
       const {url} = record;
       if (entityByUrl.has(url)) continue;
 
       const entity = thirdPartyWeb.getEntity(url) ||
-        EntityClassification.makeUpAnEntity(madeUpEntityCache, url);
+        EntityClassification._makeUpAnEntity(madeUpEntityCache, url);
       if (!entity) continue;
 
       const entityURLs = urlsByEntity.get(entity) || new Set();
@@ -76,7 +131,7 @@ class EntityClassification {
     // 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);
+      EntityClassification._makeUpAnEntity(madeUpEntityCache, firstPartyUrl);
 
     /**
      * Convenience function to check if a URL belongs to first party.

package/core/computed/metrics/cumulative-layout-shift.d.ts

@@ -3,6 +3,7 @@ export type LayoutShiftEvent = {
     ts: number;
     isMainFrame: boolean;
     weightedScore: number;
+    impactedNodes?: LH.Artifacts.TraceImpactedNode[];
 };
 declare const CumulativeLayoutShiftComputed: typeof CumulativeLayoutShift & {
     request: (dependencies: import("../../index.js").Trace, context: import("../../../types/utility-types.js").default.ImmutableObject<{
@@ -10,7 +11,6 @@ declare const CumulativeLayoutShiftComputed: typeof CumulativeLayoutShift & {
     }>) => Promise<{
         cumulativeLayoutShift: number;
         cumulativeLayoutShiftMainFrame: number;
-        totalCumulativeLayoutShift: number;
     }>;
 };
 declare class CumulativeLayoutShift {
@@ -32,21 +32,14 @@ declare class CumulativeLayoutShift {
      * @return {number}
      */
     static calculate(layoutShiftEvents: Array<LayoutShiftEvent>): number;
-    /**
-     * Sum all layout shift events from the entire trace.
-     * @param {Array<LayoutShiftEvent>} layoutShiftEvents
-     * @return {number}
-     */
-    static calculateTotalCumulativeLayoutShift(layoutShiftEvents: Array<LayoutShiftEvent>): number;
     /**
      * @param {LH.Trace} trace
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<{cumulativeLayoutShift: number, cumulativeLayoutShiftMainFrame: number, totalCumulativeLayoutShift: number}>}
+     * @return {Promise<{cumulativeLayoutShift: number, cumulativeLayoutShiftMainFrame: number}>}
      */
     static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<{
         cumulativeLayoutShift: number;
         cumulativeLayoutShiftMainFrame: number;
-        totalCumulativeLayoutShift: number;
     }>;
 }
 import { ProcessedTrace } from '../processed-trace.js';

package/core/computed/metrics/cumulative-layout-shift.js

@@ -7,7 +7,7 @@
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {ProcessedTrace} from '../processed-trace.js';
 
-/** @typedef {{ts: number, isMainFrame: boolean, weightedScore: number}} LayoutShiftEvent */
+/** @typedef {{ts: number, isMainFrame: boolean, weightedScore: number, impactedNodes?: LH.Artifacts.TraceImpactedNode[]}} LayoutShiftEvent */
 
 const RECENT_INPUT_WINDOW = 500;
 
@@ -65,6 +65,7 @@ class CumulativeLayoutShift {
         ts: event.ts,
         isMainFrame: event.args.data.is_main_frame,
         weightedScore: event.args.data.weighted_score_delta,
+        impactedNodes: event.args.data.impacted_nodes,
       });
     }
 
@@ -100,19 +101,10 @@ class CumulativeLayoutShift {
     return maxScore;
   }
 
-  /**
-   * Sum all layout shift events from the entire trace.
-   * @param {Array<LayoutShiftEvent>} layoutShiftEvents
-   * @return {number}
-   */
-  static calculateTotalCumulativeLayoutShift(layoutShiftEvents) {
-    return layoutShiftEvents.reduce((sum, e) => sum += e.weightedScore, 0);
-  }
-
   /**
    * @param {LH.Trace} trace
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<{cumulativeLayoutShift: number, cumulativeLayoutShiftMainFrame: number, totalCumulativeLayoutShift: number}>}
+   * @return {Promise<{cumulativeLayoutShift: number, cumulativeLayoutShiftMainFrame: number}>}
    */
   static async compute_(trace, context) {
     const processedTrace = await ProcessedTrace.request(trace, context);
@@ -121,14 +113,9 @@ class CumulativeLayoutShift {
         CumulativeLayoutShift.getLayoutShiftEvents(processedTrace);
     const mainFrameShiftEvents = allFrameShiftEvents.filter(e => e.isMainFrame);
 
-    // The original Cumulative Layout Shift metric, the sum of all main-frame shift events.
-    const totalCumulativeLayoutShift =
-        CumulativeLayoutShift.calculateTotalCumulativeLayoutShift(mainFrameShiftEvents);
-
     return {
       cumulativeLayoutShift: CumulativeLayoutShift.calculate(allFrameShiftEvents),
       cumulativeLayoutShiftMainFrame: CumulativeLayoutShift.calculate(mainFrameShiftEvents),
-      totalCumulativeLayoutShift,
     };
   }
 }

package/core/computed/metrics/time-to-first-byte.js

@@ -26,7 +26,8 @@ class TimeToFirstByte extends NavigationMetric {
 
     // Estimate when the connection is not warm.
     // TTFB = DNS + (SSL)? + TCP handshake + 1 RT for request + server response time
-    let roundTrips = 3;
+    let roundTrips = 2;
+    if (!mainResource.protocol.startsWith('h3')) roundTrips += 1; // TCP
     if (mainResource.parsedURL.scheme === 'https') roundTrips += 1;
     const estimatedTTFB = data.settings.throttling.rttMs * roundTrips + observedResponseTime;
 
@@ -40,15 +41,17 @@ class TimeToFirstByte extends NavigationMetric {
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static async computeObservedMetric(data, context) {
-    const {processedNavigation} = data;
-    const timeOriginTs = processedNavigation.timestamps.timeOrigin;
     const mainResource = await MainResource.request(data, context);
+    if (!mainResource.timing) {
+      throw new Error('missing timing for main resource');
+    }
 
-    // Technically TTFB is the start of the response headers not the end.
-    // That signal isn't available to us so we use header end time as a best guess.
-    const timestamp = mainResource.responseHeadersEndTime * 1000;
+    const {processedNavigation} = data;
+    const timeOriginTs = processedNavigation.timestamps.timeOrigin;
+    const timestampMs =
+      mainResource.timing.requestTime * 1000 + mainResource.timing.receiveHeadersStart;
+    const timestamp = timestampMs * 1000;
     const timing = (timestamp - timeOriginTs) / 1000;
-
     return {timing, timestamp};
   }
 }

package/core/computed/metrics/timing-summary.js

@@ -65,7 +65,6 @@ class TimingSummary {
     const {
       cumulativeLayoutShift,
       cumulativeLayoutShiftMainFrame,
-      totalCumulativeLayoutShift,
     } = cumulativeLayoutShiftValues || {};
 
     /** @type {LH.Artifacts.TimingSummary} */
@@ -89,7 +88,6 @@ class TimingSummary {
       maxPotentialFID: maxPotentialFID?.timing,
       cumulativeLayoutShift,
       cumulativeLayoutShiftMainFrame,
-      totalCumulativeLayoutShift,
 
       lcpLoadStart: lcpBreakdown?.loadStart,
       lcpLoadEnd: lcpBreakdown?.loadEnd,
@@ -123,7 +121,6 @@ class TimingSummary {
       observedDomContentLoadedTs: processedNavigation?.timestamps.domContentLoaded,
       observedCumulativeLayoutShift: cumulativeLayoutShift,
       observedCumulativeLayoutShiftMainFrame: cumulativeLayoutShiftMainFrame,
-      observedTotalCumulativeLayoutShift: totalCumulativeLayoutShift,
 
       // Include some visual metrics from speedline
       observedFirstVisualChange: speedline.first,

package/core/config/default-config.js

@@ -263,7 +263,9 @@ const defaultConfig = {
     'accessibility/heading-order',
     'accessibility/html-has-lang',
     'accessibility/html-lang-valid',
+    'accessibility/html-xml-lang-mismatch',
     'accessibility/image-alt',
+    'accessibility/input-button-name',
     'accessibility/input-image-alt',
     'accessibility/label',
     'accessibility/link-name',
@@ -273,6 +275,8 @@ const defaultConfig = {
     'accessibility/meta-viewport',
     'accessibility/object-alt',
     'accessibility/tabindex',
+    'accessibility/table-fake-caption',
+    'accessibility/td-has-header',
     'accessibility/td-headers-attr',
     'accessibility/th-has-data-cells',
     'accessibility/valid-lang',
@@ -527,7 +531,9 @@ const defaultConfig = {
         {id: 'heading-order', weight: 2, group: 'a11y-navigation'},
         {id: 'html-has-lang', weight: 3, group: 'a11y-language'},
         {id: 'html-lang-valid', weight: 3, group: 'a11y-language'},
+        {id: 'html-xml-lang-mismatch', weight: 2, group: 'a11y-language'},
         {id: 'image-alt', weight: 10, group: 'a11y-names-labels'},
+        {id: 'input-button-name', weight: 10, group: 'a11y-names-labels'},
         {id: 'input-image-alt', weight: 10, group: 'a11y-names-labels'},
         {id: 'label', weight: 10, group: 'a11y-names-labels'},
         {id: 'link-name', weight: 3, group: 'a11y-names-labels'},
@@ -537,6 +543,8 @@ const defaultConfig = {
         {id: 'meta-viewport', weight: 10, group: 'a11y-best-practices'},
         {id: 'object-alt', weight: 3, group: 'a11y-names-labels'},
         {id: 'tabindex', weight: 3, group: 'a11y-navigation'},
+        {id: 'table-fake-caption', weight: 3, group: 'a11y-tables-lists'},
+        {id: 'td-has-header', weight: 10, group: 'a11y-tables-lists'},
         {id: 'td-headers-attr', weight: 3, group: 'a11y-tables-lists'},
         {id: 'th-has-data-cells', weight: 3, group: 'a11y-tables-lists'},
         {id: 'valid-lang', weight: 3, group: 'a11y-language'},

package/core/gather/driver/execution-context.js

@@ -125,14 +125,22 @@ class ExecutionContext {
 
     this._session.setNextProtocolTimeout(timeout);
     const response = await this._session.sendCommand('Runtime.evaluate', evaluationParams);
-    if (response.exceptionDetails) {
+
+    const ex = response.exceptionDetails;
+    if (ex) {
       // An error occurred before we could even create a Promise, should be *very* rare.
       // Also occurs when the expression is not valid JavaScript.
-      const errorMessage = response.exceptionDetails.exception ?
-        response.exceptionDetails.exception.description :
-        response.exceptionDetails.text;
-      return Promise.reject(new Error(`Evaluation exception: ${errorMessage}`));
+      const elidedExpression = expression.replace(/\s+/g, ' ').substring(0, 100);
+      const messageLines = [
+        'Runtime.evaluate exception',
+        `Expression: ${elidedExpression}\n---- (elided)`,
+        !ex.stackTrace ? `Parse error at: ${ex.lineNumber + 1}:${ex.columnNumber + 1}` : null,
+        ex.exception?.description || ex.text,
+      ].filter(Boolean);
+      const evaluationError = new Error(messageLines.join('\n'));
+      return Promise.reject(evaluationError);
     }
+
     // Protocol should always return a 'result' object, but it is sometimes undefined.  See #6026.
     if (response.result === undefined) {
       return Promise.reject(

package/core/gather/driver/target-manager.d.ts

@@ -18,12 +18,15 @@ export class TargetManager extends TargetManager_base {
     constructor(cdpSession: LH.Puppeteer.CDPSession);
     _enabled: boolean;
     _rootCdpSession: import("../../../types/puppeteer.js").default.CDPSession;
+    _mainFrameId: string;
     /**
      * A map of target id to target/session information. Used to ensure unique
      * attached targets.
      * @type {Map<string, TargetWithSession>}
      */
     _targetIdToTargets: Map<string, TargetWithSession>;
+    /** @type {Map<string, LH.Crdp.Runtime.ExecutionContextDescription>} */
+    _executionContextIdToDescriptions: Map<string, LH.Crdp.Runtime.ExecutionContextDescription>;
     /**
      * @param {LH.Puppeteer.CDPSession} cdpSession
      */
@@ -32,6 +35,15 @@ export class TargetManager extends TargetManager_base {
      * @param {LH.Crdp.Page.FrameNavigatedEvent} frameNavigatedEvent
      */
     _onFrameNavigated(frameNavigatedEvent: LH.Crdp.Page.FrameNavigatedEvent): Promise<void>;
+    /**
+     * @param {LH.Crdp.Runtime.ExecutionContextCreatedEvent} event
+     */
+    _onExecutionContextCreated(event: LH.Crdp.Runtime.ExecutionContextCreatedEvent): void;
+    /**
+     * @param {LH.Crdp.Runtime.ExecutionContextDestroyedEvent} event
+     */
+    _onExecutionContextDestroyed(event: LH.Crdp.Runtime.ExecutionContextDestroyedEvent): void;
+    _onExecutionContextsCleared(): void;
     /**
      * @param {string} sessionId
      * @return {LH.Gatherer.FRProtocolSession}
@@ -42,6 +54,7 @@ export class TargetManager extends TargetManager_base {
      * @return {LH.Gatherer.FRProtocolSession}
      */
     rootSession(): LH.Gatherer.FRProtocolSession;
+    mainFrameExecutionContexts(): import("devtools-protocol").Protocol.Runtime.ExecutionContextDescription[];
     /**
      * Returns a listener for all protocol events from session, and augments the
      * event with the sessionId.

package/core/gather/driver/target-manager.js

@@ -40,6 +40,7 @@ class TargetManager extends ProtocolEventEmitter {
 
     this._enabled = false;
     this._rootCdpSession = cdpSession;
+    this._mainFrameId = '';
 
     /**
      * A map of target id to target/session information. Used to ensure unique
@@ -47,9 +48,14 @@ class TargetManager extends ProtocolEventEmitter {
      * @type {Map<string, TargetWithSession>}
      */
     this._targetIdToTargets = new Map();
+    /** @type {Map<string, LH.Crdp.Runtime.ExecutionContextDescription>} */
+    this._executionContextIdToDescriptions = new Map();
 
     this._onSessionAttached = this._onSessionAttached.bind(this);
     this._onFrameNavigated = this._onFrameNavigated.bind(this);
+    this._onExecutionContextCreated = this._onExecutionContextCreated.bind(this);
+    this._onExecutionContextDestroyed = this._onExecutionContextDestroyed.bind(this);
+    this._onExecutionContextsCleared = this._onExecutionContextsCleared.bind(this);
   }
 
   /**
@@ -97,6 +103,12 @@ class TargetManager extends ProtocolEventEmitter {
     return this._findSession(rootSessionId);
   }
 
+  mainFrameExecutionContexts() {
+    return [...this._executionContextIdToDescriptions.values()].filter(executionContext => {
+      return executionContext.auxData.frameId === this._mainFrameId;
+    });
+  }
+
   /**
    * @param {LH.Puppeteer.CDPSession} cdpSession
    */
@@ -153,6 +165,27 @@ class TargetManager extends ProtocolEventEmitter {
     }
   }
 
+  /**
+   * @param {LH.Crdp.Runtime.ExecutionContextCreatedEvent} event
+   */
+  _onExecutionContextCreated(event) {
+    if (event.context.name === '__puppeteer_utility_world__') return;
+    if (event.context.name === 'lighthouse_isolated_context') return;
+
+    this._executionContextIdToDescriptions.set(event.context.uniqueId, event.context);
+  }
+
+  /**
+   * @param {LH.Crdp.Runtime.ExecutionContextDestroyedEvent} event
+   */
+  _onExecutionContextDestroyed(event) {
+    this._executionContextIdToDescriptions.delete(event.executionContextUniqueId);
+  }
+
+  _onExecutionContextsCleared() {
+    this._executionContextIdToDescriptions.clear();
+  }
+
   /**
    * Returns a listener for all protocol events from session, and augments the
    * event with the sessionId.
@@ -183,10 +216,17 @@ class TargetManager extends ProtocolEventEmitter {
 
     this._enabled = true;
     this._targetIdToTargets = new Map();
+    this._executionContextIdToDescriptions = new Map();
 
     this._rootCdpSession.on('Page.frameNavigated', this._onFrameNavigated);
+    this._rootCdpSession.on('Runtime.executionContextCreated', this._onExecutionContextCreated);
+    this._rootCdpSession.on('Runtime.executionContextDestroyed', this._onExecutionContextDestroyed);
+    this._rootCdpSession.on('Runtime.executionContextsCleared', this._onExecutionContextsCleared);
 
     await this._rootCdpSession.send('Page.enable');
+    await this._rootCdpSession.send('Runtime.enable');
+
+    this._mainFrameId = (await this._rootCdpSession.send('Page.getFrameTree')).frameTree.frame.id;
 
     // Start with the already attached root session.
     await this._onSessionAttached(this._rootCdpSession);
@@ -197,14 +237,23 @@ class TargetManager extends ProtocolEventEmitter {
    */
   async disable() {
     this._rootCdpSession.off('Page.frameNavigated', this._onFrameNavigated);
+    this._rootCdpSession.off('Runtime.executionContextCreated', this._onExecutionContextCreated);
+    this._rootCdpSession.off('Runtime.executionContextDestroyed',
+      this._onExecutionContextDestroyed);
+    this._rootCdpSession.off('Runtime.executionContextsCleared', this._onExecutionContextsCleared);
 
     for (const {cdpSession, protocolListener} of this._targetIdToTargets.values()) {
       cdpSession.off('*', protocolListener);
       cdpSession.off('sessionattached', this._onSessionAttached);
     }
 
+    await this._rootCdpSession.send('Page.disable');
+    await this._rootCdpSession.send('Runtime.disable');
+
     this._enabled = false;
     this._targetIdToTargets = new Map();
+    this._executionContextIdToDescriptions = new Map();
+    this._mainFrameId = '';
   }
 }
 

package/core/gather/gatherers/accessibility.js

@@ -39,34 +39,33 @@ async function runA11yChecks() {
     resultTypes: ['violations', 'inapplicable'],
     rules: {
       // Consider http://go/prcpg for expert review of the aXe rules.
-      'tabindex': {enabled: true},
       'accesskeys': {enabled: true},
-      'heading-order': {enabled: true},
-      'meta-viewport': {enabled: true},
-      'duplicate-id': {enabled: false},
-      'table-fake-caption': {enabled: false},
-      'td-has-header': {enabled: false},
-      'marquee': {enabled: false},
       'area-alt': {enabled: false},
-      'html-xml-lang-mismatch': {enabled: false},
+      'aria-roledescription': {enabled: false},
+      'aria-treeitem-name': {enabled: true},
+      'audio-caption': {enabled: false},
       'blink': {enabled: false},
-      'server-side-image-map': {enabled: false},
+      'duplicate-id': {enabled: false},
+      'frame-focusable-content': {enabled: false},
+      'frame-title-unique': {enabled: false},
+      'heading-order': {enabled: true},
+      'html-xml-lang-mismatch': {enabled: true},
       'identical-links-same-purpose': {enabled: false},
-      'no-autoplay-audio': {enabled: false},
-      'svg-img-alt': {enabled: false},
-      'audio-caption': {enabled: false},
-      'aria-treeitem-name': {enabled: true},
+      'input-button-name': {enabled: true},
+      'link-in-text-block': {enabled: false},
+      'marquee': {enabled: false},
+      'meta-viewport': {enabled: true},
       // https://github.com/dequelabs/axe-core/issues/2958
       'nested-interactive': {enabled: false},
-      'frame-focusable-content': {enabled: false},
-      'aria-roledescription': {enabled: false},
-      'scrollable-region-focusable': {enabled: false},
-      // TODO(paulirish): create audits and enable these 5.
-      'input-button-name': {enabled: false},
+      'no-autoplay-audio': {enabled: false},
       'role-img-alt': {enabled: false},
+      'scrollable-region-focusable': {enabled: false},
       'select-name': {enabled: false},
-      'link-in-text-block': {enabled: false},
-      'frame-title-unique': {enabled: false},
+      'server-side-image-map': {enabled: false},
+      'svg-img-alt': {enabled: false},
+      'tabindex': {enabled: true},
+      'table-fake-caption': {enabled: true},
+      'td-has-header': {enabled: true},
     },
   });