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

package/dist/compare.js

@@ -0,0 +1,209 @@
+import picocolors from 'picocolors';
+import { mannWhitneyU, quantile } from './statistics.js';
+import { formatUnit } from './units.js';
+const { bold, dim, green, red, underline } = picocolors;
+const SIGNIFICANCE_THRESHOLD = 0.05;
+// Groups SnapshotRows into per-(scenario, variant, metric) sample arrays.
+// Skips rows whose value is non-finite (e.g. failed CSV parse).
+export function groupRows(rows) {
+    const out = new Map();
+    for (const r of rows) {
+        if (!Number.isFinite(r.value))
+            continue;
+        const key = makeKey(r.scenario, r.variant, r.metric);
+        let group = out.get(key);
+        if (!group) {
+            group = {
+                scenario: r.scenario,
+                variant: r.variant,
+                metric: r.metric,
+                unit: r.unit,
+                samples: [],
+            };
+            out.set(key, group);
+        }
+        group.samples.push(r.value);
+    }
+    return out;
+}
+export function makeKey(scenario, variant, metric) {
+    return `${scenario}\x00${variant}\x00${metric}`;
+}
+// Prints the comparison table comparing baseline (A) to current (B).
+// Reports series only in one side and unit mismatches separately.
+export function printComparison(baseline, current, options = {
+    baselineLabel: 'baseline',
+}) {
+    const { baselineLabel, currentLabel } = options;
+    console.log();
+    if (currentLabel) {
+        console.log(bold(underline(`Comparison: ${baselineLabel} → ${currentLabel}`)));
+    }
+    else {
+        console.log(bold(underline(`Comparison vs baseline: ${baselineLabel}`)));
+    }
+    const pairs = [];
+    const onlyInCurrent = [];
+    const onlyInBaseline = [];
+    const skippedMismatch = [];
+    for (const [key, cur] of current) {
+        const base = baseline.get(key);
+        if (!base) {
+            onlyInCurrent.push(`${cur.scenario} · ${cur.variant} · ${cur.metric}`);
+            continue;
+        }
+        if (base.unit !== cur.unit) {
+            skippedMismatch.push(`${cur.scenario} · ${cur.variant} · ${cur.metric} (baseline=${base.unit}, current=${cur.unit})`);
+            continue;
+        }
+        pairs.push({ base, cur });
+    }
+    for (const [key, base] of baseline) {
+        if (!current.has(key)) {
+            onlyInBaseline.push(`${base.scenario} · ${base.variant} · ${base.metric}`);
+        }
+    }
+    // Hoist the most common sample count for each side into a banner above the
+    // table; per-row `(n)` is then shown only for rows that deviate from it,
+    // so the eye-catching exceptions aren't drowned in repeated `(7)`s.
+    const baseMode = modeN(pairs.map((p) => p.base.samples.length));
+    const curMode = modeN(pairs.map((p) => p.cur.samples.length));
+    if (pairs.length > 0) {
+        if (baseMode != null && curMode != null) {
+            const banner = baseMode === curMode
+                ? `n = ${baseMode} per metric`
+                : `baseline n = ${baseMode}, current n = ${curMode}`;
+            console.log(bold(banner));
+        }
+        const header = [
+            'Scenario · Variant',
+            'Metric',
+            'Baseline p50 / p90 / p99',
+            'Current p50 / p90 / p99',
+            'Δ p50',
+            'Δ%',
+            'p',
+        ];
+        const rows = pairs.map(({ base, cur }) => formatRow(base, cur, baseMode, curMode));
+        printTable(header, rows);
+    }
+    else {
+        console.log(dim('No matching (scenario, variant, metric) tuples between current and baseline.'));
+    }
+    logList('Only in current', onlyInCurrent);
+    logList('Only in baseline', onlyInBaseline);
+    logList('Skipped due to unit mismatch', skippedMismatch, Infinity);
+}
+function logList(label, items, max = 5) {
+    if (items.length === 0)
+        return;
+    const shown = items.slice(0, max).join(', ');
+    const suffix = items.length > max ? '…' : '';
+    console.log(dim(`${label} (${items.length}): ${shown}${suffix}`));
+}
+// Picks the most common n in the list. Ties are broken in favor of the
+// larger n (treat "the typical fully-collected sample count" as the default).
+// Returns null for an empty list.
+function modeN(ns) {
+    if (ns.length === 0)
+        return null;
+    const counts = new Map();
+    for (const n of ns)
+        counts.set(n, (counts.get(n) ?? 0) + 1);
+    let bestN = ns[0];
+    let bestCount = 0;
+    for (const [n, c] of counts) {
+        if (c > bestCount || (c === bestCount && n > bestN)) {
+            bestN = n;
+            bestCount = c;
+        }
+    }
+    return bestN;
+}
+function formatRow(base, cur, baseMode, curMode) {
+    const bs = percentiles(base.samples);
+    const cs = percentiles(cur.samples);
+    const delta = cs.p50 - bs.p50;
+    const deltaPct = bs.p50 === 0 ? NaN : (delta / bs.p50) * 100;
+    const mwu = mannWhitneyU(base.samples, cur.samples);
+    // Color verdict uses Mann–Whitney U's p as the significance signal, with
+    // the sign of the p50 shift determining improvement vs regression.
+    let verdict;
+    if (Number.isFinite(mwu.p) && mwu.p < SIGNIFICANCE_THRESHOLD && delta !== 0) {
+        verdict = delta < 0 ? 'improved' : 'regressed';
+    }
+    return {
+        cells: [
+            `${base.scenario} · ${base.variant}`,
+            base.metric,
+            formatGroupCell(base, bs, base.samples.length !== baseMode),
+            formatGroupCell(cur, cs, cur.samples.length !== curMode),
+            formatDelta(delta, base.unit),
+            Number.isFinite(deltaPct) ? `${deltaPct.toFixed(1)}%` : 'n/a',
+            formatP(mwu.p),
+        ],
+        verdict,
+    };
+}
+function percentiles(samples) {
+    return {
+        p50: quantile(samples, 0.5),
+        p90: quantile(samples, 0.9),
+        p99: quantile(samples, 0.99),
+    };
+}
+function formatGroupCell(group, s, showN) {
+    const parts = [s.p50, s.p90, s.p99].map((v) => splitFormattedUnit(v, group.unit));
+    const nSuffix = showN ? ` (${group.samples.length})` : '';
+    // If all three values render with the same unit suffix (e.g. all "requests"),
+    // only print the suffix on the last value to avoid "7 req / 7 req / 7 req".
+    if (parts[0].suffix === parts[1].suffix &&
+        parts[1].suffix === parts[2].suffix) {
+        return `${parts[0].num} / ${parts[1].num} / ${parts[2].num}${parts[2].suffix}${nSuffix}`;
+    }
+    return `${parts[0].num}${parts[0].suffix} / ${parts[1].num}${parts[1].suffix} / ${parts[2].num}${parts[2].suffix}${nSuffix}`;
+}
+function splitFormattedUnit(value, unit) {
+    const formatted = formatUnit(value, unit);
+    const m = /^(-?\d+(?:\.\d+)?)(.*)$/.exec(formatted);
+    if (!m)
+        return { num: formatted, suffix: '' };
+    return { num: m[1], suffix: m[2] };
+}
+function formatDelta(d, unit) {
+    if (!Number.isFinite(d))
+        return 'n/a';
+    const sign = d > 0 ? '+' : '';
+    return `${sign}${formatUnit(d, unit)}`;
+}
+function formatP(p) {
+    if (!Number.isFinite(p))
+        return String(p);
+    if (p === 0)
+        return '0';
+    if (p < 1e-3)
+        return p.toExponential(2);
+    return p.toFixed(3);
+}
+function printTable(header, rows) {
+    const widths = header.map((h) => h.length);
+    for (const r of rows) {
+        for (let i = 0; i < r.cells.length; i++) {
+            if (r.cells[i].length > widths[i])
+                widths[i] = r.cells[i].length;
+        }
+    }
+    const pad = (s, w) => s + ' '.repeat(w - s.length);
+    const line = (cells, paint = (s) => s) => '| ' + cells.map((c, i) => paint(pad(c, widths[i]))).join(' | ') + ' |';
+    const sep = '|' + widths.map((w) => '-'.repeat(w + 2)).join('|') + '|';
+    console.log(line(header));
+    console.log(sep);
+    for (const r of rows) {
+        const paint = r.verdict === 'improved'
+            ? green
+            : r.verdict === 'regressed'
+                ? red
+                : undefined;
+        console.log(line(r.cells, paint));
+    }
+}

package/dist/describe.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigFor, CurrentScenario, Scenario } from "./index.js";
+import type { ConfigFor, CurrentScenario, Scenario } from './index.js';
 export declare function setCurrentScenarios(scenarios: Scenario[] | null): void;
 export declare function describe<P>(name: string, config: ConfigFor<P>, fn: (props: P) => Promise<void>): void;
 export declare namespace describe {

package/dist/describe.js

@@ -1,5 +1,5 @@
-import compose from "./interfaces/compose.js";
-import { runScenarios } from "./runner.js";
+import compose from './interfaces/compose.js';
+import { runScenarios } from './runner.js';
 let currentScenarios = null;
 export function setCurrentScenarios(scenarios) {
     currentScenarios = scenarios;
@@ -8,9 +8,9 @@ export function describe(name, config, fn) {
     if (currentScenarios === null) {
         const scenarios = (currentScenarios = []);
         Promise.resolve().then(async () => {
-            const ifaceNames = process.env.INTERFACE || "interactive,console";
+            const ifaceNames = process.env.INTERFACE || 'interactive,console';
             const ifaces = [];
-            for (const ifaceName of ifaceNames.split(",").map((s) => s.trim())) {
+            for (const ifaceName of ifaceNames.split(',').map((s) => s.trim())) {
                 let iface;
                 try {
                     iface = await import(`./interfaces/${ifaceName}.js`);
@@ -19,7 +19,7 @@ export function describe(name, config, fn) {
                     iface = await import(ifaceName);
                 }
                 iface = (iface && iface.default) || iface;
-                if (typeof iface === "function") {
+                if (typeof iface === 'function') {
                     iface = await iface();
                 }
                 if (!iface) {
@@ -32,7 +32,7 @@ export function describe(name, config, fn) {
     }
     const normalizedConfig = Object.fromEntries(Object.entries(config).map(([key, value]) => [
         key,
-        typeof value === "boolean"
+        typeof value === 'boolean'
             ? [value, !value]
             : value,
     ]));
@@ -55,36 +55,36 @@ export function withCurrent(current, fn) {
         currentScenario = prev;
     });
 }
-export const PREVIOUS = Symbol("previous measurement with that unit");
+export const PREVIOUS = Symbol('previous measurement with that unit');
 export async function measureTime(name, options = {}) {
     const end = Date.now() - (options.offset || 0);
-    await reportMeasurement(name, end, "ms", {
+    await reportMeasurement(name, end, 'ms', {
         relativeTo: PREVIOUS,
         ...options,
     });
 }
 export async function reportMeasurement(name, value, unit, options = {}) {
     if (!currentScenario) {
-        throw new Error("reportMeasurement() must be called inside of describe()");
+        throw new Error('reportMeasurement() must be called inside of describe()');
     }
-    if (typeof name !== "string") {
-        throw new Error("reportMeasurement() must be called with a name that is a string");
+    if (typeof name !== 'string') {
+        throw new Error('reportMeasurement() must be called with a name that is a string');
     }
-    if (typeof value !== "number") {
-        throw new Error("reportMeasurement() must be called with a value that is a number");
+    if (typeof value !== 'number') {
+        throw new Error('reportMeasurement() must be called with a value that is a number');
     }
     if (isNaN(value)) {
-        throw new Error("reportMeasurement() must be called with a value that is not NaN");
+        throw new Error('reportMeasurement() must be called with a value that is not NaN');
     }
     if (!isFinite(value)) {
-        throw new Error("reportMeasurement() must be called with a value that is finite");
+        throw new Error('reportMeasurement() must be called with a value that is finite');
     }
-    if (typeof unit !== "string") {
-        throw new Error("reportMeasurement() must be called with a unit that is a string");
+    if (typeof unit !== 'string') {
+        throw new Error('reportMeasurement() must be called with a unit that is a string');
     }
     let { relativeTo, scenario, props } = options;
     if (relativeTo === PREVIOUS) {
-        relativeTo = "previous";
+        relativeTo = 'previous';
         for (const [prevName, prev] of currentScenario.measurements) {
             if (prev.unit === unit) {
                 relativeTo = prevName;

package/dist/file.js

@@ -4,7 +4,7 @@ import { dirname } from 'path';
 export async function waitForFile(path, timeout) {
     let currentAction = '';
     let timeoutRef;
-    const timeoutPromise = new Promise((resolve, reject) => {
+    const timeoutPromise = new Promise((_resolve, reject) => {
         timeoutRef = setTimeout(() => {
             reject(new Error(`Timed out waiting for file ${path} (${currentAction}))`));
         }, timeout || 60000);
@@ -21,16 +21,16 @@ export async function waitForFile(path, timeout) {
     }
     elements.reverse();
     try {
-        for (const path of elements) {
-            const checkAccess = () => access(path, constants.F_OK)
+        for (const element of elements) {
+            const checkAccess = () => access(element, constants.F_OK)
                 .then(() => true)
                 .catch(() => false);
             if (!(await checkAccess())) {
                 let resolveCheckAgain = () => { };
-                const watcher = watch(dirname(path), () => {
+                const watcher = watch(dirname(element), () => {
                     resolveCheckAgain();
                 });
-                currentAction = `waiting for ${path}`;
+                currentAction = `waiting for ${element}`;
                 let checkAgainPromise = new Promise((resolve) => {
                     resolveCheckAgain = resolve;
                 });

package/dist/index.d.ts

@@ -20,15 +20,28 @@ export interface CurrentScenario {
     }>;
 }
 export type Interface = Partial<FullInterface>;
+export interface VariantStatistic {
+    samples: number[];
+    unit: string;
+    relativeTo?: string;
+    mean: number;
+    p50: number;
+    p90: number;
+}
 export interface FullInterface {
     filterScenarios(scenarios: Scenario[]): Promise<Scenario[]>;
     filterScenarioVariants(scenarioVariants: ScenarioVariant[]): Promise<ScenarioVariant[]>;
-    start(scenario: string, props: Record<string, string | number | boolean | null>): Promise<void>;
+    start(scenario: string, props: Record<string, string | number | boolean | null>, runInfo?: {
+        run: number;
+        total: number;
+        warmup: boolean;
+    }): Promise<void>;
     measurement(scenario: string, props: Record<string, string | number | boolean | null>, name: string, value: number, unit: string, relativeTo?: string): Promise<void>;
     end(scenario: string, props: Record<string, string | number | boolean | null>): Promise<void>;
     error(scenario: string, props: Record<string, string | number | boolean | null>, error: unknown): Promise<void>;
+    variantStatistics(scenario: string, props: Record<string, string | number | boolean | null>, stats: Record<string, VariantStatistic>): Promise<void>;
     finish(): Promise<void>;
 }
 export declare function intoFullInterface(iface: Interface): FullInterface;
-export { describe, measureTime, reportMeasurement, PREVIOUS, } from "./describe.js";
-export { runScenarios } from "./runner.js";
+export { describe, measureTime, reportMeasurement, PREVIOUS, } from './describe.js';
+export { runScenarios } from './runner.js';

package/dist/index.js

@@ -7,8 +7,9 @@ export function intoFullInterface(iface) {
         measurement: iface.measurement ?? (async () => { }),
         end: iface.end ?? (async () => { }),
         error: iface.error ?? (async () => { }),
+        variantStatistics: iface.variantStatistics ?? (async () => { }),
         finish: iface.finish ?? (async () => { }),
     };
 }
-export { describe, measureTime, reportMeasurement, PREVIOUS, } from "./describe.js";
-export { runScenarios } from "./runner.js";
+export { describe, measureTime, reportMeasurement, PREVIOUS, } from './describe.js';
+export { runScenarios } from './runner.js';

package/dist/interfaces/compare.d.ts

@@ -0,0 +1,4 @@
+import type { Interface } from '../index.js';
+export default function createInterface(options: {
+    baselinePath: string;
+}): Promise<Interface>;

package/dist/interfaces/compare.js

@@ -0,0 +1,27 @@
+import { groupRows, makeKey, printComparison, } from '../compare.js';
+import { readSnapshot } from '../snapshot.js';
+import { formatVariantProps } from '../utils.js';
+export default async function createInterface(options) {
+    const baselinePath = options.baselinePath;
+    const baselineRows = await readSnapshot(baselinePath);
+    const baseline = groupRows(baselineRows);
+    const current = new Map();
+    return {
+        variantStatistics: async (scenario, props, stats) => {
+            const variant = formatVariantProps(props);
+            for (const [metric, s] of Object.entries(stats)) {
+                const key = makeKey(scenario, variant, metric);
+                current.set(key, {
+                    scenario,
+                    variant,
+                    metric,
+                    unit: s.unit,
+                    samples: s.samples.slice(),
+                });
+            }
+        },
+        finish: async () => {
+            printComparison(baseline, current, { baselineLabel: baselinePath });
+        },
+    };
+}

package/dist/interfaces/compose.d.ts

@@ -1,2 +1,2 @@
-import { Interface } from "../index.js";
+import type { Interface } from '../index.js';
 export default function compose(...ifaces: Interface[]): Interface;

package/dist/interfaces/compose.js

@@ -7,7 +7,7 @@ export default function compose(...ifaces) {
     }
     const composed = {};
     for (const key of allKeys) {
-        if (key.startsWith("filter")) {
+        if (key.startsWith('filter')) {
             composed[key] = async (items, ...args) => {
                 for (const iface of ifaces) {
                     const anyIface = iface;

package/dist/interfaces/console.d.ts

@@ -1,2 +1,4 @@
-import { Interface } from "../index.js";
-export default function createInterface(): Interface;
+import type { Interface } from '../index.js';
+export default function createInterface(options?: {
+    n?: number;
+}): Interface;

package/dist/interfaces/console.js

@@ -1,14 +1,36 @@
-import picocolors from "picocolors";
-import { formatUnit } from "../units.js";
-import { formatVariant } from "../utils.js";
-const { bgCyan, bold, magenta, red, underline } = picocolors;
-export default function createInterface() {
+import picocolors from 'picocolors';
+import { formatUnit } from '../units.js';
+import { formatVariant } from '../utils.js';
+const { bgCyan, bold, cyan, dim, magenta, red, underline } = picocolors;
+export default function createInterface(options = {}) {
+    const n = options.n ?? 1;
+    const showSummary = n > 1;
     const iface = {
-        start: async (scenario, props) => {
-            console.log(bold(underline(`Running ${formatVariant(scenario, props)}...`)));
+        start: async (scenario, props, runInfo) => {
+            const label = formatVariant(scenario, props);
+            let progress = '';
+            if (runInfo) {
+                progress = runInfo.warmup
+                    ? ` [warmup ${runInfo.run}/${runInfo.total}]`
+                    : ` [${runInfo.run}/${runInfo.total}]`;
+            }
+            console.log(bold(underline(`Running ${label}...${progress}`)));
         },
         measurement: async (scenario, props, name, value, unit, relativeTo) => {
-            console.log(bgCyan(bold(magenta(`${formatVariant(scenario, props)}: ${name} = ${formatUnit(value, unit)}${relativeTo ? ` (from ${relativeTo})` : ""}`))));
+            console.log(bgCyan(bold(magenta(`${formatVariant(scenario, props)}: ${name} = ${formatUnit(value, unit)}${relativeTo ? ` (from ${relativeTo})` : ''}`))));
+        },
+        variantStatistics: async (scenario, props, stats) => {
+            if (!showSummary)
+                return;
+            const header = `${formatVariant(scenario, props)}  (n=${n})`;
+            console.log(bold(cyan(header)));
+            for (const [name, s] of Object.entries(stats)) {
+                const meanText = formatUnit(s.mean, s.unit);
+                const p50Text = formatUnit(s.p50, s.unit);
+                const p90Text = formatUnit(s.p90, s.unit);
+                const relText = s.relativeTo ? dim(` (from ${s.relativeTo})`) : '';
+                console.log(`  ${name}: mean=${meanText}  p50=${p50Text}  p90=${p90Text}${relText}`);
+            }
         },
         error: async (scenario, props, error) => {
             console.log(bold(red(`${formatVariant(scenario, props)}: ${(error && error.stack) || error}`)));

package/dist/interfaces/constants.js

@@ -1,19 +1,19 @@
-import os from "node:os";
-import { command } from "../shell.js";
+import os from 'node:os';
+import { command } from '../shell.js';
 export const UNIT_MAPPING = {
-    ms: "millisecond",
-    requests: "request",
-    bytes: "byte",
+    ms: 'millisecond',
+    requests: 'request',
+    bytes: 'byte',
 };
 export const GIT_SHA = process.env.GITHUB_SHA ??
     (await (async () => {
-        const cmd = command("git", ["rev-parse", "HEAD"]);
+        const cmd = command('git', ['rev-parse', 'HEAD']);
         await cmd.ok();
         return cmd.output.trim();
     })());
 export const GIT_BRANCH = process.env.GITHUB_REF_NAME ??
     (await (async () => {
-        const cmd = command("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+        const cmd = command('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
         await cmd.ok();
         return cmd.output.trim();
     })());

package/dist/interfaces/datadog.d.ts

@@ -1,4 +1,4 @@
-import type { Interface } from "../index.js";
+import type { Interface } from '../index.js';
 export default function createInterface({ apiKey, appKey, host, }?: {
     apiKey?: string;
     appKey?: string;

package/dist/interfaces/datadog.js

@@ -1,17 +1,17 @@
-import datadogApiClient from "@datadog/datadog-api-client";
-import os from "os";
-import { CPU_ARCH, CPU_MODEL, GIT_BRANCH, GIT_SHA, IS_CI, NODE_VERSION, NUM_CPUS, OS, OS_RELEASE, USERNAME } from "./constants.js";
+import datadogApiClient from '@datadog/datadog-api-client';
+import os from 'os';
+import { CPU_ARCH, CPU_MODEL, GIT_BRANCH, GIT_SHA, IS_CI, NODE_VERSION, NUM_CPUS, OS, OS_RELEASE, USERNAME, } from './constants.js';
 function toIdentifier(str) {
-    return str.replace(/\//g, ".").replace(/ /g, "_");
+    return str.replace(/\//g, '.').replace(/ /g, '_');
 }
 const UNIT_MAPPING = {
-    ms: "millisecond",
-    requests: "request",
-    bytes: "byte",
+    ms: 'millisecond',
+    requests: 'request',
+    bytes: 'byte',
 };
 export default function createInterface({ apiKey = process.env.DATADOG_API_KEY, appKey = process.env.DATADOG_APP_KEY, host = process.env.DATADOG_HOST || os.hostname(), } = {}) {
     if (!apiKey)
-        throw new Error("Datadog API key is required (set DATADOG_API_KEY)");
+        throw new Error('Datadog API key is required (set DATADOG_API_KEY)');
     const commonTags = [
         `ci:${IS_CI}`,
         `os:${OS}`,
@@ -35,7 +35,7 @@ export default function createInterface({ apiKey = process.env.DATADOG_API_KEY,
     const dataPoints = [];
     const metricMetadata = {};
     const iface = {
-        measurement: async (scenario, props, name, value, unit, relativeTo) => {
+        measurement: async (scenario, props, name, value, unit, _relativeTo) => {
             const ts = Math.round(Date.now() / 1000);
             const metric = toIdentifier(`devlow_bench/${scenario}/${name}`);
             if (UNIT_MAPPING[unit]) {
@@ -45,16 +45,16 @@ export default function createInterface({ apiKey = process.env.DATADOG_API_KEY,
             }
             dataPoints.push({
                 metric,
-                type: "distribution",
+                type: 'distribution',
                 host,
                 tags: Object.entries(props)
-                    .filter(([, value]) => value !== null)
-                    .map(([key, value]) => `${toIdentifier(key)}:${toIdentifier(value.toString())}`)
+                    .filter(([, propValue]) => propValue !== null)
+                    .map(([key, propValue]) => `${toIdentifier(key)}:${toIdentifier(propValue.toString())}`)
                     .concat(commonTags),
                 points: [[ts, [value]]],
             });
         },
-        end: async (scenario, props) => {
+        end: async (_scenario, _props) => {
             await api.submitDistributionPoints({
                 body: {
                     series: dataPoints,

package/dist/interfaces/interactive.d.ts

@@ -1,2 +1,2 @@
-import { Interface } from "../index.js";
+import type { Interface } from '../index.js';
 export default function createInterface(): Interface;

package/dist/interfaces/interactive.js

@@ -1,5 +1,5 @@
-import inquirer from "inquirer";
-import { formatVariant } from "../utils.js";
+import inquirer from 'inquirer';
+import { formatVariant } from '../utils.js';
 export default function createInterface() {
     const iface = {
         filterScenarios: async (scenarios) => {
@@ -7,10 +7,10 @@ export default function createInterface() {
                 return scenarios;
             }
             let answer = await inquirer.prompt({
-                type: "checkbox",
-                name: "scenarios",
+                type: 'checkbox',
+                name: 'scenarios',
                 default: scenarios.slice(),
-                message: "Choose scenarios to run",
+                message: 'Choose scenarios to run',
                 choices: scenarios.map((scenario) => ({
                     name: scenario.name,
                     value: scenario,
@@ -23,10 +23,10 @@ export default function createInterface() {
                 return variants;
             }
             let answer = await inquirer.prompt({
-                type: "checkbox",
-                name: "variants",
+                type: 'checkbox',
+                name: 'variants',
                 default: variants.slice(),
-                message: "Choose variants to run",
+                message: 'Choose variants to run',
                 choices: variants.map((variant) => {
                     return {
                         name: formatVariant(variant.scenario.name, variant.props),

package/dist/interfaces/json.d.ts

@@ -1,2 +1,4 @@
-import { Interface } from "../index.js";
-export default function createInterface(file?: string): Interface;
+import type { Interface } from '../index.js';
+export default function createInterface(file?: string, options?: {
+    n?: number;
+}): Interface;