@vercel/devlow-bench 0.3.4 → 16.4.0-canary.24

package/README.md

@@ -10,19 +10,36 @@ npm install devlow-bench
 
 ## Usage
 
-```bash
-Usage: devlow-bench [options] <scenario files>
-## Selecting scenarios
-  --scenario=<filter>, -s=<filter>   Only run the scenario with the given name
-  --interactive, -i                  Select scenarios and variants interactively
-  --<prop>=<value>                   Filter by any variant property defined in scenarios
-## Output
-  --json=<path>, -j=<path>           Write the results to the given path as JSON
-  --console                          Print the results to the console
-  --datadog[=<hostname>]             Upload the results to Datadog
-                                     (requires DATADOG_API_KEY environment variables)
-## Help
-  --help, -h, -?                     Show this help
+```text
+Usage: devlow-bench [options] [command]
+
+Run developer-workflow benchmarks.
+
+Options:
+  -h, --help                       display help for command
+
+Commands:
+  run [options] [scenarios...]     Run scenario files and report measurements.
+  compare <baseline> <current>     Compare two snapshot CSVs side-by-side.
+  help [command]                   display help for command
+```
+
+`run` is the default command, so scenario paths can still be passed without
+writing `run` explicitly. Its options include:
+
+```text
+-s, --scenario <filter>            Only run scenarios whose name matches the filter (repeatable).
+-F, --filter <pair>                Filter variants by property: key=value (repeatable).
+-i, --interactive                  Select scenarios and variants interactively.
+--n <number>                       Run each variant N times.
+--warmup <number>                  Discard the first N runs before sampling.
+--snapshot <path>                  Override the snapshot CSV path.
+--compare                          Print a comparison table after the run.
+--baseline <path>                  Select a comparison baseline; implies --compare.
+-j, --json <path>                  Write results as JSON.
+--no-console                       Suppress console output.
+--datadog [host]                   Upload results to Datadog.
+--snowflake [batchUri]             Upload results to Snowflake.
 ```
 
 ## Scenarios
@@ -30,10 +47,10 @@ Usage: devlow-bench [options] <scenario files>
 A scenario file is similar to a test case file. It can contain one or multiple scenarios by using the `describe()` method to define them.
 
 ```js
-import { describe } from "devlow-bench";
+import { describe } from 'devlow-bench'
 
 describe(
-  "my scenario",
+  'my scenario',
   {
     /* property options */
   },
@@ -44,7 +61,7 @@ describe(
   ) => {
     // run the scenario
   }
-);
+)
 ```
 
 The `describe()` method takes three arguments:
@@ -58,18 +75,18 @@ The `props` object can contain any number of properties. The key is the name of
 ### Example
 
 ```js
-import { describe } from "devlow-bench";
+import { describe } from 'devlow-bench'
 
 describe(
-  "my scenario",
+  'my scenario',
   {
     myProperty: [1, 2, 3],
     myOtherProperty: true,
   },
   async ({ myProperty, myOtherProperty }) => {
-    console.log(myProperty, myOtherProperty);
+    console.log(myProperty, myOtherProperty)
   }
-);
+)
 
 // will print:
 // 1 true
@@ -83,17 +100,17 @@ describe(
 ## Reporting measurements
 
 ```js
-import { measureTime, reportMeasurement } from "devlow-bench";
+import { measureTime, reportMeasurement } from 'devlow-bench'
 
 // Measure a time
-await measureTime("name of the timing", {
+await measureTime('name of the timing', {
   /* optional options */
-});
+})
 
 // Report some other measurement
-await reportMeasurement("name of the measurement", value, unit, {
+await reportMeasurement('name of the measurement', value, unit, {
   /* optional options */
-});
+})
 ```
 
 Options:
@@ -107,15 +124,15 @@ Options:
 The `devlow-bench` package provides a few helper functions to run operations in the browser.
 
 ```js
-import { newBrowserSession } from "devlow-bench/browser";
+import { newBrowserSession } from 'devlow-bench/browser'
 
 const session = await newBrowserSession({
   // options
-});
-await session.hardNavigation("metric name", "https://example.com");
-await session.reload("metric name");
-await session.softNavigationByClick("metric name", ".selector-to-click");
-await session.close();
+})
+await session.hardNavigation('metric name', 'https://example.com')
+await session.reload('metric name')
+await session.softNavigationByClick('metric name', '.selector-to-click')
+await session.close()
 ```
 
 Run with `BROWSER_OUTPUT=1` to show the output of the browser.
@@ -162,8 +179,8 @@ Run with `SHELL_OUTPUT=1` to show the output of the shell commands.
 The `devlow-bench` package provides a few helper functions to run operations on the file system.
 
 ```js
-import { waitForFile } from "devlow-bench/file";
+import { waitForFile } from 'devlow-bench/file'
 
 // wait for file to exist
-await waitForFile("/path/to/file", /* timeout = */ 30000);
+await waitForFile('/path/to/file', /* timeout = */ 30000)
 ```

package/dist/browser.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from "playwright-chromium";
+import type { Page } from 'playwright-chromium';
 interface BrowserSession {
     close(): Promise<void>;
     hardNavigation(metricName: string, url: string): Promise<Page>;

package/dist/browser.js

@@ -1,5 +1,5 @@
-import { chromium } from "playwright-chromium";
-import { measureTime, reportMeasurement } from "./index.js";
+import { chromium } from 'playwright-chromium';
+import { measureTime, reportMeasurement } from './index.js';
 const browserOutput = Boolean(process.env.BROWSER_OUTPUT);
 async function withRequestMetrics(metricName, page, fn) {
     const activePromises = [];
@@ -9,9 +9,7 @@ async function withRequestMetrics(metricName, page, fn) {
         activePromises.push((async () => {
             const url = response.request().url();
             const status = response.status();
-            const extension = 
-            // eslint-disable-next-line prefer-named-capture-group -- TODO: address lint
-            /^[^?#]+\.([a-z0-9]+)(?:[?#]|$)/i.exec(url)?.[1] ?? "none";
+            const extension = /^[^?#]+\.([a-z0-9]+)(?:[?#]|$)/i.exec(url)?.[1] ?? 'none';
             const currentRequests = requestsByExtension.get(extension) ?? 0;
             requestsByExtension.set(extension, currentRequests + 1);
             if (status >= 200 && status < 300) {
@@ -35,10 +33,10 @@ async function withRequestMetrics(metricName, page, fn) {
     let logCount = 0;
     const consoleHandler = (message) => {
         const type = message.type();
-        if (type === "error") {
+        if (type === 'error') {
             errorCount++;
         }
-        else if (type === "warning") {
+        else if (type === 'warning') {
             warningCount++;
         }
         else {
@@ -68,31 +66,31 @@ async function withRequestMetrics(metricName, page, fn) {
         }
     };
     try {
-        page.on("response", responseHandler);
-        page.on("console", consoleHandler);
-        page.on("pageerror", exceptionHandler);
+        page.on('response', responseHandler);
+        page.on('console', consoleHandler);
+        page.on('pageerror', exceptionHandler);
         await fn();
         await Promise.all(activePromises);
         let totalDownload = 0;
         for (const [extension, size] of sizeByExtension.entries()) {
-            await reportMeasurement(`${metricName}/responseSizes/${extension}`, size, "bytes");
+            await reportMeasurement(`${metricName}/responseSizes/${extension}`, size, 'bytes');
             totalDownload += size;
         }
-        await reportMeasurement(`${metricName}/responseSizes`, totalDownload, "bytes");
+        await reportMeasurement(`${metricName}/responseSizes`, totalDownload, 'bytes');
         let totalRequests = 0;
         for (const [extension, count] of requestsByExtension.entries()) {
-            await reportMeasurement(`${metricName}/requests/${extension}`, count, "requests");
+            await reportMeasurement(`${metricName}/requests/${extension}`, count, 'requests');
             totalRequests += count;
         }
-        await reportMeasurement(`${metricName}/requests`, totalRequests, "requests");
-        await reportMeasurement(`${metricName}/console/logs`, logCount, "messages");
-        await reportMeasurement(`${metricName}/console/warnings`, warningCount, "messages");
-        await reportMeasurement(`${metricName}/console/errors`, errorCount, "messages");
-        await reportMeasurement(`${metricName}/console/uncaught`, uncaughtCount, "messages");
-        await reportMeasurement(`${metricName}/console`, logCount + warningCount + errorCount + uncaughtCount, "messages");
+        await reportMeasurement(`${metricName}/requests`, totalRequests, 'requests');
+        await reportMeasurement(`${metricName}/console/logs`, logCount, 'messages');
+        await reportMeasurement(`${metricName}/console/warnings`, warningCount, 'messages');
+        await reportMeasurement(`${metricName}/console/errors`, errorCount, 'messages');
+        await reportMeasurement(`${metricName}/console/uncaught`, uncaughtCount, 'messages');
+        await reportMeasurement(`${metricName}/console`, logCount + warningCount + errorCount + uncaughtCount, 'messages');
     }
     finally {
-        page.off("response", responseHandler);
+        page.off('response', responseHandler);
     }
 }
 /**
@@ -105,9 +103,9 @@ async function withRequestMetrics(metricName, page, fn) {
 function networkIdle(page, delayMs = 300, timeoutMs = 180000) {
     return new Promise((resolve) => {
         const cleanup = () => {
-            page.off("request", requestHandler);
-            page.off("requestfailed", requestFinishedHandler);
-            page.off("requestfinished", requestFinishedHandler);
+            page.off('request', requestHandler);
+            page.off('requestfailed', requestFinishedHandler);
+            page.off('requestfinished', requestFinishedHandler);
             clearTimeout(fullTimeout);
             if (timeout) {
                 clearTimeout(timeout);
@@ -119,12 +117,11 @@ function networkIdle(page, delayMs = 300, timeoutMs = 180000) {
         let timeout = null;
         const fullTimeout = setTimeout(() => {
             cleanup();
-            // eslint-disable-next-line no-console -- logging
-            console.error(`Timeout while waiting for network idle. These requests are still pending: ${Array.from(requests).join(", ")}} time is ${lastRequest - start}`);
+            console.error(`Timeout while waiting for network idle. These requests are still pending: ${Array.from(requests).join(', ')}} time is ${lastRequest - start}`);
             resolve(Date.now() - lastRequest);
         }, timeoutMs);
         const requestFilter = (request) => {
-            return request.headers().accept !== "text/event-stream";
+            return request.headers().accept !== 'text/event-stream';
         };
         const requestHandler = (request) => {
             requests.set(request.url(), (requests.get(request.url()) ?? 0) + 1);
@@ -147,7 +144,6 @@ function networkIdle(page, delayMs = 300, timeoutMs = 180000) {
             lastRequest = Date.now();
             const currentCount = requests.get(request.url());
             if (currentCount === undefined) {
-                // eslint-disable-next-line no-console -- basic logging
                 console.error(`Unexpected untracked but completed request ${request.url()}`);
                 return;
             }
@@ -164,9 +160,9 @@ function networkIdle(page, delayMs = 300, timeoutMs = 180000) {
                 }, delayMs);
             }
         };
-        page.on("request", requestHandler);
-        page.on("requestfailed", requestFinishedHandler);
-        page.on("requestfinished", requestFinishedHandler);
+        page.on('request', requestHandler);
+        page.on('requestfailed', requestFinishedHandler);
+        page.on('requestfinished', requestFinishedHandler);
     });
 }
 class BrowserSessionImpl {
@@ -191,17 +187,23 @@ class BrowserSessionImpl {
         await withRequestMetrics(metricName, page, async () => {
             await measureTime(`${metricName}/start`);
             const idle = networkIdle(page, 3000);
-            await page.goto(url, {
-                waitUntil: "commit",
+            const response = await page.goto(url, {
+                waitUntil: 'commit',
             });
+            if (!response) {
+                throw new Error(`Navigation to ${url} produced no response`);
+            }
+            if (!response.ok()) {
+                throw new Error(`Navigation to ${url} returned HTTP ${response.status()}`);
+            }
             await measureTime(`${metricName}/html`, {
                 relativeTo: `${metricName}/start`,
             });
-            await page.waitForLoadState("domcontentloaded");
+            await page.waitForLoadState('domcontentloaded');
             await measureTime(`${metricName}/dom`, {
                 relativeTo: `${metricName}/start`,
             });
-            await page.waitForLoadState("load");
+            await page.waitForLoadState('load');
             await measureTime(`${metricName}/load`, {
                 relativeTo: `${metricName}/start`,
             });
@@ -216,12 +218,12 @@ class BrowserSessionImpl {
     async softNavigationByClick(metricName, selector) {
         const page = this.page;
         if (!page) {
-            throw new Error("softNavigationByClick() must be called after hardNavigation()");
+            throw new Error('softNavigationByClick() must be called after hardNavigation()');
         }
         await withRequestMetrics(metricName, page, async () => {
             await measureTime(`${metricName}/start`);
             const firstResponse = new Promise((resolve) => {
-                page.once("response", () => {
+                page.once('response', () => {
                     resolve();
                 });
             });
@@ -241,22 +243,28 @@ class BrowserSessionImpl {
     async reload(metricName) {
         const page = this.page;
         if (!page) {
-            throw new Error("reload() must be called after hardNavigation()");
+            throw new Error('reload() must be called after hardNavigation()');
         }
         await withRequestMetrics(metricName, page, async () => {
             await measureTime(`${metricName}/start`);
             const idle = networkIdle(page, 3000);
-            await page.reload({
-                waitUntil: "commit",
+            const response = await page.reload({
+                waitUntil: 'commit',
             });
+            if (!response) {
+                throw new Error('Reload produced no response');
+            }
+            if (!response.ok()) {
+                throw new Error(`Reload returned HTTP ${response.status()}`);
+            }
             await measureTime(`${metricName}/html`, {
                 relativeTo: `${metricName}/start`,
             });
-            await page.waitForLoadState("domcontentloaded");
+            await page.waitForLoadState('domcontentloaded');
             await measureTime(`${metricName}/dom`, {
                 relativeTo: `${metricName}/start`,
             });
-            await page.waitForLoadState("load");
+            await page.waitForLoadState('load');
             await measureTime(`${metricName}/load`, {
                 relativeTo: `${metricName}/start`,
             });
@@ -270,12 +278,12 @@ class BrowserSessionImpl {
 }
 export async function newBrowserSession(options) {
     const browser = await chromium.launch({
-        headless: options.headless ?? process.env.HEADLESS !== "false",
-        devtools: true,
+        headless: options.headless ?? process.env.HEADLESS !== 'false',
+        args: options.headless ? undefined : ['--auto-open-devtools-for-tabs'],
         timeout: 60000,
     });
     const context = await browser.newContext({
-        baseURL: options.baseURL ?? "http://localhost:3000",
+        baseURL: options.baseURL ?? 'http://localhost:3000',
         viewport: { width: 1280, height: 720 },
     });
     context.setDefaultTimeout(120000);

package/dist/cli.js

@@ -1,73 +1,94 @@
-import minimist from "minimist";
-import { setCurrentScenarios } from "./describe.js";
-import { join } from "path";
-import { runScenarios } from "./index.js";
-import compose from "./interfaces/compose.js";
-import { pathToFileURL } from "url";
+import { Command } from 'commander';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { groupRows, printComparison } from './compare.js';
+import { setCurrentScenarios } from './describe.js';
+import { runScenarios } from './index.js';
+import compose from './interfaces/compose.js';
+import { readSnapshot, resolveCompareTarget } from './snapshot.js';
+;
 (async () => {
-    const knownArgs = new Set([
-        "scenario",
-        "s",
-        "json",
-        "j",
-        "console",
-        "datadog",
-        "snowflake",
-        "interactive",
-        "i",
-        "help",
-        "h",
-        "?",
-        "_",
+    const program = new Command()
+        .name('devlow-bench')
+        .description('Run developer-workflow benchmarks.')
+        .showHelpAfterError();
+    program
+        .command('run', { isDefault: true })
+        .description('Run scenario files and report measurements.')
+        .argument('[scenarios...]', 'Scenario module paths to load.')
+        .option('-s, --scenario <filter>', 'Only run scenarios whose name matches the filter (repeatable).', (v, prev) => (prev ?? []).concat(v), [])
+        .option('-F, --filter <pair>', 'Filter variants by property: -F key=value (repeatable; same key repeated = OR).', (v, prev) => (prev ?? []).concat(v), [])
+        .option('-i, --interactive', 'Select scenarios and variants interactively.')
+        .option('--n <number>', 'Run each variant N times; reports mean/p50/p90 per metric. Default: 1.', (v) => Number(v))
+        .option('--warmup <number>', 'Discard the first N runs of each variant before sampling. Default: 0. Do NOT enable when measuring cold-start metrics.', (v) => Number(v))
+        .option('--snapshot <path>', 'Override the snapshot CSV path. Default: ./.devlow-bench/snapshots/<ts>.csv. Snapshots are always written.')
+        .option('--compare', 'Print a comparison table at end of run. Baseline = newest snapshot, unless --baseline overrides.')
+        .option('--baseline <path>', 'Explicit baseline (file or directory). Implies --compare.')
+        .option('-j, --json <path>', 'Write the results to the given path as JSON.')
+        .option('--no-console', 'Suppress console output.')
+        .option('--datadog [host]', 'Upload the results to Datadog (requires DATADOG_API_KEY).')
+        .option('--snowflake [batchUri]', 'Upload the results to Snowflake (requires SNOWFLAKE_TOPIC_NAME and SNOWFLAKE_SCHEMA_ID).')
+        .action(runRun);
+    program
+        .command('compare')
+        .description('Compare two snapshot CSVs side-by-side, with p50/p90/p99 plus a Mann–Whitney U p-value per metric.')
+        .argument('<baseline>', 'Baseline snapshot CSV path.')
+        .argument('<current>', 'Current snapshot CSV path.')
+        .action(runCompare);
+    await program.parseAsync();
+})().catch((e) => {
+    console.error(e.stack);
+    process.exit(1);
+});
+async function runCompare(baselinePath, currentPath) {
+    const [baseRows, curRows] = await Promise.all([
+        readSnapshot(baselinePath),
+        readSnapshot(currentPath),
     ]);
-    const args = minimist(process.argv.slice(2), {
-        alias: {
-            s: "scenario",
-            j: "json",
-            i: "interactive",
-            "?": "help",
-            h: "help",
-        },
+    printComparison(groupRows(baseRows), groupRows(curRows), {
+        baselineLabel: baselinePath,
+        currentLabel: currentPath,
     });
-    if (args.help || (Object.keys(args).length === 1 && args._.length === 0)) {
-        console.log("Usage: devlow-bench [options] <scenario files>");
-        console.log("## Selecting scenarios");
-        console.log("  --scenario=<filter>, -s=<filter>   Only run the scenario with the given name");
-        console.log("  --interactive, -i                  Select scenarios and variants interactively");
-        console.log("  --<prop>=<value>                   Filter by any variant property defined in scenarios");
-        console.log("## Output");
-        console.log("  --json=<path>, -j=<path>           Write the results to the given path as JSON");
-        console.log("  --console                          Print the results to the console");
-        console.log("  --datadog[=<hostname>]             Upload the results to Datadog");
-        console.log("                                     (requires DATADOG_API_KEY environment variables)");
-        console.log("  --snowflake[=<batch-uri>]          Upload the results to Snowflake");
-        console.log("                                     (requires SNOWFLAKE_TOPIC_NAME and SNOWFLAKE_SCHEMA_ID and environment variables)");
-        console.log("## Help");
-        console.log("  --help, -h, -?                     Show this help");
+}
+async function runRun(scenarioPaths, opts) {
+    const propFilters = [];
+    for (const pair of opts.filter ?? []) {
+        const eq = pair.indexOf('=');
+        if (eq === -1) {
+            console.error(`devlow-bench: invalid -F ${pair} (expected key=value).`);
+            process.exit(1);
+        }
+        propFilters.push([pair.slice(0, eq), pair.slice(eq + 1)]);
     }
     const scenarios = [];
     setCurrentScenarios(scenarios);
-    for (const path of args._) {
+    for (const path of scenarioPaths) {
         await import(pathToFileURL(join(process.cwd(), path)).toString());
     }
     setCurrentScenarios(null);
     const cliIface = {
-        filterScenarios: async (scenarios) => {
-            if (args.scenario) {
-                const filter = [].concat(args.scenario);
-                return scenarios.filter((s) => filter.some((filter) => s.name.includes(filter)));
-            }
-            return scenarios;
+        filterScenarios: async (allScenarios) => {
+            const filters = opts.scenario;
+            if (!filters || filters.length === 0)
+                return allScenarios;
+            return allScenarios.filter((s) => filters.some((f) => s.name.includes(f)));
         },
         filterScenarioVariants: async (variants) => {
-            const propEntries = Object.entries(args).filter(([key]) => !knownArgs.has(key));
-            if (propEntries.length === 0)
+            if (propFilters.length === 0)
                 return variants;
-            for (const [key, value] of propEntries) {
-                const values = (Array.isArray(value) ? value : [value]).map((v) => v.toString());
+            // Group multiple -F key=value with the same key into an OR set.
+            const byKey = new Map();
+            for (const [k, v] of propFilters) {
+                const existing = byKey.get(k);
+                if (existing)
+                    existing.push(v);
+                else
+                    byKey.set(k, [v]);
+            }
+            for (const [key, values] of byKey) {
                 variants = variants.filter((variant) => {
                     const prop = variant.props[key];
-                    if (typeof prop === "undefined")
+                    if (typeof prop === 'undefined')
                         return false;
                     const str = prop.toString();
                     return values.some((v) => str.includes(v));
@@ -76,19 +97,43 @@ import { pathToFileURL } from "url";
             return variants;
         },
     };
-    let ifaces = [
+    // Validation (clamp to non-negative integers, default n=1/warmup=0) is
+    // delegated to runScenarios — see runner.ts.
+    const n = typeof opts.n === 'number' && Number.isFinite(opts.n) ? opts.n : 1;
+    const warmup = typeof opts.warmup === 'number' && Number.isFinite(opts.warmup)
+        ? opts.warmup
+        : 0;
+    // Snapshot is always on. --snapshot=<path> overrides the default path.
+    const snapshotIface = (await import('./interfaces/snapshot.js')).default({
+        path: opts.snapshot,
+    });
+    // Comparison: enabled by --compare or by giving an explicit --baseline.
+    const compareEnabled = opts.compare === true || typeof opts.baseline === 'string';
+    let compareIface = null;
+    if (compareEnabled) {
+        const baselineArg = typeof opts.baseline === 'string' ? opts.baseline : true;
+        const baselinePath = await resolveCompareTarget(baselineArg, snapshotIface.resolvedPath);
+        if (baselinePath == null) {
+            console.error('No baseline snapshot found. Run devlow-bench at least once, or pass --baseline=<path>.');
+            process.exit(1);
+        }
+        compareIface = await (await import('./interfaces/compare.js')).default({ baselinePath });
+    }
+    const ifaces = [
         cliIface,
-        args.interactive && (await import("./interfaces/interactive.js")).default(),
-        args.json && (await import("./interfaces/json.js")).default(args.json),
-        args.datadog &&
-            (await import("./interfaces/datadog.js")).default(typeof args.datadog === "string" ? { host: args.datadog } : undefined),
-        args.snowflake &&
-            (await import("./interfaces/snowflake.js")).default(typeof args.snowflake === "string" ? { gatewayUri: args.snowflake } : undefined),
-        args.console !== false &&
-            (await import("./interfaces/console.js")).default(),
+        opts.interactive && (await import('./interfaces/interactive.js')).default(),
+        opts.json &&
+            (await import('./interfaces/json.js')).default(opts.json, { n }),
+        opts.datadog &&
+            (await import('./interfaces/datadog.js')).default(typeof opts.datadog === 'string' ? { host: opts.datadog } : undefined),
+        opts.snowflake &&
+            (await import('./interfaces/snowflake.js')).default(typeof opts.snowflake === 'string'
+                ? { gatewayUri: opts.snowflake }
+                : undefined),
+        opts.console !== false &&
+            (await import('./interfaces/console.js')).default({ n }),
+        compareIface,
+        snapshotIface,
     ].filter((x) => x);
-    await runScenarios(scenarios, compose(...ifaces));
-})().catch((e) => {
-    console.error(e.stack);
-    process.exit(1);
-});
+    await runScenarios(scenarios, compose(...ifaces), { n, warmup });
+}

package/dist/compare.d.ts

@@ -0,0 +1,14 @@
+import type { SnapshotRow } from './snapshot.js';
+export interface SampleGroup {
+    scenario: string;
+    variant: string;
+    metric: string;
+    unit: string;
+    samples: number[];
+}
+export declare function groupRows(rows: SnapshotRow[]): Map<string, SampleGroup>;
+export declare function makeKey(scenario: string, variant: string, metric: string): string;
+export declare function printComparison(baseline: Map<string, SampleGroup>, current: Map<string, SampleGroup>, options?: {
+    baselineLabel: string;
+    currentLabel?: string;
+}): void;