lighthouse 11.6.0 → 11.7.0-dev.20240321

package/core/gather/gatherers/css-usage.js

@@ -36,7 +36,7 @@ class CSSUsage extends BaseGatherer {
   /**
    * @param {LH.Crdp.CSS.StyleSheetAddedEvent} event
    */
-  async _onStylesheetAdded(event) {
+  _onStylesheetAdded(event) {
     if (!this._session) throw new Error('Session not initialized');
     const styleSheetId = event.header.styleSheetId;
     const sheetPromise = this._session.sendCommand('CSS.getStyleSheetText', {styleSheetId})
@@ -66,41 +66,43 @@ class CSSUsage extends BaseGatherer {
   /**
    * @param {LH.Gatherer.Context} context
    */
-  async startCSSUsageTracking(context) {
+  async startInstrumentation(context) {
     const session = context.driver.defaultSession;
     this._session = session;
-    session.on('CSS.styleSheetAdded', this._onStylesheetAdded);
+
+    // Calling `CSS.enable` will emit events for stylesheets currently on the page.
+    // We want to ignore these events in navigation mode because they are not relevant to the
+    // navigation that is about to happen. Adding the event listener *after* calling `CSS.enable`
+    // ensures that the events for pre-existing stylesheets are ignored.
+    const isNavigation = context.gatherMode === 'navigation';
+    if (!isNavigation) {
+      session.on('CSS.styleSheetAdded', this._onStylesheetAdded);
+    }
 
     await session.sendCommand('DOM.enable');
     await session.sendCommand('CSS.enable');
     await session.sendCommand('CSS.startRuleUsageTracking');
+
+    if (isNavigation) {
+      session.on('CSS.styleSheetAdded', this._onStylesheetAdded);
+    }
   }
 
 
   /**
    * @param {LH.Gatherer.Context} context
    */
-  async stopCSSUsageTracking(context) {
+  async stopInstrumentation(context) {
     const session = context.driver.defaultSession;
     const coverageResponse = await session.sendCommand('CSS.stopRuleUsageTracking');
     this._ruleUsage = coverageResponse.ruleUsage;
     session.off('CSS.styleSheetAdded', this._onStylesheetAdded);
-  }
 
-  /**
-   * @param {LH.Gatherer.Context} context
-   */
-  async startInstrumentation(context) {
-    if (context.gatherMode !== 'timespan') return;
-    await this.startCSSUsageTracking(context);
-  }
+    // Ensure we finish fetching all stylesheet contents before disabling the CSS domain
+    await Promise.all(this._sheetPromises.values());
 
-  /**
-   * @param {LH.Gatherer.Context} context
-   */
-  async stopInstrumentation(context) {
-    if (context.gatherMode !== 'timespan') return;
-    await this.stopCSSUsageTracking(context);
+    await session.sendCommand('CSS.disable');
+    await session.sendCommand('DOM.disable');
   }
 
   /**
@@ -108,17 +110,16 @@ class CSSUsage extends BaseGatherer {
    * @return {Promise<LH.Artifacts['CSSUsage']>}
    */
   async getArtifact(context) {
-    const session = context.driver.defaultSession;
     const executionContext = context.driver.executionContext;
 
-    if (context.gatherMode !== 'timespan') {
-      await this.startCSSUsageTracking(context);
+    if (context.gatherMode === 'snapshot') {
+      await this.startInstrumentation(context);
 
       // Force style to recompute.
       // Doesn't appear to be necessary in newer versions of Chrome.
       await executionContext.evaluateAsync('getComputedStyle(document.body)');
 
-      await this.stopCSSUsageTracking(context);
+      await this.stopInstrumentation(context);
     }
 
     /** @type {Map<string, LH.Artifacts.CSSStyleSheetInfo>} */
@@ -140,9 +141,6 @@ class CSSUsage extends BaseGatherer {
       dedupedStylesheets.set(sheet.content, sheet);
     }
 
-    await session.sendCommand('CSS.disable');
-    await session.sendCommand('DOM.disable');
-
     if (!this._ruleUsage) throw new Error('Issue collecting rule usages');
 
     return {

package/core/gather/gatherers/devtools-log.d.ts

@@ -12,6 +12,10 @@ declare class DevtoolsLog extends BaseGatherer {
      * @param {LH.Gatherer.Context} passContext
      */
     stopSensitiveInstrumentation({ driver }: LH.Gatherer.Context): Promise<void>;
+    /**
+     * @return {LH.Artifacts['DevtoolsLog']}
+     */
+    getDebugData(): LH.Artifacts['DevtoolsLog'];
     /**
      * @return {Promise<LH.Artifacts['DevtoolsLog']>}
      */

package/core/gather/gatherers/devtools-log.js

@@ -49,6 +49,13 @@ class DevtoolsLog extends BaseGatherer {
     driver.targetManager.off('protocolevent', this._onProtocolMessage);
   }
 
+  /**
+   * @return {LH.Artifacts['DevtoolsLog']}
+   */
+  getDebugData() {
+    return this._messageLog.messages;
+  }
+
   /**
    * @return {Promise<LH.Artifacts['DevtoolsLog']>}
    */

package/core/gather/gatherers/full-page-screenshot.d.ts

@@ -1,5 +1,9 @@
 export default FullPageScreenshot;
 declare class FullPageScreenshot extends BaseGatherer {
+    /**
+     * @param {LH.Gatherer.Context} context
+     */
+    waitForNetworkIdle(context: LH.Gatherer.Context): import("../driver/wait-for-condition.js").CancellableWait<void>;
     /**
      * @param {LH.Gatherer.Context} context
      * @param {{height: number, width: number, mobile: boolean}} deviceMetrics

package/core/gather/gatherers/full-page-screenshot.js

@@ -13,7 +13,10 @@ import {waitForNetworkIdle} from '../driver/wait-for-condition.js';
 // JPEG quality setting
 // Exploration and examples of reports using different quality settings: https://docs.google.com/document/d/1ZSffucIca9XDW2eEwfoevrk-OTl7WQFeMf0CgeJAA8M/edit#
 // Note: this analysis was done for JPEG, but now we use WEBP.
-const FULL_PAGE_SCREENSHOT_QUALITY = 30;
+const FULL_PAGE_SCREENSHOT_QUALITY = process.env.LH_FPS_TEST ? 100 : 30;
+// webp currently cant do lossless encoding, so to help tests switch to png
+// Remove when this is resolved: https://bugs.chromium.org/p/chromium/issues/detail?id=1469183
+const FULL_PAGE_SCREENSHOT_FORMAT = process.env.LH_FPS_TEST ? 'png' : 'webp';
 
 // https://developers.google.com/speed/webp/faq#what_is_the_maximum_size_a_webp_image_can_be
 const MAX_WEBP_SIZE = 16383;
@@ -44,17 +47,6 @@ function getObservedDeviceMetrics() {
   };
 }
 
-/**
- * The screenshot dimensions are sized to `window.outerHeight` / `window.outerWidth`,
- * however the bounding boxes of the elements are relative to `window.innerHeight` / `window.innerWidth`.
- */
-function getScreenshotAreaSize() {
-  return {
-    width: window.innerWidth,
-    height: window.innerHeight,
-  };
-}
-
 function waitForDoubleRaf() {
   return new Promise((resolve) => {
     requestAnimationFrame(() => requestAnimationFrame(resolve));
@@ -69,6 +61,21 @@ class FullPageScreenshot extends BaseGatherer {
     supportedModes: ['snapshot', 'timespan', 'navigation'],
   };
 
+  /**
+   * @param {LH.Gatherer.Context} context
+   */
+  waitForNetworkIdle(context) {
+    const session = context.driver.defaultSession;
+    const networkMonitor = context.driver.networkMonitor;
+    return waitForNetworkIdle(session, networkMonitor, {
+      pretendDCLAlreadyFired: true,
+      networkQuietThresholdMs: 1000,
+      busyEvent: 'network-critical-busy',
+      idleEvent: 'network-critical-idle',
+      isIdle: recorder => recorder.isCriticalIdle(),
+    });
+  }
+
   /**
    * @param {LH.Gatherer.Context} context
    * @param {{height: number, width: number, mobile: boolean}} deviceMetrics
@@ -86,15 +93,7 @@ class FullPageScreenshot extends BaseGatherer {
     );
     const height = Math.min(fullHeight, MAX_WEBP_SIZE);
 
-    // Setup network monitor before we change the viewport.
-    const networkMonitor = context.driver.networkMonitor;
-    const waitForNetworkIdleResult = waitForNetworkIdle(session, networkMonitor, {
-      pretendDCLAlreadyFired: true,
-      networkQuietThresholdMs: 1000,
-      busyEvent: 'network-critical-busy',
-      idleEvent: 'network-critical-idle',
-      isIdle: recorder => recorder.isCriticalIdle(),
-    });
+    const waitForNetworkIdleResult = this.waitForNetworkIdle(context);
 
     await session.sendCommand('Emulation.setDeviceMetricsOverride', {
       mobile: deviceMetrics.mobile,
@@ -120,22 +119,19 @@ class FullPageScreenshot extends BaseGatherer {
    * @return {Promise<LH.Result.FullPageScreenshot['screenshot']>}
    */
   async _takeScreenshot(context) {
-    const result = await context.driver.defaultSession.sendCommand('Page.captureScreenshot', {
-      format: 'webp',
-      quality: FULL_PAGE_SCREENSHOT_QUALITY,
-    });
-    const data = 'data:image/webp;base64,' + result.data;
-
-    const screenshotAreaSize =
-      await context.driver.executionContext.evaluate(getScreenshotAreaSize, {
-        args: [],
-        useIsolation: true,
-      });
+    const [metrics, result] = await Promise.all([
+      context.driver.defaultSession.sendCommand('Page.getLayoutMetrics'),
+      context.driver.defaultSession.sendCommand('Page.captureScreenshot', {
+        format: FULL_PAGE_SCREENSHOT_FORMAT,
+        quality: FULL_PAGE_SCREENSHOT_QUALITY,
+      }),
+    ]);
+    const data = `data:image/${FULL_PAGE_SCREENSHOT_FORMAT};base64,` + result.data;
 
     return {
       data,
-      width: screenshotAreaSize.width,
-      height: screenshotAreaSize.height,
+      width: metrics.cssVisualViewport.clientWidth,
+      height: metrics.cssVisualViewport.clientHeight,
     };
   }
 
@@ -159,7 +155,7 @@ class FullPageScreenshot extends BaseGatherer {
       for (const [node, id] of lhIdToElements.entries()) {
         // @ts-expect-error - getBoundingClientRect put into scope via stringification
         const rect = getBoundingClientRect(node);
-        nodes[id] = rect;
+        nodes[id] = {id: node.id, ...rect};
       }
 
       return nodes;

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

@@ -124,9 +124,7 @@ class RootCauses extends BaseGatherer {
       rootCauses.layoutShifts[layoutShiftEvents.indexOf(event)] = r;
     }
 
-    // Yeah this gatherer enabled it, and so you'd think it should disable it too...
-    // ...but we don't give gatherers their own session so this stomps on others.
-    // await driver.defaultSession.sendCommand('DOM.disable');
+    await driver.defaultSession.sendCommand('DOM.disable');
     await driver.defaultSession.sendCommand('CSS.disable');
 
     return rootCauses;

package/core/gather/gatherers/trace-elements.js

@@ -155,7 +155,7 @@ class TraceElements extends BaseGatherer {
     const {settings} = context;
     try {
       const responsivenessEvent = await Responsiveness.request({trace, settings}, context);
-      if (!responsivenessEvent || responsivenessEvent.name === 'FallbackTiming') return;
+      if (!responsivenessEvent) return;
       return {nodeId: responsivenessEvent.args.data.nodeId};
     } catch {
       // Don't let responsiveness errors sink the rest of the gatherer.

package/core/gather/gatherers/trace.d.ts

@@ -17,6 +17,7 @@ declare class Trace extends BaseGatherer {
      * @param {LH.Gatherer.Context} passContext
      */
     stopSensitiveInstrumentation({ driver }: LH.Gatherer.Context): Promise<void>;
+    getDebugData(): import("../../index.js").Trace;
     getArtifact(): import("../../index.js").Trace;
 }
 import BaseGatherer from '../base-gatherer.js';

package/core/gather/gatherers/trace.js

@@ -126,6 +126,10 @@ class Trace extends BaseGatherer {
     this._trace = await Trace.endTraceAndCollectEvents(driver.defaultSession);
   }
 
+  getDebugData() {
+    return this._trace;
+  }
+
   getArtifact() {
     return this._trace;
   }

package/core/gather/navigation-runner.js

@@ -110,31 +110,19 @@ async function _navigate(navigationContext) {
  * @return {Promise<{devtoolsLog?: LH.DevtoolsLog, records?: Array<LH.Artifacts.NetworkRequest>, trace?: LH.Trace}>}
  */
 async function _collectDebugData(navigationContext, phaseState) {
-  const devtoolsLogArtifactDefn = phaseState.artifactDefinitions.find(
-    definition => definition.gatherer.instance.meta.symbol === DevtoolsLog.symbol
-  );
-  const traceArtifactDefn = phaseState.artifactDefinitions.find(
-    definition => definition.gatherer.instance.meta.symbol === Trace.symbol
-  );
-
-  const artifactDefinitions = [devtoolsLogArtifactDefn, traceArtifactDefn].filter(
-    /**
-     * @param {LH.Config.AnyArtifactDefn | undefined} defn
-     * @return {defn is LH.Config.AnyArtifactDefn}
-     */
-    defn => Boolean(defn)
-  );
-  if (!artifactDefinitions.length) return {};
-
-  await collectPhaseArtifacts({...phaseState, phase: 'getArtifact', artifactDefinitions});
-  const getArtifactState = phaseState.artifactState.getArtifact;
-
-  const devtoolsLogArtifactId = devtoolsLogArtifactDefn?.id;
-  const devtoolsLog = devtoolsLogArtifactId && (await getArtifactState[devtoolsLogArtifactId]);
-  const records = devtoolsLog && (await NetworkRecords.request(devtoolsLog, navigationContext));
+  let devtoolsLog;
+  let trace;
+
+  for (const definition of phaseState.artifactDefinitions) {
+    const {instance} = definition.gatherer;
+    if (instance instanceof DevtoolsLog) {
+      devtoolsLog = instance.getDebugData();
+    } else if (instance instanceof Trace) {
+      trace = instance.getDebugData();
+    }
+  }
 
-  const traceArtifactId = traceArtifactDefn?.id;
-  const trace = traceArtifactId && (await getArtifactState[traceArtifactId]);
+  const records = devtoolsLog && (await NetworkRecords.request(devtoolsLog, navigationContext));
 
   return {devtoolsLog, records, trace};
 }
@@ -277,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/session.js

@@ -6,6 +6,8 @@
 
 import EventEmitter from 'events';
 
+import log from 'lighthouse-logger';
+
 import {LighthouseError} from '../lib/lh-error.js';
 
 // Controls how long to wait for a response after sending a DevTools protocol command.
@@ -107,6 +109,9 @@ class ProtocolSession extends CrdpEventEmitter {
     const resultPromise = this._cdpSession.send(method, ...params, {
       // Add 50ms to the Puppeteer timeout to ensure the Lighthouse timeout finishes first.
       timeout: timeoutMs + PPTR_BUFFER,
+    }).catch((error) => {
+      log.formatProtocol('method <= browser ERR', {method}, 'error');
+      throw LighthouseError.fromProtocolMessage(method, error);
     });
     const resultWithTimeoutPromise = Promise.race([resultPromise, timeoutPromise]);
 

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/asset-saver.js

@@ -11,7 +11,7 @@ import url from 'url';
 
 import log from 'lighthouse-logger';
 
-import {Simulator} from './dependency-graph/simulator/simulator.js';
+import {Simulator} from './lantern/simulator/simulator.js';
 import lanternTraceSaver from './lantern-trace-saver.js';
 import {MetricTraceEvents} from './traces/metric-trace-events.js';
 import {NetworkAnalysis} from '../computed/network-analysis.js';

package/core/lib/emulation.js

@@ -4,8 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {lighthouseVersion} from '../../shared/root.js';
-
 const NO_THROTTLING_METRICS = {
   latency: 0,
   downloadThroughput: 0,
@@ -29,7 +27,6 @@ function parseUseragentIntoMetadata(userAgent, formFactor) {
   const brands = [
     {brand: 'Chromium', version},
     {brand: 'Google Chrome', version},
-    {brand: 'Lighthouse', version: lighthouseVersion},
   ];
 
   const motoGPowerDetails = {

package/core/lib/{dependency-graph → lantern}/base-node.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 = import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode;
+export type Node<T = any> = import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>;
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -11,7 +11,8 @@ export type Node = import('./cpu-node.js').CPUNode | import('./network-node.js')
 /**
  * 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.
- * @typedef {import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode} Node
+ * @template [T=any]
+ * @typedef {import('./cpu-node.js').CPUNode<T> | import('./network-node.js').NetworkNode<T>} Node
  */
 /**
  * @fileoverview This class encapsulates logic for handling resources and tasks used to model the
@@ -25,7 +26,10 @@ export type Node = import('./cpu-node.js').CPUNode | import('./network-node.js')
  * This allows particular optimizations in this class so that we do no need to check for cycles as
  * these methods are called and we can always start traversal at the root node.
  */
-export class BaseNode {
+/**
+ * @template [T=any]
+ */
+export class BaseNode<T = any> {
     /**
      * Returns whether the given node has a cycle in its dependent graph by performing a DFS.
      * @param {Node} node
@@ -134,17 +138,17 @@ export class BaseNode {
      *
      * The `getNextNodes` function takes a visited node and returns which nodes to
      * visit next. It defaults to returning the node's dependents.
-     * @param {(node: Node, traversalPath: Node[]) => void} callback
-     * @param {function(Node): Node[]} [getNextNodes]
+     * @param {(node: Node<T>, traversalPath: Node<T>[]) => void} callback
+     * @param {function(Node<T>): Node<T>[]} [getNextNodes]
      */
-    traverse(callback: (node: Node, traversalPath: Node[]) => void, getNextNodes?: ((arg0: Node) => Node[]) | undefined): void;
+    traverse(callback: (node: Node<T>, traversalPath: Node<T>[]) => void, getNextNodes?: ((arg0: Node<T>) => Node<T>[]) | undefined): void;
     /**
      * @see BaseNode.traverse
      * @param {function(Node): Node[]} [getNextNodes]
      */
     traverseGenerator(getNextNodes?: ((arg0: Node) => Node[]) | undefined): Generator<{
-        node: Node;
-        traversalPath: Node[];
+        node: Node<any>;
+        traversalPath: Node<any>[];
     }, void, unknown>;
     /**
      * @param {Node} node