lighthouse 11.7.0-dev.20240408 → 11.7.1

package/CONTRIBUTING.md

@@ -79,8 +79,8 @@ A PR adding or changing a gatherer almost always needs to include the following:
 1. **Golden artifacts**: `sample_v2.json` is generated from a set of artifacts that come from running LH against `dbw_tester.html`. Those artifacts likely need to be updated after gatherer changes with `yarn update:sample-artifacts`, but limit to just the artifact being altered if possible. For example:
 
    ```sh
-   # update just the Scripts artifact
-   yarn update:sample-artifacts Scripts
+   # update just the ScriptElements artifact
+   yarn update:sample-artifacts ScriptElements
    ```
 
    This command works for updating `yarn update:sample-artifacts DevtoolsLog` or `Trace` as well, but the resulting `sample_v2.json` churn may be extensive and you might be better off editing manually.

package/cli/test/smokehouse/core-tests.js

@@ -61,6 +61,7 @@ import screenshot from './test-definitions/screenshot.js';
 import seoFailing from './test-definitions/seo-failing.js';
 import seoPassing from './test-definitions/seo-passing.js';
 import seoStatus403 from './test-definitions/seo-status-403.js';
+import seoTapTargets from './test-definitions/seo-tap-targets.js';
 import serviceWorkerReloaded from './test-definitions/service-worker-reloaded.js';
 import shiftAttribution from './test-definitions/shift-attribution.js';
 import sourceMaps from './test-definitions/source-maps.js';
@@ -125,6 +126,7 @@ const smokeTests = [
   seoFailing,
   seoPassing,
   seoStatus403,
+  seoTapTargets,
   serviceWorkerReloaded,
   shiftAttribution,
   sourceMaps,

package/core/audits/accessibility/duplicate-id-active.d.ts

@@ -0,0 +1,10 @@
+export default DuplicateIdActive;
+declare class DuplicateIdActive extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=duplicate-id-active.d.ts.map

package/core/audits/accessibility/duplicate-id-active.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Ensures every `id` attribute value of active, focusable elements is unique.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if there are any duplicate id HTML attributes on active, focusable elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[id]` attributes on active, focusable elements are unique',
+  /** Title of an accesibility audit that checks if there are any duplicate id HTML attributes on active, focusable elements. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[id]` attributes on active, focusable elements are not unique',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'All focusable elements must have a unique `id` to ensure that they\'re visible to assistive technologies. [Learn how to fix duplicate `id`s](https://dequeuniversity.com/rules/axe/4.9/duplicate-id-active).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DuplicateIdActive extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'duplicate-id-active',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default DuplicateIdActive;
+export {UIStrings};

package/core/audits/accessibility/target-size.js

@@ -35,6 +35,7 @@ class TargetSize extends AxeAudit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
       requiredArtifacts: ['Accessibility'],
     };
   }

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

@@ -56,6 +56,22 @@ export class ByteEfficiencyAudit extends Audit {
         simulationBeforeChanges: LH.Gatherer.Simulation.Result;
         simulationAfterChanges: LH.Gatherer.Simulation.Result;
     };
+    /**
+     * Computes the estimated effect of all the byte savings on the maximum of the following:
+     *
+     * - end time of the last long task in the provided graph
+     * - (if includeLoad is true or not provided) end time of the last node in the graph
+     *
+     * @param {Array<LH.Audit.ByteEfficiencyItem>} results The array of byte savings results per resource
+     * @param {Node} graph
+     * @param {Simulator} simulator
+     * @param {{includeLoad?: boolean, providedWastedBytesByUrl?: Map<string, number>}=} options
+     * @return {number}
+     */
+    static computeWasteWithTTIGraph(results: Array<LH.Audit.ByteEfficiencyItem>, graph: Node, simulator: Simulator, options?: {
+        includeLoad?: boolean;
+        providedWastedBytesByUrl?: Map<string, number>;
+    } | undefined): number;
     /**
      * @param {ByteEfficiencyProduct} result
      * @param {Simulator} simulator

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

@@ -5,9 +5,11 @@
  */
 
 import {Audit} from '../audit.js';
+import {LanternInteractive} from '../../computed/metrics/lantern-interactive.js';
 import * as i18n from '../../lib/i18n/i18n.js';
 import {NetworkRecords} from '../../computed/network-records.js';
 import {LoadSimulator} from '../../computed/load-simulator.js';
+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';
@@ -149,6 +151,37 @@ class ByteEfficiencyAudit extends Audit {
     };
   }
 
+  /**
+   * Computes the estimated effect of all the byte savings on the maximum of the following:
+   *
+   * - end time of the last long task in the provided graph
+   * - (if includeLoad is true or not provided) end time of the last node in the graph
+   *
+   * @param {Array<LH.Audit.ByteEfficiencyItem>} results The array of byte savings results per resource
+   * @param {Node} graph
+   * @param {Simulator} simulator
+   * @param {{includeLoad?: boolean, providedWastedBytesByUrl?: Map<string, number>}=} options
+   * @return {number}
+   */
+  static computeWasteWithTTIGraph(results, graph, simulator, options) {
+    options = Object.assign({includeLoad: true}, options);
+    const {savings: savingsOnOverallLoad, simulationBeforeChanges, simulationAfterChanges} =
+      this.computeWasteWithGraph(results, graph, simulator, {
+        ...options,
+        label: 'overallLoad',
+      });
+
+    const savingsOnTTI =
+      LanternInteractive.getLastLongTaskEndTime(simulationBeforeChanges.nodeTimings) -
+      LanternInteractive.getLastLongTaskEndTime(simulationAfterChanges.nodeTimings);
+
+    let savings = savingsOnTTI;
+    if (options.includeLoad) savings = Math.max(savings, savingsOnOverallLoad);
+
+    // Round waste to nearest 10ms
+    return Math.round(Math.max(savings, 0) / 10) * 10;
+  }
+
   /**
    * @param {ByteEfficiencyProduct} result
    * @param {Simulator} simulator
@@ -171,6 +204,7 @@ class ByteEfficiencyAudit extends Audit {
     // This is useful information in the LHR and should be preserved.
     let wastedMs;
     if (metricComputationInput.gatherContext.gatherMode === 'navigation') {
+      const graph = await PageDependencyGraph.request(metricComputationInput, context);
       const {
         optimisticGraph: optimisticFCPGraph,
       } = await LanternFirstContentfulPaint.request(metricComputationInput, context);
@@ -178,6 +212,10 @@ class ByteEfficiencyAudit extends Audit {
         optimisticGraph: optimisticLCPGraph,
       } = await LanternLargestContentfulPaint.request(metricComputationInput, context);
 
+      wastedMs = this.computeWasteWithTTIGraph(results, graph, simulator, {
+        providedWastedBytesByUrl: result.wastedBytesByUrl,
+      });
+
       const {savings: fcpSavings} = this.computeWasteWithGraph(
         results,
         optimisticFCPGraph,
@@ -205,7 +243,6 @@ class ByteEfficiencyAudit extends Audit {
 
       metricSavings.FCP = fcpSavings;
       metricSavings.LCP = Math.max(lcpGraphSavings, lcpRecordSavings);
-      wastedMs = metricSavings.LCP;
     } else {
       wastedMs = simulator.computeWastedMsFromWastedBytes(wastedBytes);
     }

package/core/audits/byte-efficiency/offscreen-images.d.ts

@@ -47,6 +47,17 @@ declare class OffscreenImages extends ByteEfficiencyAudit {
      * @param {number} interactiveTimestamp
      */
     static filterObservedResults(images: WasteResult[], interactiveTimestamp: number): WasteResult[];
+    /**
+     * The default byte efficiency audit will report max(TTI, load), since lazy-loading offscreen
+     * images won't reduce the overall time and the wasted bytes are really only "wasted" for TTI,
+     * override the function to just look at TTI savings.
+     *
+     * @param {Array<LH.Audit.ByteEfficiencyItem>} results
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @param {LH.Gatherer.Simulation.Simulator} simulator
+     * @return {number}
+     */
+    static computeWasteWithTTIGraph(results: Array<LH.Audit.ByteEfficiencyItem>, graph: LH.Gatherer.Simulation.GraphNode, simulator: LH.Gatherer.Simulation.Simulator): number;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords

package/core/audits/byte-efficiency/offscreen-images.js

@@ -156,6 +156,21 @@ class OffscreenImages extends ByteEfficiencyAudit {
     });
   }
 
+  /**
+   * The default byte efficiency audit will report max(TTI, load), since lazy-loading offscreen
+   * images won't reduce the overall time and the wasted bytes are really only "wasted" for TTI,
+   * override the function to just look at TTI savings.
+   *
+   * @param {Array<LH.Audit.ByteEfficiencyItem>} results
+   * @param {LH.Gatherer.Simulation.GraphNode} graph
+   * @param {LH.Gatherer.Simulation.Simulator} simulator
+   * @return {number}
+   */
+  static computeWasteWithTTIGraph(results, graph, simulator) {
+    return super.computeWasteWithTTIGraph(results, graph, simulator,
+      {includeLoad: false});
+  }
+
   /**
    * @param {LH.Artifacts} artifacts
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords

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

@@ -20,6 +20,19 @@ declare class UsesHTTP2Audit extends Audit {
         simulationBefore: LH.Gatherer.Simulation.Result;
         simulationAfter: LH.Gatherer.Simulation.Result;
     };
+    /**
+     * Computes the estimated effect all results being converted to use http/2, the max of:
+     *
+     * - end time of the last long task in the provided graph
+     * - end time of the last node in the graph
+     * @param {Array<{url: string}>} results
+     * @param {Node} graph
+     * @param {Simulator} simulator
+     * @return {number}
+     */
+    static computeWasteWithTTIGraph(results: Array<{
+        url: string;
+    }>, graph: Node, simulator: Simulator): number;
     /**
      * Determines whether a network request is a "static resource" that would benefit from H2 multiplexing.
      * XHRs, tracking pixels, etc generally don't benefit as much because they aren't requested en-masse

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

@@ -15,9 +15,11 @@
 import {Audit} from '../audit.js';
 import {EntityClassification} from '../../computed/entity-classification.js';
 import UrlUtils from '../../lib/url-utils.js';
+import {LanternInteractive} from '../../computed/metrics/lantern-interactive.js';
 import {NetworkRequest} from '../../lib/network-request.js';
 import {NetworkRecords} from '../../computed/network-records.js';
 import {LoadSimulator} from '../../computed/load-simulator.js';
+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 * as i18n from '../../lib/i18n/i18n.js';
@@ -115,6 +117,32 @@ class UsesHTTP2Audit extends Audit {
     };
   }
 
+  /**
+   * Computes the estimated effect all results being converted to use http/2, the max of:
+   *
+   * - end time of the last long task in the provided graph
+   * - end time of the last node in the graph
+   * @param {Array<{url: string}>} results
+   * @param {Node} graph
+   * @param {Simulator} simulator
+   * @return {number}
+   */
+  static computeWasteWithTTIGraph(results, graph, simulator) {
+    const {savings: savingsOnOverallLoad, simulationBefore, simulationAfter} =
+      this.computeWasteWithGraph(results, graph, simulator, {
+        label: 'tti',
+      });
+
+    const savingsOnTTI =
+      LanternInteractive.getLastLongTaskEndTime(simulationBefore.nodeTimings) -
+      LanternInteractive.getLastLongTaskEndTime(simulationAfter.nodeTimings);
+
+    const savings = Math.max(savingsOnTTI, savingsOnOverallLoad);
+
+    // Round waste to nearest 10ms
+    return Math.round(Math.max(savings, 0) / 10) * 10;
+  }
+
   /**
    * Determines whether a network request is a "static resource" that would benefit from H2 multiplexing.
    * XHRs, tracking pixels, etc generally don't benefit as much because they aren't requested en-masse
@@ -207,6 +235,7 @@ class UsesHTTP2Audit extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
@@ -240,6 +269,7 @@ class UsesHTTP2Audit extends Audit {
       devtoolsLog,
       settings,
     };
+    const pageGraph = await PageDependencyGraph.request({trace, devtoolsLog, URL}, context);
     const simulator = await LoadSimulator.request(simulatorOptions, context);
     const metricComputationInput = Audit.makeMetricComputationDataInput(artifacts, context);
 
@@ -250,6 +280,8 @@ class UsesHTTP2Audit extends Audit {
       pessimisticGraph: lcpGraph,
     } = await LanternLargestContentfulPaint.request(metricComputationInput, context);
 
+    const wastedMsTti = UsesHTTP2Audit.computeWasteWithTTIGraph(
+      resources, pageGraph, simulator);
     const wasteFcp =
       UsesHTTP2Audit.computeWasteWithGraph(resources,
         fcpGraph, simulator, {label: 'fcp'});
@@ -264,11 +296,11 @@ class UsesHTTP2Audit extends Audit {
     ];
 
     const details = Audit.makeOpportunityDetails(headings, resources,
-      {overallSavingsMs: wasteLcp.savings});
+      {overallSavingsMs: wastedMsTti});
 
     return {
       displayValue,
-      numericValue: wasteLcp.savings,
+      numericValue: wastedMsTti,
       numericUnit: 'millisecond',
       score: resources.length ? 0 : 1,
       details,

package/core/audits/layout-shift-elements.d.ts

@@ -0,0 +1,16 @@
+export default LayoutShiftElements;
+declare class LayoutShiftElements 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>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const columnContribution: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=layout-shift-elements.d.ts.map

package/core/audits/layout-shift-elements.js

@@ -0,0 +1,101 @@
+/**
+ * @license Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {CumulativeLayoutShift as CumulativeLayoutShiftComputed} from '../computed/metrics/cumulative-layout-shift.js';
+import CumulativeLayoutShift from './metrics/cumulative-layout-shift.js';
+
+const UIStrings = {
+  /** Descriptive title of a diagnostic audit that provides the top elements affected by layout shifts. */
+  title: 'Avoid large layout shifts',
+  /** Description of a diagnostic audit that provides the top elements affected by layout shifts. "windowing" means the metric value is calculated using the subset of events in a small window of time during the run. "normalization" is a good substitute for "windowing". The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'These DOM elements were most affected by layout shifts. Some layout shifts may not be included in the CLS metric value due to [windowing](https://web.dev/articles/cls#what_is_cls). [Learn how to improve CLS](https://web.dev/articles/optimize-cls)',
+  /**  Label for a column in a data table; entries in this column will be the amount that the corresponding element affected by layout shifts. */
+  columnContribution: 'Layout shift impact',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LayoutShiftElements extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'layout-shift-elements',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
+      guidanceLevel: 2,
+      requiredArtifacts: ['traces', 'TraceElements'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const {cumulativeLayoutShift: clsSavings, impactByNodeId} =
+      await CumulativeLayoutShiftComputed.request(artifacts.traces[Audit.DEFAULT_PASS], context);
+
+    /** @type {Array<{node: LH.Audit.Details.ItemValue, score: number}>} */
+    const clsElementData = artifacts.TraceElements
+      .filter(element => element.traceEventType === 'layout-shift-element')
+      .map(element => ({
+        node: Audit.makeNodeItem(element.node),
+        score: impactByNodeId.get(element.nodeId) || 0,
+      }));
+
+    if (clsElementData.length < impactByNodeId.size) {
+      const displayedNodeImpact = clsElementData.reduce((sum, {score}) => sum += score, 0);
+
+      // This is not necessarily the same as CLS due to normalization.
+      const totalNodeImpact = Array.from(impactByNodeId.values())
+        .reduce((sum, score) => sum + score);
+
+      clsElementData.push({
+        node: {
+          type: 'code',
+          value: str_(i18n.UIStrings.otherResourceType),
+        },
+        score: totalNodeImpact - displayedNodeImpact,
+      });
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'node', valueType: 'node', label: str_(i18n.UIStrings.columnElement)},
+      {key: 'score', valueType: 'numeric',
+        granularity: 0.001, label: str_(UIStrings.columnContribution)},
+    ];
+
+    const details = Audit.makeTableDetails(headings, clsElementData);
+
+    let displayValue;
+    if (impactByNodeId.size > 0) {
+      displayValue = str_(i18n.UIStrings.displayValueElementsFound,
+        {nodeCount: impactByNodeId.size});
+    }
+
+    const passed = clsSavings <= CumulativeLayoutShift.defaultOptions.p10;
+
+    return {
+      score: passed ? 1 : 0,
+      scoreDisplayMode: passed ? Audit.SCORING_MODES.INFORMATIVE : undefined,
+      metricSavings: {
+        CLS: clsSavings,
+      },
+      notApplicable: details.items.length === 0,
+      displayValue,
+      details,
+    };
+  }
+}
+
+export default LayoutShiftElements;
+export {UIStrings};

package/core/audits/no-unload-listeners.d.ts

@@ -0,0 +1,16 @@
+export default NoUnloadListeners;
+declare class NoUnloadListeners 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>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=no-unload-listeners.d.ts.map

package/core/audits/no-unload-listeners.js

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {Audit} from './audit.js';
+import {JSBundles} from '../computed/js-bundles.js';
+import * as i18n from './../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Descriptive title of a Lighthouse audit that checks if a web page has 'unload' event listeners and finds none. */
+  title: 'Avoids `unload` event listeners',
+  /** Descriptive title of a Lighthouse audit that checks if a web page has 'unload' event listeners and finds that it is using them. */
+  failureTitle: 'Registers an `unload` listener',
+  /** Description of a Lighthouse audit that tells the user why pages should not use the 'unload' event. This is displayed after a user expands the section to see more. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'The `unload` event does not fire reliably and listening for it can prevent browser optimizations like the Back-Forward Cache. Use `pagehide` or `visibilitychange` events instead. [Learn more about unload event listeners](https://web.dev/articles/bfcache#never_use_the_unload_event)',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class NoUnloadListeners extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'no-unload-listeners',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['GlobalListeners', 'SourceMaps', 'Scripts'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const unloadListeners = artifacts.GlobalListeners.filter(l => l.type === 'unload');
+    if (!unloadListeners.length) {
+      return {
+        score: 1,
+      };
+    }
+
+    const bundles = await JSBundles.request(artifacts, context);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'source', valueType: 'source-location', label: str_(i18n.UIStrings.columnSource)},
+    ];
+
+    /** @type {Array<{source: LH.Audit.Details.ItemValue}>} */
+    const tableItems = unloadListeners.map(listener => {
+      const {lineNumber, columnNumber} = listener;
+      const script = artifacts.Scripts.find(s => s.scriptId === listener.scriptId);
+
+      // If we can't find a url, still show something so the user can manually
+      // look for where an `unload` handler is being created.
+      if (!script) {
+        return {
+          source: {
+            type: 'url',
+            value: `(unknown):${lineNumber}:${columnNumber}`,
+          },
+        };
+      }
+
+      const bundle = bundles.find(bundle => bundle.script.scriptId === script.scriptId);
+      return {
+        source: Audit.makeSourceLocation(script.url, lineNumber, columnNumber, bundle),
+      };
+    });
+
+    return {
+      score: 0,
+      details: Audit.makeTableDetails(headings, tableItems),
+    };
+  }
+}
+
+export default NoUnloadListeners;
+export {UIStrings};

package/core/audits/preload-fonts.d.ts

@@ -14,7 +14,11 @@ declare class PreloadFontsAudit extends Audit {
      * @param {LH.Audit.Context} context
      * @return {Promise<LH.Audit.Product>}
      */
-    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+    static audit_(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+    /**
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(): Promise<LH.Audit.Product>;
 }
 export namespace UIStrings {
     const title: string;

package/core/audits/preload-fonts.js

@@ -62,7 +62,7 @@ class PreloadFontsAudit extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit(artifacts, context) {
+  static async audit_(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[this.DEFAULT_PASS];
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
 
@@ -91,6 +91,15 @@ class PreloadFontsAudit extends Audit {
       notApplicable: optionalFontURLs.size === 0,
     };
   }
+
+  /**
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit() {
+    // Preload advice is on hold until https://github.com/GoogleChrome/lighthouse/issues/11960
+    // is resolved.
+    return {score: 1, notApplicable: true};
+  }
 }
 
 export default PreloadFontsAudit;

package/core/audits/script-elements-test-audit.d.ts

@@ -0,0 +1,14 @@
+declare namespace _default {
+    namespace meta {
+        const id: string;
+        const title: string;
+        const failureTitle: string;
+        const description: string;
+        const requiredArtifacts: string[];
+    }
+    function audit(): {
+        score: number;
+    };
+}
+export default _default;
+//# sourceMappingURL=script-elements-test-audit.d.ts.map

package/core/audits/script-elements-test-audit.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview This is a fake audit used exclusively in smoke tests to force inclusion of ScriptElements artifact.
+ * It is included here for complex reasons in the way the bundled smoketests work.
+ *
+ * The smokehouse configs are evaluated first in the node CLI side (which requires an absolute path using LH_ROOT).
+ * The smokehouse configs are then *re-evaluated* in the bundled context for execution by Lighthouse (which *cannot* use an absolute path using LH_ROOT).
+ *
+ * This mismatch in environment demands that the audit path in the config must be context-aware,
+ * yet the require-graph for the config is included before even the CLI knows that it will be using
+ * a bundled runner. Rather than force a massive smoketest architecture change, we include a harmless,
+ * test-only audit in our core list instead.
+ */
+
+export default {
+  meta: {
+    id: 'script-elements-test-audit',
+    title: 'ScriptElements',
+    failureTitle: 'ScriptElements',
+    description: 'Audit to force the inclusion of ScriptElements artifact',
+    requiredArtifacts: ['ScriptElements'],
+  },
+  audit: () => ({score: 1}),
+};

package/core/audits/seo/is-crawlable.d.ts

@@ -6,12 +6,11 @@ declare class IsCrawlable extends Audit {
     static handleMetaElement(metaElement: LH.Artifacts.MetaElement): {
         source: {
             snippet: string;
-            /** @type {Array<string|undefined>} */
             type: "node";
             lhId?: string | undefined;
             path?: string | undefined;
             selector?: string | undefined;
-            boundingRect?: import("../../../types/lhr/audit-details.js").default.Rect | undefined; /** @type {Array<string|undefined>} */
+            boundingRect?: import("../../../types/lhr/audit-details.js").default.Rect | undefined;
             nodeLabel?: string | undefined;
         };
     } | undefined;