@mui/internal-benchmark 0.0.3-canary.2 → 0.0.3-canary.21

package/index.mjs

@@ -11,28 +11,39 @@ import { expect, it } from 'vitest';
 import * as ReactDOMClient from 'react-dom/client'; // aliased to react-dom/profiling by Vite
 import * as ReactDOM from 'react-dom';
 import { ElementTiming } from "./ElementTiming.mjs";
+import { ScalarMetric } from "./ScalarMetric.mjs";
+import { metricsGate } from "./metricsGate.mjs";
+import { createReactRecordingControls } from "./reactRecording.mjs";
+import { runProfileSession } from "./profileSession.mjs";
 // Import for TaskMeta augmentation side effect
 import "./taskMetaAugmentation.mjs";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export { ElementTiming } from "./ElementTiming.mjs";
+export { Metric } from "./Metric.mjs";
+export { ScalarMetric };
+export { DiscreteMetric } from "./DiscreteMetric.mjs";
 function BenchProfiler({
   captures,
+  recording,
   children
 }) {
   const onRender = React.useCallback((id, phase, actualDuration, _baseDuration, startTime) => {
-    captures.push({
-      id,
-      phase,
-      actualDuration,
-      startTime
-    });
-  }, [captures]);
-  return /*#__PURE__*/_jsxs(React.Profiler, {
+    // Skip renders captured while React recording is paused (e.g. the mount when the benchmark
+    // starts paused, or a span the interaction explicitly excludes).
+    if (recording.active) {
+      captures.push({
+        id,
+        phase,
+        actualDuration,
+        startTime
+      });
+      recording.markRendered();
+    }
+  }, [captures, recording]);
+  return /*#__PURE__*/_jsx(React.Profiler, {
     id: "bench",
     onRender: onRender,
-    children: [children, _ElementTiming || (_ElementTiming = /*#__PURE__*/_jsx(ElementTiming, {
-      name: "default"
-    }))]
+    children: children
   });
 }
 
@@ -54,9 +65,137 @@ function settle() {
 function supportsElementTiming() {
   return PerformanceObserver.supportedEntryTypes.includes('element');
 }
+// Sets up a PerformanceObserver for the Element Timing API and exposes a promise-based
+// `waitForElementTiming` helper. Used by the measurement loop (which also reads `elementEntries`
+// to record paint metrics) and the interactive profiling session.
+function createElementTimingWaiter() {
+  const hasElementTiming = supportsElementTiming();
+  const elementEntries = [];
+  const elementResolvers = new Map();
+  let observer = null;
+  if (hasElementTiming) {
+    observer = new PerformanceObserver(list => {
+      for (const entry of list.getEntries()) {
+        elementEntries.push(entry);
+        const resolver = elementResolvers.get(entry.identifier);
+        if (resolver) {
+          elementResolvers.delete(entry.identifier);
+          resolver();
+        }
+      }
+    });
+    observer.observe({
+      type: 'element',
+      buffered: false
+    });
+  }
+  const waitForElementTiming = (identifier, timeout) => {
+    if (!hasElementTiming) {
+      console.warn(`waitForElementTiming("${identifier}"): Element Timing API is not supported. ` + 'Paint metrics will not be collected.');
+      return Promise.resolve();
+    }
+    if (elementEntries.some(entry => entry.identifier === identifier)) {
+      return Promise.resolve();
+    }
+    const {
+      promise,
+      resolve,
+      reject
+    } = Promise.withResolvers();
+    const timeoutMs = timeout ?? 5000;
+    const timer = timeoutMs > 0 && timeoutMs < Infinity ? setTimeout(() => {
+      elementResolvers.delete(identifier);
+      reject(new Error(`waitForElementTiming("${identifier}"): timed out after ${timeoutMs}ms. ` + 'Ensure the element has an `elementtiming` attribute and is visible in the viewport.'));
+    }, timeoutMs) : undefined;
+    elementResolvers.set(identifier, () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      resolve();
+    });
+    return promise;
+  };
+  return {
+    elementEntries,
+    waitForElementTiming,
+    disconnect: () => observer?.disconnect()
+  };
+}
+
+// When true, `benchmark()` opens an interactive profiling session in a headed
+// browser instead of running the automated measurement loop. Enabled by
+// `createBenchmarkVitestConfig({ profile: true })` or `BENCHMARK_PROFILE=true`,
+// both of which replace this expression at build time via Vite `define`.
+const PROFILE_MODE = process.env.BENCHMARK_PROFILE === 'true';
+function createCaseRuntime({
+  renderFn,
+  interaction,
+  context,
+  onUncaughtError
+}) {
+  let root = null;
+  let container = null;
+  return {
+    mount() {
+      if (root) {
+        return;
+      }
+      container = document.createElement('div');
+      document.body.appendChild(container);
+      const newRoot = ReactDOMClient.createRoot(container, {
+        onUncaughtError
+      });
+      root = newRoot;
+      ReactDOM.flushSync(() => {
+        newRoot.render(/*#__PURE__*/_jsxs(React.Fragment, {
+          children: [renderFn(), _ElementTiming || (_ElementTiming = /*#__PURE__*/_jsx(ElementTiming, {
+            name: "default"
+          }))]
+        }));
+      });
+    },
+    interact: interaction ? async () => {
+      await interaction(context);
+    } : undefined,
+    unmount() {
+      if (!root) {
+        return;
+      }
+      root.unmount();
+      container?.remove();
+      root = null;
+      container = null;
+    },
+    isMounted: () => root !== null
+  };
+}
 export function benchmark(name, renderFn, interactionOrOptions, maybeOptions) {
   const interaction = typeof interactionOrOptions === 'function' ? interactionOrOptions : undefined;
   const options = typeof interactionOrOptions === 'object' ? interactionOrOptions : maybeOptions;
+
+  // In profile mode, skip the automated measurement loop entirely: build a bare case runtime (no
+  // BenchProfiler wrapper, no-op recording since the user drives DevTools by hand) and hand it to
+  // the interactive panel.
+  if (PROFILE_MODE) {
+    it(name, async () => {
+      const timing = createElementTimingWaiter();
+      // No `wrap`: profile mode renders the component bare (no BenchProfiler / React Profiler
+      // overhead in the hand-captured trace). The runtime still plants the `default` sentinel, so
+      // the first paint shows up as a labeled marker in the DevTools Performance timeline.
+      const runtime = createCaseRuntime({
+        renderFn,
+        interaction,
+        context: {
+          waitForElementTiming: timing.waitForElementTiming,
+          pauseReactRecording: () => {},
+          resumeReactRecording: () => {}
+        }
+      });
+      await runProfileSession(name, runtime);
+      timing.disconnect();
+    });
+    return;
+  }
   it(name, async ({
     task
   }) => {
@@ -64,108 +203,99 @@ export function benchmark(name, renderFn, interactionOrOptions, maybeOptions) {
     const warmupRuns = options?.warmupRuns ?? 10;
     const totalRuns = warmupRuns + runs;
     const iterations = [];
-    const hasElementTiming = supportsElementTiming();
+
+    // Paint timings are recorded as one harness-owned `bench:paint` metric: the default sentinel
+    // is the base series (`bench:paint`) and named `elementtiming` markers are sub-series
+    // (`bench:paint#grid-header`, …), all sharing a single definition. Paint is informational (no
+    // alarm): it dominates each test's total duration, so a per-test paint alarm just duplicates the
+    // Duration regression signal and floods the report on any broadly-regressed run.
+    const paint = new ScalarMetric({
+      name: 'bench:paint',
+      format: {
+        style: 'unit',
+        unit: 'millisecond',
+        maximumFractionDigits: 2
+      }
+    });
     if (typeof window.gc !== 'function') {
       console.warn('window.gc is not available. Run with --js-flags=--expose-gc for consistent GC between iterations.');
     }
     let renderError = null;
+    // Set if any iteration had a recording window that was active yet captured no renders.
+    let sawEmptyActiveWindow = false;
     for (let i = 0; i < totalRuns; i += 1) {
       const isWarmup = i < warmupRuns;
 
+      // Custom metrics recorded inside the benchmark honor warmup exclusion through the gate, the
+      // same way renders and `bench:paint` are excluded during warmup.
+      metricsGate.setRecordingEnabled(task, !isWarmup);
+
+      // Per-iteration switch for the harness's React render/paint recording. Starts paused when
+      // `reactRecordingPaused` is set; the interaction callback drives it from there.
+      const recording = createReactRecordingControls(!(options?.reactRecordingPaused ?? false));
+
       // Drain event loop from previous unmount, then double GC for thorough cleanup
       // eslint-disable-next-line no-await-in-loop
       await settle();
       forceGC();
       const captures = [];
-      const elementEntries = [];
-      const elementResolvers = new Map();
-
-      // Set up Element Timing observer
-      let elementObserver = null;
-      if (hasElementTiming) {
-        elementObserver = new PerformanceObserver(list => {
-          for (const entry of list.getEntries()) {
-            elementEntries.push(entry);
-            const resolver = elementResolvers.get(entry.identifier);
-            if (resolver) {
-              elementResolvers.delete(entry.identifier);
-              resolver();
-            }
-          }
-        });
-        elementObserver.observe({
-          type: 'element',
-          buffered: false
-        });
-      }
-      const waitForElementTiming = (identifier, timeout) => {
-        if (!hasElementTiming) {
-          console.warn(`waitForElementTiming("${identifier}"): Element Timing API is not supported. ` + 'Paint metrics will not be collected.');
-          return Promise.resolve();
-        }
-        if (elementEntries.some(entry => entry.identifier === identifier)) {
-          return Promise.resolve();
-        }
-        const {
-          promise,
-          resolve,
-          reject
-        } = Promise.withResolvers();
-        const timeoutMs = timeout ?? 5000;
-        const timer = timeoutMs > 0 && timeoutMs < Infinity ? setTimeout(() => {
-          elementResolvers.delete(identifier);
-          reject(new Error(`waitForElementTiming("${identifier}"): timed out after ${timeoutMs}ms. ` + 'Ensure the element has an `elementtiming` attribute and is visible in the viewport.'));
-        }, timeoutMs) : undefined;
-        elementResolvers.set(identifier, () => {
-          if (timer) {
-            clearTimeout(timer);
-          }
-          resolve();
-        });
-        return promise;
-      };
-      const iterationStart = performance.now();
-      const container = document.createElement('div');
-      document.body.appendChild(container);
-      const root = ReactDOMClient.createRoot(container, {
+      const timing = createElementTimingWaiter();
+      const runtime = createCaseRuntime({
+        // Wrap the case in BenchProfiler so its renders are captured; the runtime mounts whatever
+        // renderFn returns (profiling passes the case bare).
+        renderFn: () => /*#__PURE__*/_jsx(BenchProfiler, {
+          captures: captures,
+          recording: recording,
+          children: renderFn()
+        }),
+        interaction,
+        context: {
+          waitForElementTiming: timing.waitForElementTiming,
+          pauseReactRecording: recording.pauseReactRecording,
+          resumeReactRecording: recording.resumeReactRecording
+        },
         // eslint-disable-next-line @typescript-eslint/no-loop-func
         onUncaughtError: error => {
           renderError = error;
         }
       });
-      ReactDOM.flushSync(() => {
-        root.render(/*#__PURE__*/_jsx(BenchProfiler, {
-          captures: captures,
-          children: renderFn()
-        }));
-      });
+      const iterationStart = performance.now();
+      runtime.mount();
       if (renderError) {
-        elementObserver?.disconnect();
-        root.unmount();
-        container.remove();
+        timing.disconnect();
+        runtime.unmount();
         break;
       }
-      if (interaction) {
-        // eslint-disable-next-line no-await-in-loop
-        await interaction({
-          waitForElementTiming
-        });
-      }
+
+      // eslint-disable-next-line no-await-in-loop
+      await runtime.interact?.();
 
       // Wait for the bench sentinel paint entry (relies on test timeout)
       // eslint-disable-next-line no-await-in-loop
-      await waitForElementTiming('default', 0);
-      elementObserver?.disconnect();
-      root.unmount();
-      container.remove();
+      await timing.waitForElementTiming('default', 0);
+
+      // Close the final window and remember if any active window measured no renders.
+      recording.finalizeWindow();
+      if (recording.hadEmptyActiveWindow) {
+        sawEmptyActiveWindow = true;
+      }
+      timing.disconnect();
+      runtime.unmount();
       if (!isWarmup) {
-        const metrics = elementEntries.map(entry => ({
-          name: `paint:${entry.identifier}`,
-          value: entry.renderTime - iterationStart
-        }));
+        for (const entry of timing.elementEntries) {
+          // Skip paints that happened while recording was paused. Attribute by the paint's
+          // `paintTime`, not by when the observer callback fired (which can lag the paint).
+          if (!recording.activeAt(entry.paintTime)) {
+            continue;
+          }
+          // The default sentinel is the base series; named markers become sub-series.
+          const id = entry.identifier === 'default' ? undefined : entry.identifier;
+          paint.record(entry.paintTime - iterationStart, id !== undefined ? {
+            id
+          } : undefined);
+        }
         iterations.push({
-          renders: captures,
-          metrics
+          renders: captures
         });
       }
       if (options?.afterEach) {
@@ -179,8 +309,9 @@ export function benchmark(name, renderFn, interactionOrOptions, maybeOptions) {
       throw renderError;
     }
 
-    // Validate that at least one render was recorded
-    expect(iterations[0].renders.length, 'No renders were recorded during benchmark').toBeGreaterThan(0);
+    // Every active recording window must capture at least one render. Windows where recording was
+    // never running (e.g. a fully-paused, metric-only benchmark) are not checked.
+    expect(sawEmptyActiveWindow, 'React recording was active but captured no renders. If you only measure imperative DOM ' + 'updates or custom metrics, keep recording paused (reactRecordingPaused) instead of resuming.').toBe(false);
 
     // Validate all iterations produced the same render events (count + order).
     // This runs after meta is set so the reporter can still display results on failure.

package/metricsGate.d.mts

@@ -0,0 +1,7 @@
+import type { RunnerTestCase } from 'vitest';
+export declare const metricsGate: {
+  /** Whether custom-metric recording is currently enabled for `test`. Defaults to `true`. */
+  isRecordingEnabled(test: RunnerTestCase): boolean;
+  /** Enable or disable custom-metric recording for `test`. */
+  setRecordingEnabled(test: RunnerTestCase, enabled: boolean): void;
+};

package/metricsGate.mjs

@@ -0,0 +1,21 @@
+// Internal — not exported from the package, not user-facing. The `benchmark()` harness toggles
+// recording per test (off during warmup iterations) and `Metric.record()` consults it, so custom
+// metrics recorded inside a benchmark honor the same warmup exclusion as renders and `bench:paint`.
+//
+// Storage tracks the *disabled* tests so absence means enabled: a test with no entry — e.g. a
+// standalone `it()` loop that never goes through the harness — records normally by default.
+const disabled = new WeakSet();
+export const metricsGate = {
+  /** Whether custom-metric recording is currently enabled for `test`. Defaults to `true`. */
+  isRecordingEnabled(test) {
+    return !disabled.has(test);
+  },
+  /** Enable or disable custom-metric recording for `test`. */
+  setRecordingEnabled(test, enabled) {
+    if (enabled) {
+      disabled.delete(test);
+    } else {
+      disabled.add(test);
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-benchmark",
-  "version": "0.0.3-canary.2",
+  "version": "0.0.3-canary.21",
   "author": "MUI Team",
   "description": "Benchmark utilities for MUI projects. Internal package.",
   "repository": {
@@ -9,11 +9,11 @@
     "directory": "packages/benchmark"
   },
   "dependencies": {
-    "@babel/runtime": "^7.29.2",
-    "@vitejs/plugin-react": "^6.0.1",
+    "@babel/runtime": "^7.29.7",
+    "@vitejs/plugin-react": "^6.1.0",
     "env-ci": "^11.2.0",
-    "execa": "^9.6.1",
-    "zod": "^4.3.6"
+    "execa": "^10.0.1",
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "@vitest/browser-playwright": ">=4.1",
@@ -68,5 +68,5 @@
       }
     }
   },
-  "gitSha": "2e4759d55d99ba6104718b973ed93e965326be98"
+  "gitSha": "9e0cb003bd909d9f1b5f9f33b1706f3ce1627ea8"
 }

package/profileSession.d.mts

@@ -0,0 +1,2 @@
+import type { BenchmarkCaseRuntime } from "./types.mjs";
+export declare function runProfileSession(name: string, runtime: BenchmarkCaseRuntime): Promise<void>;

package/profileSession.mjs

@@ -0,0 +1,95 @@
+const PROFILE_PANEL_STYLE = ['position:fixed', 'top:0', 'left:0', 'right:0', 'z-index:2147483647', 'display:flex', 'gap:8px', 'align-items:center', 'box-sizing:border-box', 'padding:8px 12px', 'background:#1e1e1e', 'color:#fff', 'font:13px/1.4 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace', 'box-shadow:0 1px 6px rgba(0,0,0,0.5)'].join(';');
+const PROFILE_BUTTON_STYLE = ['padding:4px 10px', 'border:1px solid #555', 'border-radius:4px', 'background:#333', 'color:#fff', 'cursor:pointer', 'font:inherit'].join(';');
+function createProfileButton(label) {
+  const button = document.createElement('button');
+  button.type = 'button';
+  button.textContent = label;
+  button.style.cssText = PROFILE_BUTTON_STYLE;
+  return button;
+}
+
+// Interactive profiling session: instead of measuring, render a control panel with
+// Render / Unmount / Run interaction / Finish buttons that drive the given case runtime. The
+// component under test stays unmounted until the user clicks "Render", giving them time to start
+// the DevTools profiler first. The returned promise resolves on "Finish", which is what keeps the
+// Vitest test (and the headed browser window) alive in between; the caller cleans up afterwards.
+export function runProfileSession(name, runtime) {
+  const panel = document.createElement('div');
+  panel.setAttribute('data-benchmark-profile-panel', '');
+  panel.style.cssText = PROFILE_PANEL_STYLE;
+  const title = document.createElement('span');
+  title.textContent = `⏱ ${name}`;
+  title.style.cssText = 'font-weight:600;white-space:nowrap';
+  const status = document.createElement('span');
+  status.style.cssText = 'margin-left:auto;opacity:0.85;white-space:nowrap';
+  const renderButton = createProfileButton('▶ Render');
+  const interactButton = runtime.interact ? createProfileButton('⚡ Run interaction') : null;
+  const finishButton = createProfileButton('✓ Finish');
+  if (interactButton) {
+    interactButton.disabled = true;
+  }
+  panel.appendChild(title);
+  panel.appendChild(renderButton);
+  if (interactButton) {
+    panel.appendChild(interactButton);
+  }
+  panel.appendChild(finishButton);
+  panel.appendChild(status);
+  document.body.appendChild(panel);
+
+  // Push page content below the fixed panel so it doesn't cover the component.
+  const spacer = document.createElement('div');
+  spacer.style.height = `${panel.offsetHeight}px`;
+  document.body.insertBefore(spacer, panel);
+  const setStatus = text => {
+    status.textContent = text;
+  };
+  const show = () => {
+    if (runtime.isMounted()) {
+      return;
+    }
+    runtime.mount();
+    renderButton.textContent = '■ Unmount';
+    if (interactButton) {
+      interactButton.disabled = false;
+    }
+    setStatus('rendered — capture your profile, then Unmount or Finish');
+  };
+  const hide = () => {
+    if (!runtime.isMounted()) {
+      return;
+    }
+    runtime.unmount();
+    renderButton.textContent = '▶ Render';
+    if (interactButton) {
+      interactButton.disabled = true;
+    }
+    setStatus('unmounted — Render again or Finish');
+  };
+  setStatus('idle — start the DevTools profiler, then click Render');
+  return new Promise(resolve => {
+    renderButton.addEventListener('click', () => runtime.isMounted() ? hide() : show());
+    if (interactButton) {
+      interactButton.addEventListener('click', async () => {
+        interactButton.disabled = true;
+        setStatus('running interaction…');
+        try {
+          await runtime.interact?.();
+          setStatus('interaction done');
+        } catch (error) {
+          setStatus(`interaction error: ${String(error)}`);
+        } finally {
+          if (runtime.isMounted()) {
+            interactButton.disabled = false;
+          }
+        }
+      });
+    }
+    finishButton.addEventListener('click', () => {
+      hide();
+      spacer.remove();
+      panel.remove();
+      resolve();
+    });
+  });
+}

package/reactRecording.d.mts

@@ -0,0 +1,30 @@
+export interface ReactRecordingControls {
+  /** Whether React render/paint recording is active right now — the synchronous gate for renders. */
+  readonly active: boolean;
+  /** Whether any active recording window closed without capturing a render. */
+  readonly hadEmptyActiveWindow: boolean;
+  /**
+   * Whether recording was active at `time` (a `performance.now()` timestamp). Paint entries are
+   * observed asynchronously, so they are attributed by their `paintTime` rather than by the
+   * recording state at the moment the observer callback happens to fire.
+   */
+  activeAt(time: number): boolean;
+  /** Note that a render was captured in the current window. Called by the harness from `onRender`. */
+  markRendered(): void;
+  /** Close the final window at the end of the iteration (validates it if recording is still active). */
+  finalizeWindow(): void;
+  /** Pause React render/paint recording. Throws if recording is already paused. */
+  pauseReactRecording(): void;
+  /** Resume React render/paint recording. Throws if recording is already active. */
+  resumeReactRecording(): void;
+}
+/**
+ * Creates the per-iteration switch that turns the harness's React render/paint recording on and
+ * off. The interaction callback drives it via `pauseReactRecording`/`resumeReactRecording`; the
+ * strict state machine (each throws when called in the wrong state) catches unbalanced pairs early.
+ *
+ * It also tracks whether each *active* window captured at least one render, so the harness can flag
+ * a window that was recording but measured nothing — while leaving fully-paused (metric-only)
+ * benchmarks alone.
+ */
+export declare function createReactRecordingControls(initiallyActive: boolean): ReactRecordingControls;

package/reactRecording.mjs

@@ -0,0 +1,76 @@
+/**
+ * Creates the per-iteration switch that turns the harness's React render/paint recording on and
+ * off. The interaction callback drives it via `pauseReactRecording`/`resumeReactRecording`; the
+ * strict state machine (each throws when called in the wrong state) catches unbalanced pairs early.
+ *
+ * It also tracks whether each *active* window captured at least one render, so the harness can flag
+ * a window that was recording but measured nothing — while leaving fully-paused (metric-only)
+ * benchmarks alone.
+ */
+export function createReactRecordingControls(initiallyActive) {
+  let active = initiallyActive;
+  let currentWindowHasRender = false;
+  let emptyActiveWindow = false;
+  // Transitions in chronological order. The implicit state before the first toggle is
+  // `initiallyActive`; `activeAt` replays this to attribute a paint to its render time.
+  const transitions = [];
+
+  // Flag the window being closed if it was recording yet captured nothing.
+  function closeWindowIfActive() {
+    if (active && !currentWindowHasRender) {
+      emptyActiveWindow = true;
+    }
+  }
+  return {
+    get active() {
+      return active;
+    },
+    get hadEmptyActiveWindow() {
+      return emptyActiveWindow;
+    },
+    activeAt(time) {
+      let result = initiallyActive;
+      for (const transition of transitions) {
+        if (transition.time > time) {
+          break;
+        }
+        result = transition.active;
+      }
+      return result;
+    },
+    markRendered() {
+      currentWindowHasRender = true;
+    },
+    finalizeWindow() {
+      closeWindowIfActive();
+    },
+    pauseReactRecording() {
+      // Stamp first — before the guard and bookkeeping — so the closing window ends as early as
+      // possible and excludes pause's own overhead. In the throw path it is simply discarded.
+      const now = performance.now();
+      if (!active) {
+        throw new Error('pauseReactRecording() called but React recording is already paused.');
+      }
+      closeWindowIfActive();
+      active = false;
+      transitions.push({
+        time: now,
+        active: false
+      });
+    },
+    resumeReactRecording() {
+      if (active) {
+        throw new Error('resumeReactRecording() called but React recording is already active.');
+      }
+      active = true;
+      currentWindowHasRender = false;
+      // Stamp last — after the bookkeeping — so the new window starts as late as possible and
+      // excludes resume's own overhead.
+      const now = performance.now();
+      transitions.push({
+        time: now,
+        active: true
+      });
+    }
+  };
+}

package/reporter.d.mts

@@ -10,11 +10,13 @@ export interface BenchmarkReporterOptions {
 }
 declare class BenchmarkReporter implements Reporter {
   private benchmarks;
+  private metricDefinitions;
   private outputPath;
   private upload;
   private baselinePath;
   private hasFailures;
   constructor(options?: BenchmarkReporterOptions);
+  onTestRunStart(): void;
   onTestCaseResult(testCase: TestCase): void;
   onTestRunEnd(): Promise<void>;
 }