lighthouse 11.0.0 → 11.1.0

package/core/computed/tbt-impact-tasks.d.ts

@@ -1,14 +1,9 @@
 export { TBTImpactTasksComputed as TBTImpactTasks };
-export type TBTImpactTask = LH.Artifacts.TaskNode & {
-    tbtImpact: number;
-    selfTbtImpact: number;
-};
 declare const TBTImpactTasksComputed: typeof TBTImpactTasks & {
     request: (dependencies: import("../index.js").Artifacts.MetricComputationDataInput, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<TBTImpactTask[]>;
+    }>) => Promise<import("../index.js").Artifacts.TBTImpactTask[]>;
 };
-/** @typedef {LH.Artifacts.TaskNode & {tbtImpact: number, selfTbtImpact: number}} TBTImpactTask */
 declare class TBTImpactTasks {
     /**
      * @param {LH.Artifacts.TaskNode} task
@@ -28,27 +23,27 @@ declare class TBTImpactTasks {
      * @param {LH.Artifacts.TaskNode[]} tasks
      * @param {Map<LH.Artifacts.TaskNode, number>} taskToImpact
      */
-    static createImpactTasks(tasks: LH.Artifacts.TaskNode[], taskToImpact: Map<LH.Artifacts.TaskNode, number>): TBTImpactTask[];
+    static createImpactTasks(tasks: LH.Artifacts.TaskNode[], taskToImpact: Map<LH.Artifacts.TaskNode, number>): import("../index.js").Artifacts.TBTImpactTask[];
     /**
      * @param {LH.Artifacts.TaskNode[]} tasks
      * @param {number} startTimeMs
      * @param {number} endTimeMs
-     * @return {TBTImpactTask[]}
+     * @return {LH.Artifacts.TBTImpactTask[]}
      */
-    static computeImpactsFromObservedTasks(tasks: LH.Artifacts.TaskNode[], startTimeMs: number, endTimeMs: number): TBTImpactTask[];
+    static computeImpactsFromObservedTasks(tasks: LH.Artifacts.TaskNode[], startTimeMs: number, endTimeMs: number): LH.Artifacts.TBTImpactTask[];
     /**
      * @param {LH.Artifacts.TaskNode[]} tasks
      * @param {LH.Gatherer.Simulation.Result['nodeTimings']} tbtNodeTimings
      * @param {number} startTimeMs
      * @param {number} endTimeMs
-     * @return {TBTImpactTask[]}
+     * @return {LH.Artifacts.TBTImpactTask[]}
      */
-    static computeImpactsFromLantern(tasks: LH.Artifacts.TaskNode[], tbtNodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], startTimeMs: number, endTimeMs: number): TBTImpactTask[];
+    static computeImpactsFromLantern(tasks: LH.Artifacts.TaskNode[], tbtNodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], startTimeMs: number, endTimeMs: number): LH.Artifacts.TBTImpactTask[];
     /**
      * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
      * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<TBTImpactTask[]>}
+     * @return {Promise<LH.Artifacts.TBTImpactTask[]>}
      */
-    static compute_(metricComputationData: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<TBTImpactTask[]>;
+    static compute_(metricComputationData: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.TBTImpactTask[]>;
 }
 //# sourceMappingURL=tbt-impact-tasks.d.ts.map

package/core/computed/tbt-impact-tasks.js

@@ -12,8 +12,6 @@ import {TotalBlockingTime} from './metrics/total-blocking-time.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {calculateTbtImpactForEvent} from './metrics/tbt-utils.js';
 
-/** @typedef {LH.Artifacts.TaskNode & {tbtImpact: number, selfTbtImpact: number}} TBTImpactTask */
-
 class TBTImpactTasks {
   /**
    * @param {LH.Artifacts.TaskNode} task
@@ -66,7 +64,7 @@ class TBTImpactTasks {
    * @param {Map<LH.Artifacts.TaskNode, number>} taskToImpact
    */
   static createImpactTasks(tasks, taskToImpact) {
-    /** @type {TBTImpactTask[]} */
+    /** @type {LH.Artifacts.TBTImpactTask[]} */
     const tbtImpactTasks = [];
 
     for (const task of tasks) {
@@ -92,7 +90,7 @@ class TBTImpactTasks {
    * @param {LH.Artifacts.TaskNode[]} tasks
    * @param {number} startTimeMs
    * @param {number} endTimeMs
-   * @return {TBTImpactTask[]}
+   * @return {LH.Artifacts.TBTImpactTask[]}
    */
   static computeImpactsFromObservedTasks(tasks, startTimeMs, endTimeMs) {
     /** @type {Map<LH.Artifacts.TaskNode, number>} */
@@ -125,7 +123,7 @@ class TBTImpactTasks {
    * @param {LH.Gatherer.Simulation.Result['nodeTimings']} tbtNodeTimings
    * @param {number} startTimeMs
    * @param {number} endTimeMs
-   * @return {TBTImpactTask[]}
+   * @return {LH.Artifacts.TBTImpactTask[]}
    */
   static computeImpactsFromLantern(tasks, tbtNodeTimings, startTimeMs, endTimeMs) {
     /** @type {Map<LH.Artifacts.TaskNode, number>} */
@@ -193,7 +191,7 @@ class TBTImpactTasks {
   /**
    * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<TBTImpactTask[]>}
+   * @return {Promise<LH.Artifacts.TBTImpactTask[]>}
    */
   static async compute_(metricComputationData, context) {
     const tbtResult = await TotalBlockingTime.request(metricComputationData, context);

package/core/computed/viewport-meta.js

@@ -35,7 +35,17 @@ class ViewportMeta {
     }
 
     const viewportProps = parsedProps.validProperties;
-    const isMobileOptimized = Boolean(viewportProps.width || viewportProps['initial-scale']);
+    const initialScale = Number(viewportProps['initial-scale']);
+
+    if (!isNaN(initialScale) && initialScale < 1) {
+      return {
+        hasViewportTag: true,
+        isMobileOptimized: false,
+        parserWarnings: warnings,
+      };
+    }
+
+    const isMobileOptimized = Boolean(viewportProps.width || initialScale);
 
     return {
       hasViewportTag: true,

package/core/config/config-helpers.js

@@ -16,7 +16,7 @@ import ConfigPlugin from './config-plugin.js';
 import {Runner} from '../runner.js';
 import * as i18n from '../lib/i18n/i18n.js';
 import * as validation from './validation.js';
-import {getModuleDirectory} from '../../esm-utils.js';
+import {getModuleDirectory} from '../../shared/esm-utils.js';
 
 const require = createRequire(import.meta.url);
 

package/core/config/config.js

@@ -28,7 +28,7 @@ import {
   mergeConfigFragment,
   mergeConfigFragmentArrayByKey,
 } from './config-helpers.js';
-import {getModuleDirectory} from '../../esm-utils.js';
+import {getModuleDirectory} from '../../shared/esm-utils.js';
 import * as format from '../../shared/localization/format.js';
 
 const defaultConfigPath = path.join(

package/core/gather/gatherers/accessibility.js

@@ -42,12 +42,17 @@ async function runA11yChecks() {
       'accesskeys': {enabled: true},
       'area-alt': {enabled: false},
       'aria-allowed-role': {enabled: true},
+      'aria-braille-equivalent': {enabled: false},
+      'aria-conditional-attr': {enabled: false},
+      'aria-deprecated-role': {enabled: false},
       'aria-dialog-name': {enabled: true},
+      'aria-prohibited-attr': {enabled: false},
       'aria-roledescription': {enabled: false},
       'aria-treeitem-name': {enabled: true},
       'aria-text': {enabled: true},
       'audio-caption': {enabled: false},
       'blink': {enabled: false},
+      'duplicate-id-active': {enabled: true},
       'duplicate-id': {enabled: false},
       'empty-heading': {enabled: true},
       'frame-focusable-content': {enabled: false},

package/core/gather/timespan-runner.d.ts

@@ -9,4 +9,7 @@ export function startTimespanGather(page: LH.Puppeteer.Page, options?: {
 } | undefined): Promise<{
     endTimespanGather(): Promise<LH.Gatherer.GatherResult>;
 }>;
+export namespace UIStrings {
+    const warningNavigationDetected: string;
+}
 //# sourceMappingURL=timespan-runner.d.ts.map

package/core/gather/timespan-runner.js

@@ -12,6 +12,16 @@ import {getEmptyArtifactState, collectPhaseArtifacts, awaitArtifacts} from './ru
 import {enableAsyncStacks, prepareTargetForTimespanMode} from './driver/prepare.js';
 import {initializeConfig} from '../config/config.js';
 import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+/* eslint-disable max-len */
+const UIStrings = {
+  /** A warning that indicates page navigations should be audited using navigation mode, as opposed to timespan mode. "navigation mode" refers to a Lighthouse mode that analyzes a page navigation. "timespan mode" refers to a Lighthouse mode that analyzes user interactions over an arbitrary period of time. */
+  warningNavigationDetected: 'A page navigation was detected during the run. Using timespan mode to audit page navigations is not recommended. Use navigation mode to audit page navigations for better third-party attribution and main thread detection.',
+};
+/* eslint-enable max-len */
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 
 /**
  * @param {LH.Puppeteer.Page} page
@@ -45,6 +55,13 @@ async function startTimespanGather(page, options = {}) {
 
   await prepareTargetForTimespanMode(driver, resolvedConfig.settings);
 
+  let pageNavigationDetected = false;
+  function onFrameNavigated() {
+    pageNavigationDetected = true;
+  }
+
+  driver.defaultSession.on('Page.frameNavigated', onFrameNavigated);
+
   const disableAsyncStacks = await enableAsyncStacks(driver.defaultSession);
 
   await collectPhaseArtifacts({phase: 'startInstrumentation', ...phaseOptions});
@@ -67,6 +84,11 @@ async function startTimespanGather(page, options = {}) {
           // We should disable our `Page.frameNavigated` handlers before that.
           await disableAsyncStacks();
 
+          driver.defaultSession.off('Page.frameNavigated', onFrameNavigated);
+          if (pageNavigationDetected) {
+            baseArtifacts.LighthouseRunWarnings.push(str_(UIStrings.warningNavigationDetected));
+          }
+
           await collectPhaseArtifacts({phase: 'getArtifact', ...phaseOptions});
           await driver.disconnect();
 
@@ -82,4 +104,5 @@ async function startTimespanGather(page, options = {}) {
 
 export {
   startTimespanGather,
+  UIStrings,
 };

package/core/index.cjs

@@ -5,38 +5,38 @@
  */
 'use strict';
 
-/** @type {import('./index.js')['default']} */
+/**
+ * @typedef ExportType
+ * @property {import('./index.js')['startFlow']} startFlow
+ * @property {import('./index.js')['navigation']} navigation
+ * @property {import('./index.js')['startTimespan']} startTimespan
+ * @property {import('./index.js')['snapshot']} snapshot
+ */
+
+/** @type {import('./index.js')['default'] & ExportType} */
 const lighthouse = async function lighthouse(...args) {
   const {default: lighthouse} = await import('./index.js');
   return lighthouse(...args);
 };
 
-/** @type {import('./index.js')['startFlow']} */
-const startFlow = async function startFlow(...args) {
+lighthouse.startFlow = async function startFlow(...args) {
   const {startFlow} = await import('./index.js');
   return startFlow(...args);
 };
 
-/** @type {import('./index.js')['navigation']} */
-const navigation = async function navigation(...args) {
+lighthouse.navigation = async function navigation(...args) {
   const {navigation} = await import('./index.js');
   return navigation(...args);
 };
 
-/** @type {import('./index.js')['startTimespan']} */
-const startTimespan = async function startTimespan(...args) {
+lighthouse.startTimespan = async function startTimespan(...args) {
   const {startTimespan} = await import('./index.js');
   return startTimespan(...args);
 };
 
-/** @type {import('./index.js')['snapshot']} */
-const snapshot = async function snapshot(...args) {
+lighthouse.snapshot = async function snapshot(...args) {
   const {snapshot} = await import('./index.js');
   return snapshot(...args);
 };
 
 module.exports = lighthouse;
-module.exports.startFlow = startFlow;
-module.exports.navigation = navigation;
-module.exports.startTimespan = startTimespan;
-module.exports.snapshot = snapshot;

package/core/index.d.cts

@@ -1,4 +1,17 @@
 export = lighthouse;
-/** @type {import('./index.js')['default']} */
-declare const lighthouse: typeof import("./index.js")['default'];
+/**
+ * @typedef ExportType
+ * @property {import('./index.js')['startFlow']} startFlow
+ * @property {import('./index.js')['navigation']} navigation
+ * @property {import('./index.js')['startTimespan']} startTimespan
+ * @property {import('./index.js')['snapshot']} snapshot
+ */
+/** @type {import('./index.js')['default'] & ExportType} */
+declare const lighthouse: typeof import("./index.js")['default'] & ExportType;
+type ExportType = {
+    startFlow: typeof import("./index.js")['startFlow'];
+    navigation: typeof import("./index.js")['navigation'];
+    startTimespan: typeof import("./index.js")['startTimespan'];
+    snapshot: typeof import("./index.js")['snapshot'];
+};
 //# sourceMappingURL=index.d.cts.map

package/core/lib/asset-saver.d.ts

@@ -1,5 +1,4 @@
 export type PreparedAssets = {
-    passName: string;
     traceData: LH.Trace;
     devtoolsLog: import("../index.js").DevtoolsLog;
 };
@@ -35,7 +34,6 @@ export function saveFlowArtifacts(flowArtifacts: LH.UserFlow.FlowArtifacts, base
 export function saveLhr(lhr: LH.Result, basePath: string): void;
 /**
  * @typedef {object} PreparedAssets
- * @property {string} passName
  * @property {LH.Trace} traceData
  * @property {LH.DevtoolsLog} devtoolsLog
  */
@@ -60,7 +58,6 @@ export function loadFlowArtifacts(basePath: string): LH.UserFlow.FlowArtifacts;
  */
 export function saveAssets(artifacts: LH.Artifacts, audits: LH.Result['audits'], pathWithBasename: string): Promise<void>;
 /**
- * Filter traces and extract screenshots to prepare for saving.
  * @param {LH.Artifacts} artifacts
  * @param {LH.Result['audits']} [audits]
  * @return {Promise<Array<PreparedAssets>>}

package/core/lib/asset-saver.js

@@ -17,17 +17,18 @@ import {MetricTraceEvents} from './traces/metric-trace-events.js';
 import {NetworkAnalysis} from '../computed/network-analysis.js';
 import {LoadSimulator} from '../computed/load-simulator.js';
 import {LighthouseError} from '../lib/lh-error.js';
-import {LH_ROOT} from '../../root.js';
+import {LH_ROOT} from '../../shared/root.js';
 
 const optionsFilename = 'options.json';
 const artifactsFilename = 'artifacts.json';
 const traceSuffix = '.trace.json';
 const devtoolsLogSuffix = '.devtoolslog.json';
+const defaultPrefix = 'defaultPass';
+const errorPrefix = 'pageLoadError-defaultPass';
 const stepDirectoryRegex = /^step(\d+)$/;
 
 /**
  * @typedef {object} PreparedAssets
- * @property {string} passName
  * @property {LH.Trace} traceData
  * @property {LH.DevtoolsLog} devtoolsLog
  */
@@ -53,32 +54,30 @@ function loadArtifacts(basePath) {
 
   const filenames = fs.readdirSync(basePath);
 
-  // load devtoolsLogs
-  artifacts.devtoolsLogs = {};
   filenames.filter(f => f.endsWith(devtoolsLogSuffix)).forEach(filename => {
-    const passName = filename.replace(devtoolsLogSuffix, '');
+    if (!artifacts.devtoolsLogs) artifacts.devtoolsLogs = {};
+    const prefix = filename.replace(devtoolsLogSuffix, '');
     const devtoolsLog = JSON.parse(fs.readFileSync(path.join(basePath, filename), 'utf8'));
-    artifacts.devtoolsLogs[passName] = devtoolsLog;
-    if (passName === 'defaultPass') {
+    artifacts.devtoolsLogs[prefix] = devtoolsLog;
+    if (prefix === defaultPrefix) {
       artifacts.DevtoolsLog = devtoolsLog;
     }
-    if (passName === 'pageLoadError-defaultPass') {
+    if (prefix === errorPrefix) {
       artifacts.DevtoolsLogError = devtoolsLog;
     }
   });
 
-  // load traces
-  artifacts.traces = {};
   filenames.filter(f => f.endsWith(traceSuffix)).forEach(filename => {
+    if (!artifacts.traces) artifacts.traces = {};
     const file = fs.readFileSync(path.join(basePath, filename), {encoding: 'utf-8'});
     const trace = JSON.parse(file);
-    const passName = filename.replace(traceSuffix, '');
-    artifacts.traces[passName] = Array.isArray(trace) ? {traceEvents: trace} : trace;
-    if (passName === 'defaultPass') {
-      artifacts.Trace = artifacts.traces[passName];
+    const prefix = filename.replace(traceSuffix, '');
+    artifacts.traces[prefix] = Array.isArray(trace) ? {traceEvents: trace} : trace;
+    if (prefix === defaultPrefix) {
+      artifacts.Trace = artifacts.traces[prefix];
     }
-    if (passName === 'pageLoadError-defaultPass') {
-      artifacts.TraceError = artifacts.traces[passName];
+    if (prefix === errorPrefix) {
+      artifacts.TraceError = artifacts.traces[prefix];
     }
   });
 
@@ -220,23 +219,34 @@ async function saveArtifacts(artifacts, basePath) {
     }
   }
 
-  // `DevtoolsLog` and `Trace` will always be the 'defaultPass' version.
+  // `devtoolsLogs` and `traces` are duplicate compat artifacts.
   // We don't need to save them twice, so extract them here.
-  // eslint-disable-next-line no-unused-vars
-  const {traces, devtoolsLogs, DevtoolsLog, Trace, ...restArtifacts} = artifacts;
+  const {
+    // eslint-disable-next-line no-unused-vars
+    traces,
+    // eslint-disable-next-line no-unused-vars
+    devtoolsLogs,
+    DevtoolsLog,
+    Trace,
+    DevtoolsLogError,
+    TraceError,
+    ...restArtifacts
+  } = artifacts;
+
+  if (Trace) {
+    await saveTrace(Trace, `${basePath}/${defaultPrefix}${traceSuffix}`);
+  }
 
-  // save traces
-  if (traces) {
-    for (const [passName, trace] of Object.entries(traces)) {
-      await saveTrace(trace, `${basePath}/${passName}${traceSuffix}`);
-    }
+  if (TraceError) {
+    await saveTrace(TraceError, `${basePath}/${errorPrefix}${traceSuffix}`);
   }
 
-  // save devtools log
-  if (devtoolsLogs) {
-    for (const [passName, devtoolsLog] of Object.entries(devtoolsLogs)) {
-      await saveDevtoolsLog(devtoolsLog, `${basePath}/${passName}${devtoolsLogSuffix}`);
-    }
+  if (DevtoolsLog) {
+    await saveDevtoolsLog(DevtoolsLog, `${basePath}/${defaultPrefix}${devtoolsLogSuffix}`);
+  }
+
+  if (DevtoolsLogError) {
+    await saveDevtoolsLog(DevtoolsLogError, `${basePath}/${errorPrefix}${devtoolsLogSuffix}`);
   }
 
   // save everything else, using a replacer to serialize LighthouseErrors in the artifacts.
@@ -256,33 +266,49 @@ function saveLhr(lhr, basePath) {
 }
 
 /**
- * Filter traces and extract screenshots to prepare for saving.
+ * Filter trace and extract screenshots to prepare for saving.
+ * @param {LH.Trace} trace
+ * @param {LH.Result['audits']} [audits]
+ * @return {LH.Trace}
+ */
+function prepareTraceAsset(trace, audits) {
+  if (!trace) return trace;
+
+  const traceData = Object.assign({}, trace);
+  if (audits) {
+    const evts = new MetricTraceEvents(traceData.traceEvents, audits).generateFakeEvents();
+    traceData.traceEvents = traceData.traceEvents.concat(evts);
+  }
+  return traceData;
+}
+
+/**
  * @param {LH.Artifacts} artifacts
  * @param {LH.Result['audits']} [audits]
  * @return {Promise<Array<PreparedAssets>>}
  */
 async function prepareAssets(artifacts, audits) {
-  const passNames = Object.keys(artifacts.traces);
   /** @type {Array<PreparedAssets>} */
   const assets = [];
 
-  for (const passName of passNames) {
-    const trace = artifacts.traces[passName];
-    const devtoolsLog = artifacts.devtoolsLogs[passName];
-
-    const traceData = Object.assign({}, trace);
-    if (audits) {
-      const evts = new MetricTraceEvents(traceData.traceEvents, audits).generateFakeEvents();
-      traceData.traceEvents = traceData.traceEvents.concat(evts);
-    }
-
+  const devtoolsLog = artifacts.DevtoolsLog;
+  const traceData = prepareTraceAsset(artifacts.Trace, audits);
+  if (traceData || devtoolsLog) {
     assets.push({
-      passName,
       traceData,
       devtoolsLog,
     });
   }
 
+  const devtoolsLogError = artifacts.DevtoolsLogError;
+  const traceErrorData = prepareTraceAsset(artifacts.TraceError, audits);
+  if (devtoolsLogError || traceErrorData) {
+    assets.push({
+      traceData: traceErrorData,
+      devtoolsLog: devtoolsLogError,
+    });
+  }
+
   return assets;
 }
 

package/core/lib/dependency-graph/simulator/network-analyzer.d.ts

@@ -174,9 +174,15 @@ export class NetworkAnalyzer {
      * @return {LH.Artifacts.NetworkRequest|undefined}
      */
     static findResourceForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @param {string} resourceUrl
+     * @return {LH.Artifacts.NetworkRequest|undefined}
+     */
+    static findLastDocumentForUrl(records: Array<LH.Artifacts.NetworkRequest>, resourceUrl: string): LH.Artifacts.NetworkRequest | undefined;
     /**
      * Resolves redirect chain given a main document.
-     * See: {@link NetworkAnalyzer.findResourceForUrl}) for how to retrieve main document.
+     * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
      *
      * @param {LH.Artifacts.NetworkRequest} request
      * @return {LH.Artifacts.NetworkRequest}

package/core/lib/dependency-graph/simulator/network-analyzer.js

@@ -506,9 +506,25 @@ class NetworkAnalyzer {
     );
   }
 
+  /**
+   * @param {Array<LH.Artifacts.NetworkRequest>} records
+   * @param {string} resourceUrl
+   * @return {LH.Artifacts.NetworkRequest|undefined}
+   */
+  static findLastDocumentForUrl(records, resourceUrl) {
+    // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
+    const matchingRequests = records.filter(request =>
+      request.resourceType === 'Document' &&
+      // Note: `request.url` should never have a fragment, else this optimization gives wrong results.
+      resourceUrl.startsWith(request.url) &&
+      UrlUtils.equalWithExcludedFragments(request.url, resourceUrl)
+    );
+    return matchingRequests[matchingRequests.length - 1];
+  }
+
   /**
    * Resolves redirect chain given a main document.
-   * See: {@link NetworkAnalyzer.findResourceForUrl}) for how to retrieve main document.
+   * See: {@link NetworkAnalyzer.findLastDocumentForUrl}) for how to retrieve main document.
    *
    * @param {LH.Artifacts.NetworkRequest} request
    * @return {LH.Artifacts.NetworkRequest}

package/core/lib/emulation.js

@@ -4,7 +4,7 @@
  * 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 {lighthouseVersion} from '../../root.js';
+import {lighthouseVersion} from '../../shared/root.js';
 
 const NO_THROTTLING_METRICS = {
   latency: 0,

package/core/lib/i18n/i18n.js

@@ -13,9 +13,9 @@ import lookupClosestLocale from 'lookup-closest-locale';
 import log from 'lighthouse-logger';
 
 import {getAvailableLocales} from '../../../shared/localization/format.js';
-import {LH_ROOT} from '../../../root.js';
+import {LH_ROOT} from '../../../shared/root.js';
 import {isIcuMessage, formatMessage, DEFAULT_LOCALE} from '../../../shared/localization/format.js';
-import {getModulePath} from '../../../esm-utils.js';
+import {getModulePath} from '../../../shared/esm-utils.js';
 
 const UIStrings = {
   /** Used to show the duration in milliseconds that something lasted. The `{timeInMs}` placeholder will be replaced with the time duration, shown in milliseconds (e.g. 63 ms) */

package/core/runner.js

@@ -19,8 +19,8 @@ import * as assetSaver from './lib/asset-saver.js';
 import {Sentry} from './lib/sentry.js';
 import {ReportGenerator} from '../report/generator/report-generator.js';
 import {LighthouseError} from './lib/lh-error.js';
-import {lighthouseVersion} from '../root.js';
-import {getModuleDirectory} from '../esm-utils.js';
+import {lighthouseVersion} from '../shared/root.js';
+import {getModuleDirectory} from '../shared/esm-utils.js';
 import {EntityClassification} from './computed/entity-classification.js';
 import UrlUtils from './lib/url-utils.js';
 
@@ -375,9 +375,10 @@ class Runner {
 
         // If trace/devtoolsLog required, check that DEFAULT_PASS trace/devtoolsLog exists.
         // NOTE: for now, not a pass-specific check of traces or devtoolsLogs.
-        const noRequiredTrace = artifactName === 'traces' && !artifacts.traces[Audit.DEFAULT_PASS];
+        const noRequiredTrace = artifactName === 'traces' &&
+          !artifacts.traces?.[Audit.DEFAULT_PASS];
         const noRequiredDevtoolsLog = artifactName === 'devtoolsLogs' &&
-            !artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+          !artifacts.devtoolsLogs?.[Audit.DEFAULT_PASS];
 
         if (noArtifact || noRequiredTrace || noRequiredDevtoolsLog) {
           log.warn('Runner',