lighthouse 12.0.0 → 12.1.0-dev.20240618

package/core/gather/gatherers/root-causes.js

@@ -114,7 +114,6 @@ class RootCauses extends BaseGatherer {
     const rootCausesEngine = new TraceEngine.RootCauses(protocolInterface);
     const layoutShiftEvents = traceParsedData.LayoutShifts.clusters.flatMap(c => c.events);
     for (const event of layoutShiftEvents) {
-      // @ts-expect-error The data we do get in the trace processor is still enough here
       const r = await rootCausesEngine.layoutShifts.rootCausesForEvent(traceParsedData, event);
       if (!r) continue;
 

package/core/gather/session.d.ts

@@ -17,7 +17,8 @@ export class ProtocolSession extends ProtocolSession_base implements LH.Gatherer
      * @param {E} method
      * @param {LH.CrdpEvents[E]} params
      */
-    _handleProtocolEvent<E extends keyof import("puppeteer-core").ProtocolMapping.Events>(method: E, ...params: import("puppeteer-core").ProtocolMapping.Events[E]): void;
+    _handleProtocolEvent<E extends keyof import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Events>(method: E, ...params: import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Events[E]): void;
+    _targetCrashedPromise: Promise<never>;
     id(): string;
     /** @param {LH.Crdp.Target.TargetInfo} targetInfo */
     setTargetInfo(targetInfo: LH.Crdp.Target.TargetInfo): void;
@@ -39,7 +40,7 @@ export class ProtocolSession extends ProtocolSession_base implements LH.Gatherer
      * @param {LH.CrdpCommands[C]['paramsType']} params
      * @return {Promise<LH.CrdpCommands[C]['returnType']>}
      */
-    sendCommand<C extends keyof import("puppeteer-core").ProtocolMapping.Commands>(method: C, ...params: import("puppeteer-core").ProtocolMapping.Commands[C]["paramsType"]): Promise<import("puppeteer-core").ProtocolMapping.Commands[C]["returnType"]>;
+    sendCommand<C extends keyof import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Commands>(method: C, ...params: import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Commands[C]["paramsType"]): Promise<import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Commands[C]["returnType"]>;
     /**
      * Send and if there's an error response, do not reject.
      * @template {keyof LH.CrdpCommands} C
@@ -47,12 +48,13 @@ export class ProtocolSession extends ProtocolSession_base implements LH.Gatherer
      * @param {LH.CrdpCommands[C]['paramsType']} params
      * @return {Promise<void>}
      */
-    sendCommandAndIgnore<C_1 extends keyof import("puppeteer-core").ProtocolMapping.Commands>(method: C_1, ...params: import("puppeteer-core").ProtocolMapping.Commands[C_1]["paramsType"]): Promise<void>;
+    sendCommandAndIgnore<C_1 extends keyof import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Commands>(method: C_1, ...params: import("devtools-protocol/types/protocol-mapping.js").ProtocolMapping.Commands[C_1]["paramsType"]): Promise<void>;
     /**
      * Disposes of a session so that it can no longer talk to Chrome.
      * @return {Promise<void>}
      */
     dispose(): Promise<void>;
+    onCrashPromise(): Promise<never>;
 }
 export {};
 //# sourceMappingURL=session.d.ts.map

package/core/gather/session.js

@@ -44,6 +44,22 @@ class ProtocolSession extends CrdpEventEmitter {
     this._handleProtocolEvent = this._handleProtocolEvent.bind(this);
     // @ts-expect-error Puppeteer expects the handler params to be type `unknown`
     this._cdpSession.on('*', this._handleProtocolEvent);
+
+    // If the target crashes, we can't continue gathering.
+    // FWIW, if the target unexpectedly detaches (eg the user closed the tab), pptr will
+    // catch that and reject in this._cdpSession.send, which is caught by us.
+    /** @param {Error} _ */
+    let rej = _ => {}; // Poor man's Promise.withResolvers()
+    this._targetCrashedPromise = /** @type {Promise<never>} */ (
+      new Promise((_, theRej) => rej = theRej));
+    this.on('Inspector.targetCrashed', async () => {
+      log.error('TargetManager', 'Inspector.targetCrashed');
+      // Manually detach so no more CDP traffic is attempted.
+      // Don't await, else our rejection will be a 'Target closed' protocol error on cross-talk
+      // CDP calls.
+      void this.dispose();
+      rej(new LighthouseError(LighthouseError.errors.TARGET_CRASHED));
+    });
   }
 
   id() {
@@ -114,7 +130,8 @@ class ProtocolSession extends CrdpEventEmitter {
       log.formatProtocol('method <= browser ERR', {method}, 'error');
       throw LighthouseError.fromProtocolMessage(method, error);
     });
-    const resultWithTimeoutPromise = Promise.race([resultPromise, timeoutPromise]);
+    const resultWithTimeoutPromise =
+      Promise.race([resultPromise, timeoutPromise, this._targetCrashedPromise]);
 
     return resultWithTimeoutPromise.finally(() => {
       if (timeout) clearTimeout(timeout);
@@ -142,6 +159,10 @@ class ProtocolSession extends CrdpEventEmitter {
     this._cdpSession.off('*', this._handleProtocolEvent);
     await this._cdpSession.detach().catch(e => log.verbose('session', 'detach failed', e.message));
   }
+
+  onCrashPromise() {
+    return this._targetCrashedPromise;
+  }
 }
 
 export {ProtocolSession};

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

@@ -4,12 +4,15 @@ export type PreparedAssets = {
 };
 /**
  * Save artifacts object mostly to single file located at basePath/artifacts.json.
- * Also save the traces & devtoolsLogs to their own files
+ * Also save the traces & devtoolsLogs to their own files, with optional compression.
  * @param {LH.Artifacts} artifacts
  * @param {string} basePath
+ * @param {{gzip?: boolean}} options
  * @return {Promise<void>}
  */
-export function saveArtifacts(artifacts: LH.Artifacts, basePath: string): Promise<void>;
+export function saveArtifacts(artifacts: LH.Artifacts, basePath: string, options?: {
+    gzip?: boolean;
+}): Promise<void>;
 /**
  * Saves flow artifacts with the following file structure:
  *   flow/                             --  Directory specified by `basePath`.
@@ -32,11 +35,6 @@ export function saveFlowArtifacts(flowArtifacts: LH.UserFlow.FlowArtifacts, base
  * @param {string} basePath
  */
 export function saveLhr(lhr: LH.Result, basePath: string): void;
-/**
- * @typedef {object} PreparedAssets
- * @property {LH.Trace} [traceData]
- * @property {LH.DevtoolsLog} [devtoolsLog]
- */
 /**
  * Load artifacts object from files located within basePath
  * Also save the traces to their own files
@@ -67,16 +65,22 @@ export function prepareAssets(artifacts: LH.Artifacts, audits?: Record<string, i
  * Save a trace as JSON by streaming to disk at traceFilename.
  * @param {LH.Trace} traceData
  * @param {string} traceFilename
+ * @param {{gzip?: boolean}=} options
  * @return {Promise<void>}
  */
-export function saveTrace(traceData: LH.Trace, traceFilename: string): Promise<void>;
+export function saveTrace(traceData: LH.Trace, traceFilename: string, options?: {
+    gzip?: boolean;
+} | undefined): Promise<void>;
 /**
  * Save a devtoolsLog as JSON by streaming to disk at devtoolLogFilename.
  * @param {LH.DevtoolsLog} devtoolsLog
  * @param {string} devtoolLogFilename
+ * @param {{gzip?: boolean}=} options
  * @return {Promise<void>}
  */
-export function saveDevtoolsLog(devtoolsLog: import("../index.js").DevtoolsLog, devtoolLogFilename: string): Promise<void>;
+export function saveDevtoolsLog(devtoolsLog: import("../index.js").DevtoolsLog, devtoolLogFilename: string, options?: {
+    gzip?: boolean;
+} | undefined): Promise<void>;
 /**
  * @param {LH.DevtoolsLog} devtoolsLog
  * @param {string} outputPath

package/core/lib/asset-saver.js

@@ -8,10 +8,11 @@ import fs from 'fs';
 import path from 'path';
 import stream from 'stream';
 import url from 'url';
+import {createGzip, gunzipSync} from 'zlib';
 
 import log from 'lighthouse-logger';
 
-import {Simulator} from './lantern/simulator/simulator.js';
+import * as Lantern from './lantern/lantern.js';
 import lanternTraceSaver from './lantern-trace-saver.js';
 import {MetricTraceEvents} from './traces/metric-trace-events.js';
 import {NetworkAnalysis} from '../computed/network-analysis.js';
@@ -33,6 +34,46 @@ const stepDirectoryRegex = /^step(\d+)$/;
  * @property {LH.DevtoolsLog} [devtoolsLog]
  */
 
+/**
+ * @param {import('stream').PipelineSource<any>} contents
+ * @param {string} path
+ * @param {boolean} gzip
+ */
+async function writeJson(contents, path, gzip) {
+  const writeStream = fs.createWriteStream(gzip ? path + '.gz' : path);
+  if (gzip) {
+    await stream.promises.pipeline(contents, createGzip(), writeStream);
+  } else {
+    await stream.promises.pipeline(contents, writeStream);
+  }
+}
+
+/**
+ * Prefers reading a gzipped file (.gz) if present.
+ * @param {string} filename
+ * @param {(this: any, key: string, value: any) => any=} reviver
+ */
+function readJson(filename, reviver) {
+  if (fs.existsSync(filename + '.gz')) {
+    filename = filename + '.gz';
+  }
+
+  if (!filename.endsWith('.json.gz')) {
+    return JSON.parse(fs.readFileSync(filename, 'utf8'), reviver);
+  }
+
+  const buffer = gunzipSync(fs.readFileSync(filename));
+  return JSON.parse(buffer.toString('utf8'), reviver);
+}
+
+/**
+ * @param {string} filename
+ * @param {string} suffix
+ * @returns
+ */
+function endsWithSuffix(filename, suffix) {
+  return filename.endsWith(suffix) || filename.endsWith(suffix + '.gz');
+}
 
 /**
  * Load artifacts object from files located within basePath
@@ -48,16 +89,15 @@ function loadArtifacts(basePath) {
   }
 
   // load artifacts.json using a reviver to deserialize any LighthouseErrors in artifacts.
-  const artifactsStr = fs.readFileSync(path.join(basePath, artifactsFilename), 'utf8');
   /** @type {LH.Artifacts} */
-  const artifacts = JSON.parse(artifactsStr, LighthouseError.parseReviver);
+  const artifacts = readJson(path.join(basePath, artifactsFilename), LighthouseError.parseReviver);
 
   const filenames = fs.readdirSync(basePath);
 
-  filenames.filter(f => f.endsWith(devtoolsLogSuffix)).forEach(filename => {
+  filenames.filter(f => endsWithSuffix(f, devtoolsLogSuffix)).forEach(filename => {
     if (!artifacts.devtoolsLogs) artifacts.devtoolsLogs = {};
-    const prefix = filename.replace(devtoolsLogSuffix, '');
-    const devtoolsLog = JSON.parse(fs.readFileSync(path.join(basePath, filename), 'utf8'));
+    const prefix = filename.replace(devtoolsLogSuffix + '.gz', '').replace(devtoolsLogSuffix, '');
+    const devtoolsLog = readJson(path.join(basePath, filename));
     artifacts.devtoolsLogs[prefix] = devtoolsLog;
     if (prefix === defaultPrefix) {
       artifacts.DevtoolsLog = devtoolsLog;
@@ -67,11 +107,10 @@ function loadArtifacts(basePath) {
     }
   });
 
-  filenames.filter(f => f.endsWith(traceSuffix)).forEach(filename => {
+  filenames.filter(f => endsWithSuffix(f, 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 prefix = filename.replace(traceSuffix, '');
+    const trace = readJson(path.join(basePath, filename));
+    const prefix = filename.replace(traceSuffix + '.gz', '').replace(traceSuffix, '');
     artifacts.traces[prefix] = Array.isArray(trace) ? {traceEvents: trace} : trace;
     if (prefix === defaultPrefix) {
       artifacts.Trace = artifacts.traces[prefix];
@@ -200,12 +239,13 @@ async function saveFlowArtifacts(flowArtifacts, basePath) {
 
 /**
  * Save artifacts object mostly to single file located at basePath/artifacts.json.
- * Also save the traces & devtoolsLogs to their own files
+ * Also save the traces & devtoolsLogs to their own files, with optional compression.
  * @param {LH.Artifacts} artifacts
  * @param {string} basePath
+ * @param {{gzip?: boolean}} options
  * @return {Promise<void>}
  */
-async function saveArtifacts(artifacts, basePath) {
+async function saveArtifacts(artifacts, basePath, options = {}) {
   const status = {msg: 'Saving artifacts', id: 'lh:assetSaver:saveArtifacts'};
   log.time(status);
   fs.mkdirSync(basePath, {recursive: true});
@@ -213,8 +253,11 @@ async function saveArtifacts(artifacts, basePath) {
   // Delete any previous artifacts in this directory.
   const filenames = fs.readdirSync(basePath);
   for (const filename of filenames) {
-    if (filename.endsWith(traceSuffix) || filename.endsWith(devtoolsLogSuffix) ||
-        filename === artifactsFilename) {
+    const isPreviousFile =
+      filename.endsWith(traceSuffix) || filename.endsWith(devtoolsLogSuffix) ||
+      filename.endsWith(traceSuffix + '.gz') || filename.endsWith(devtoolsLogSuffix + '.gz') ||
+      filename === artifactsFilename || filename === artifactsFilename + '.gz';
+    if (isPreviousFile) {
       fs.unlinkSync(`${basePath}/${filename}`);
     }
   }
@@ -234,24 +277,30 @@ async function saveArtifacts(artifacts, basePath) {
   } = artifacts;
 
   if (Trace) {
-    await saveTrace(Trace, `${basePath}/${defaultPrefix}${traceSuffix}`);
+    await saveTrace(Trace, `${basePath}/${defaultPrefix}${traceSuffix}`, options);
   }
 
   if (TraceError) {
-    await saveTrace(TraceError, `${basePath}/${errorPrefix}${traceSuffix}`);
+    await saveTrace(TraceError, `${basePath}/${errorPrefix}${traceSuffix}`, options);
   }
 
   if (DevtoolsLog) {
-    await saveDevtoolsLog(DevtoolsLog, `${basePath}/${defaultPrefix}${devtoolsLogSuffix}`);
+    await saveDevtoolsLog(
+      DevtoolsLog, `${basePath}/${defaultPrefix}${devtoolsLogSuffix}`, options);
   }
 
   if (DevtoolsLogError) {
-    await saveDevtoolsLog(DevtoolsLogError, `${basePath}/${errorPrefix}${devtoolsLogSuffix}`);
+    await saveDevtoolsLog(
+      DevtoolsLogError, `${basePath}/${errorPrefix}${devtoolsLogSuffix}`, options);
   }
 
   // save everything else, using a replacer to serialize LighthouseErrors in the artifacts.
-  const restArtifactsString = JSON.stringify(restArtifacts, stringifyReplacer, 2) + '\n';
-  fs.writeFileSync(`${basePath}/${artifactsFilename}`, restArtifactsString, 'utf8');
+  const restArtifactsString = JSON.stringify(restArtifacts, stringifyReplacer, 2);
+  await writeJson(function* () {
+    yield restArtifactsString;
+    yield '\n';
+  }, `${basePath}/${artifactsFilename}`, !!options.gzip);
+
   log.log('Artifacts saved to disk in folder:', basePath);
   log.timeEnd(status);
 }
@@ -371,28 +420,26 @@ function* traceJsonGenerator(traceData) {
  * Save a trace as JSON by streaming to disk at traceFilename.
  * @param {LH.Trace} traceData
  * @param {string} traceFilename
+ * @param {{gzip?: boolean}=} options
  * @return {Promise<void>}
  */
-async function saveTrace(traceData, traceFilename) {
+function saveTrace(traceData, traceFilename, options = {}) {
   const traceIter = traceJsonGenerator(traceData);
-  const writeStream = fs.createWriteStream(traceFilename);
-
-  return stream.promises.pipeline(traceIter, writeStream);
+  return writeJson(traceIter, traceFilename, !!options.gzip);
 }
 
 /**
  * Save a devtoolsLog as JSON by streaming to disk at devtoolLogFilename.
  * @param {LH.DevtoolsLog} devtoolsLog
  * @param {string} devtoolLogFilename
+ * @param {{gzip?: boolean}=} options
  * @return {Promise<void>}
  */
-function saveDevtoolsLog(devtoolsLog, devtoolLogFilename) {
-  const writeStream = fs.createWriteStream(devtoolLogFilename);
-
-  return stream.promises.pipeline(function* () {
+function saveDevtoolsLog(devtoolsLog, devtoolLogFilename, options = {}) {
+  return writeJson(function* () {
     yield* arrayOfObjectsJsonGenerator(devtoolsLog);
     yield '\n';
-  }, writeStream);
+  }, devtoolLogFilename, !!options.gzip);
 }
 
 /**
@@ -402,7 +449,7 @@ function saveDevtoolsLog(devtoolsLog, devtoolLogFilename) {
 async function saveLanternDebugTraces(pathWithBasename) {
   if (!process.env.LANTERN_DEBUG) return;
 
-  for (const [label, nodeTimings] of Simulator.ALL_NODE_TIMINGS) {
+  for (const [label, nodeTimings] of Lantern.Simulation.Simulator.ALL_NODE_TIMINGS) {
     if (lanternTraceSaver.simulationNamesToIgnore.includes(label)) continue;
 
     const traceFilename = `${pathWithBasename}-${label}${traceSuffix}`;

package/core/lib/bf-cache-strings.js

@@ -380,7 +380,7 @@ const UIStrings = {
   /**
    * @description Description text for not restored reason NotMainFrame.
    */
-  contentWebAuthenticationAPI: 'Pages that use WebAuthetication API are not eligible for back/forward cache.',
+  contentWebAuthenticationAPI: 'Pages that use WebAuthentication API are not eligible for back/forward cache.',
   /**
    * @description Description text for not restored reason NotMainFrame.
    */
@@ -674,4 +674,4 @@ const NotRestoredReasonDescription = {
 export {
   NotRestoredReasonDescription,
   UIStrings,
-};
+};

package/core/lib/lantern/{base-node.d.ts → BaseNode.d.ts}

@@ -2,7 +2,7 @@
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  */
-export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>;
+export type Node<T = any> = import('./CpuNode.js').CPUNode<T> | import('./NetworkNode.js').NetworkNode<T>;
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -12,7 +12,7 @@ export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./netwo
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  * @template [T=any]
- * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
+ * @typedef {import('./CpuNode.js').CPUNode<T> | import('./NetworkNode.js').NetworkNode<T>} Node
  */
 /**
  * @fileoverview This class encapsulates logic for handling resources and tasks used to model the
@@ -30,6 +30,10 @@ export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./netwo
  * @template [T=any]
  */
 export class BaseNode<T = any> {
+    static TYPES: {
+        NETWORK: 'network';
+        CPU: 'cpu';
+    };
     /**
      * Returns whether the given node has a cycle in its dependent graph by performing a DFS.
      * @param {Node} node
@@ -156,10 +160,4 @@ export class BaseNode<T = any> {
      */
     canDependOn(node: Node): boolean;
 }
-export namespace BaseNode {
-    namespace TYPES {
-        const NETWORK: 'network';
-        const CPU: 'cpu';
-    }
-}
-//# sourceMappingURL=base-node.d.ts.map
+//# sourceMappingURL=BaseNode.d.ts.map

package/core/lib/lantern/{base-node.js → BaseNode.js}

@@ -8,7 +8,7 @@
  * A union of all types derived from BaseNode, allowing type check discrimination
  * based on `node.type`. If a new node type is created, it should be added here.
  * @template [T=any]
- * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
+ * @typedef {import('./CpuNode.js').CPUNode<T> | import('./NetworkNode.js').NetworkNode<T>} Node
  */
 
 /**
@@ -28,6 +28,11 @@
  * @template [T=any]
  */
 class BaseNode {
+  static TYPES = /** @type {{NETWORK: 'network', CPU: 'cpu'}} */({
+    NETWORK: 'network',
+    CPU: 'cpu',
+  });
+
   /**
    * @param {string} id
    */
@@ -361,9 +366,4 @@ class BaseNode {
   }
 }
 
-BaseNode.TYPES = /** @type {{NETWORK: 'network', CPU: 'cpu'}} */({
-  NETWORK: 'network',
-  CPU: 'cpu',
-});
-
 export {BaseNode};