lighthouse 11.6.0-dev.20240225 → 11.6.0-dev.20240226

package/core/gather/driver/execution-context.d.ts

@@ -53,9 +53,10 @@ export class ExecutionContext {
      * page without isolation.
      * @param {string} expression
      * @param {number|undefined} contextId
+     * @param {number} timeout
      * @return {Promise<*>}
      */
-    _evaluateInContext(expression: string, contextId: number | undefined): Promise<any>;
+    _evaluateInContext(expression: string, contextId: number | undefined, timeout: number): Promise<any>;
     /**
      * Note: Prefer `evaluate` instead.
      * Evaluate an expression in the context of the current page. If useIsolation is true, the expression

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

@@ -80,15 +80,10 @@ class ExecutionContext {
    * page without isolation.
    * @param {string} expression
    * @param {number|undefined} contextId
+   * @param {number} timeout
    * @return {Promise<*>}
    */
-  async _evaluateInContext(expression, contextId) {
-    // Use a higher than default timeout if the user hasn't specified a specific timeout.
-    // Otherwise, use whatever was requested.
-    const timeout = this._session.hasNextProtocolTimeout() ?
-      this._session.getNextProtocolTimeout() :
-      60000;
-
+  async _evaluateInContext(expression, contextId, timeout) {
     // `__lighthouseExecutionContextUniqueIdentifier` is only used by the FullPageScreenshot gatherer.
     // See `getNodeDetails` in page-functions.
     const uniqueExecutionContextIdentifier = contextId === undefined ?
@@ -166,17 +161,22 @@ class ExecutionContext {
    * @return {Promise<*>}
    */
   async evaluateAsync(expression, options = {}) {
+    // Use a higher than default timeout if the user hasn't specified a specific timeout.
+    // Otherwise, use whatever was requested.
+    const timeout = this._session.hasNextProtocolTimeout() ?
+      this._session.getNextProtocolTimeout() :
+      60000;
     const contextId = options.useIsolation ? await this._getOrCreateIsolatedContextId() : undefined;
 
     try {
       // `await` is not redundant here because we want to `catch` the async errors
-      return await this._evaluateInContext(expression, contextId);
+      return await this._evaluateInContext(expression, contextId, timeout);
     } catch (err) {
       // If we were using isolation and the context disappeared on us, retry one more time.
       if (contextId && err.message.includes('Cannot find context')) {
         this.clearContextId();
         const freshContextId = await this._getOrCreateIsolatedContextId();
-        return this._evaluateInContext(expression, freshContextId);
+        return this._evaluateInContext(expression, freshContextId, timeout);
       }
 
       throw err;

package/core/gather/driver/wait-for-condition.js

@@ -497,8 +497,10 @@ async function waitForFullyLoaded(session, networkMonitor, options) {
       log.warn('waitFor', 'Timed out waiting for page load. Checking if page is hung...');
       if (await isPageHung(session)) {
         log.warn('waitFor', 'Page appears to be hung, killing JavaScript...');
-        await session.sendCommand('Emulation.setScriptExecutionDisabled', {value: true});
-        await session.sendCommand('Runtime.terminateExecution');
+        // We don't await these, as we want to exit with PAGE_HUNG
+        void session.sendCommand('Emulation.setScriptExecutionDisabled', {value: true})
+          .catch(_ => {});
+        void session.sendCommand('Runtime.terminateExecution').catch(_ => {});
         throw new LighthouseError(LighthouseError.errors.PAGE_HUNG);
       }
 

package/core/gather/navigation-runner.js

@@ -265,44 +265,43 @@ async function navigationGather(page, requestor, options = {}) {
   const isCallback = typeof requestor === 'function';
 
   const runnerOptions = {resolvedConfig, computedCache};
-  const artifacts = await Runner.gather(
-    async () => {
-      const normalizedRequestor = isCallback ? requestor : UrlUtils.normalizeUrl(requestor);
-
-      /** @type {LH.Puppeteer.Browser|undefined} */
-      let lhBrowser = undefined;
-      /** @type {LH.Puppeteer.Page|undefined} */
-      let lhPage = undefined;
-
-      // For navigation mode, we shouldn't connect to a browser in audit mode,
-      // therefore we connect to the browser in the gatherFn callback.
-      if (!page) {
-        const {hostname = DEFAULT_HOSTNAME, port = DEFAULT_PORT} = flags;
-        lhBrowser = await puppeteer.connect({browserURL: `http://${hostname}:${port}`, defaultViewport: null});
-        lhPage = await lhBrowser.newPage();
-        page = lhPage;
-      }
-
-      const driver = new Driver(page);
-      const context = {
-        driver,
-        lhBrowser,
-        lhPage,
-        page,
-        resolvedConfig,
-        requestor: normalizedRequestor,
-        computedCache,
-      };
-      const {baseArtifacts} = await _setup(context);
-
-      const artifacts = await _navigation({...context, baseArtifacts});
-
-      await _cleanup(context);
-
-      return finalizeArtifacts(baseArtifacts, artifacts);
-    },
-    runnerOptions
-  );
+
+  const gatherFn = async () => {
+    const normalizedRequestor = isCallback ? requestor : UrlUtils.normalizeUrl(requestor);
+
+    /** @type {LH.Puppeteer.Browser|undefined} */
+    let lhBrowser = undefined;
+    /** @type {LH.Puppeteer.Page|undefined} */
+    let lhPage = undefined;
+
+    // For navigation mode, we shouldn't connect to a browser in audit mode,
+    // therefore we connect to the browser in the gatherFn callback.
+    if (!page) {
+      const {hostname = DEFAULT_HOSTNAME, port = DEFAULT_PORT} = flags;
+      lhBrowser = await puppeteer.connect({browserURL: `http://${hostname}:${port}`, defaultViewport: null});
+      lhPage = await lhBrowser.newPage();
+      page = lhPage;
+    }
+
+    const driver = new Driver(page);
+    const context = {
+      driver,
+      lhBrowser,
+      lhPage,
+      page,
+      resolvedConfig,
+      requestor: normalizedRequestor,
+      computedCache,
+    };
+    const {baseArtifacts} = await _setup(context);
+
+    const artifacts = await _navigation({...context, baseArtifacts});
+
+    await _cleanup(context);
+
+    return finalizeArtifacts(baseArtifacts, artifacts);
+  };
+  const artifacts = await Runner.gather(gatherFn, runnerOptions);
   return {artifacts, runnerOptions};
 }
 

package/core/gather/snapshot-runner.js

@@ -30,35 +30,35 @@ async function snapshotGather(page, options = {}) {
   const url = await driver.url();
 
   const runnerOptions = {resolvedConfig, computedCache};
-  const artifacts = await Runner.gather(
-    async () => {
-      const baseArtifacts =
+
+  const gatherFn = async () => {
+    const baseArtifacts =
         await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'snapshot'});
-      baseArtifacts.URL = {
-        finalDisplayedUrl: url,
-      };
+    baseArtifacts.URL = {
+      finalDisplayedUrl: url,
+    };
+
+    const artifactDefinitions = resolvedConfig.artifacts || [];
+    const artifactState = getEmptyArtifactState();
+    await collectPhaseArtifacts({
+      phase: 'getArtifact',
+      gatherMode: 'snapshot',
+      driver,
+      page,
+      baseArtifacts,
+      artifactDefinitions,
+      artifactState,
+      computedCache,
+      settings: resolvedConfig.settings,
+    });
 
-      const artifactDefinitions = resolvedConfig.artifacts || [];
-      const artifactState = getEmptyArtifactState();
-      await collectPhaseArtifacts({
-        phase: 'getArtifact',
-        gatherMode: 'snapshot',
-        driver,
-        page,
-        baseArtifacts,
-        artifactDefinitions,
-        artifactState,
-        computedCache,
-        settings: resolvedConfig.settings,
-      });
+    await driver.disconnect();
 
-      await driver.disconnect();
+    const artifacts = await awaitArtifacts(artifactState);
+    return finalizeArtifacts(baseArtifacts, artifacts);
+  };
 
-      const artifacts = await awaitArtifacts(artifactState);
-      return finalizeArtifacts(baseArtifacts, artifacts);
-    },
-    runnerOptions
-  );
+  const artifacts = await Runner.gather(gatherFn, runnerOptions);
   return {artifacts, runnerOptions};
 }
 

package/core/gather/timespan-runner.js

@@ -72,31 +72,30 @@ async function startTimespanGather(page, options = {}) {
       const finalDisplayedUrl = await driver.url();
 
       const runnerOptions = {resolvedConfig, computedCache};
-      const artifacts = await Runner.gather(
-        async () => {
-          baseArtifacts.URL = {finalDisplayedUrl};
-
-          await collectPhaseArtifacts({phase: 'stopSensitiveInstrumentation', ...phaseOptions});
-          await collectPhaseArtifacts({phase: 'stopInstrumentation', ...phaseOptions});
-
-          // bf-cache-failures can emit `Page.frameNavigated` at the end of the run.
-          // This can cause us to issue protocol commands after the target closes.
-          // 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();
-
-          const artifacts = await awaitArtifacts(artifactState);
-          return finalizeArtifacts(baseArtifacts, artifacts);
-        },
-        runnerOptions
-      );
+      const gatherFn = async () => {
+        baseArtifacts.URL = {finalDisplayedUrl};
+
+        await collectPhaseArtifacts({phase: 'stopSensitiveInstrumentation', ...phaseOptions});
+        await collectPhaseArtifacts({phase: 'stopInstrumentation', ...phaseOptions});
+
+        // bf-cache-failures can emit `Page.frameNavigated` at the end of the run.
+        // This can cause us to issue protocol commands after the target closes.
+        // 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();
+
+        const artifacts = await awaitArtifacts(artifactState);
+        return finalizeArtifacts(baseArtifacts, artifacts);
+      };
+
+      const artifacts = await Runner.gather(gatherFn, runnerOptions);
       return {artifacts, runnerOptions};
     },
   };

package/core/lib/network-recorder.js

@@ -257,7 +257,7 @@ class NetworkRecorder extends RequestEventEmitter {
     let candidates = recordsByURL.get(initiatorURL) || [];
     // The (valid) initiator must come before the initiated request.
     candidates = candidates.filter(c => {
-      return c.responseHeadersEndTime <= record.networkRequestTime &&
+      return c.responseHeadersEndTime <= record.rendererStartTime &&
           c.finished && !c.failed;
     });
     if (candidates.length > 1) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "11.6.0-dev.20240225",
+  "version": "11.6.0-dev.20240226",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {