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

package/dist/snapshot.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_SNAPSHOT_DIR = ".devlow-bench/snapshots";
+export interface SnapshotRow {
+    timestamp: string;
+    scenario: string;
+    variant: string;
+    metric: string;
+    sample_idx: number;
+    value: number;
+    unit: string;
+    relative_to: string;
+    git_sha: string;
+    git_branch: string;
+}
+export declare function defaultSnapshotPath(dir?: string, now?: Date): string;
+export declare function writeSnapshot(path: string, rows: SnapshotRow[]): Promise<void>;
+export declare function readSnapshot(path: string): Promise<SnapshotRow[]>;
+export declare function findMostRecentSnapshot(dir?: string, excludePath?: string): Promise<string | null>;
+export declare function resolveCompareTarget(target: string | true | undefined, excludePath?: string): Promise<string | null>;

package/dist/snapshot.js

@@ -0,0 +1,162 @@
+import { readFile, readdir, mkdir, writeFile, stat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+export const DEFAULT_SNAPSHOT_DIR = '.devlow-bench/snapshots';
+const COLUMNS = [
+    'timestamp',
+    'scenario',
+    'variant',
+    'metric',
+    'sample_idx',
+    'value',
+    'unit',
+    'relative_to',
+    'git_sha',
+    'git_branch',
+];
+export function defaultSnapshotPath(dir = DEFAULT_SNAPSHOT_DIR, now = new Date()) {
+    // ISO-ish, filesystem-safe, lexicographic-sortable.
+    const stamp = now.toISOString().replace(/[:.]/g, '-').replace(/Z$/, 'Z');
+    return resolve(join(dir, `${stamp}.csv`));
+}
+export async function writeSnapshot(path, rows) {
+    await mkdir(dirname(path), { recursive: true });
+    const lines = [COLUMNS.join(',')];
+    for (const row of rows) {
+        lines.push(COLUMNS.map((c) => csvCell(row[c])).join(','));
+    }
+    await writeFile(path, lines.join('\n') + '\n');
+}
+export async function readSnapshot(path) {
+    const text = await readFile(path, 'utf-8');
+    const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
+    if (lines.length === 0)
+        return [];
+    const header = parseCsvLine(lines[0]);
+    const idx = {};
+    for (let i = 0; i < header.length; i++) {
+        if (COLUMNS.includes(header[i])) {
+            idx[header[i]] = i;
+        }
+    }
+    const rows = [];
+    for (let i = 1; i < lines.length; i++) {
+        const cells = parseCsvLine(lines[i]);
+        const get = (k) => {
+            const j = idx[k];
+            return j == null ? '' : (cells[j] ?? '');
+        };
+        rows.push({
+            timestamp: get('timestamp'),
+            scenario: get('scenario'),
+            variant: get('variant'),
+            metric: get('metric'),
+            sample_idx: Number(get('sample_idx')),
+            value: Number(get('value')),
+            unit: get('unit'),
+            relative_to: get('relative_to'),
+            git_sha: get('git_sha'),
+            git_branch: get('git_branch'),
+        });
+    }
+    return rows;
+}
+// Returns the newest .csv in the directory, excluding the optional exclude
+// path. Returns null if the directory doesn't exist or has no matching files.
+export async function findMostRecentSnapshot(dir = DEFAULT_SNAPSHOT_DIR, excludePath) {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+    const candidates = entries.filter((f) => f.endsWith('.csv'));
+    const excludeResolved = excludePath ? resolve(excludePath) : null;
+    let best = null;
+    for (const f of candidates) {
+        const full = resolve(join(dir, f));
+        if (excludeResolved && full === excludeResolved)
+            continue;
+        const s = await stat(full);
+        if (!best || s.mtimeMs > best.mtime) {
+            best = { path: full, mtime: s.mtimeMs };
+        }
+    }
+    return best?.path ?? null;
+}
+// Resolve --compare: if given a directory, pick the newest .csv inside;
+// if given a file, use it; if null/undefined, fall back to DEFAULT_SNAPSHOT_DIR.
+export async function resolveCompareTarget(target, excludePath) {
+    if (target == null)
+        return null;
+    let candidatePath = null;
+    if (target === true) {
+        candidatePath = await findMostRecentSnapshot(DEFAULT_SNAPSHOT_DIR, excludePath);
+    }
+    else {
+        let isDir = false;
+        try {
+            isDir = (await stat(target)).isDirectory();
+        }
+        catch {
+            // Path doesn't exist; let caller error out.
+        }
+        if (isDir) {
+            candidatePath = await findMostRecentSnapshot(target, excludePath);
+        }
+        else {
+            candidatePath = resolve(target);
+        }
+    }
+    return candidatePath;
+}
+function csvCell(v) {
+    const s = String(v);
+    if (/[,"\n\r]/.test(s)) {
+        return `"${s.replace(/"/g, '""')}"`;
+    }
+    return s;
+}
+function parseCsvLine(line) {
+    const cells = [];
+    let i = 0;
+    while (i < line.length) {
+        if (line[i] === '"') {
+            let s = '';
+            i++; // skip opening quote
+            while (i < line.length) {
+                if (line[i] === '"') {
+                    if (line[i + 1] === '"') {
+                        s += '"';
+                        i += 2;
+                    }
+                    else {
+                        i++; // closing quote
+                        break;
+                    }
+                }
+                else {
+                    s += line[i];
+                    i++;
+                }
+            }
+            cells.push(s);
+            if (line[i] === ',')
+                i++;
+        }
+        else {
+            const next = line.indexOf(',', i);
+            if (next === -1) {
+                cells.push(line.slice(i));
+                i = line.length;
+            }
+            else {
+                cells.push(line.slice(i, next));
+                i = next + 1;
+            }
+        }
+    }
+    return cells;
+}

package/dist/statistics-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/statistics-test.js

@@ -0,0 +1,102 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mean, quantile, welchsTTest, mannWhitneyU } from './statistics.js';
+function near(actual, expected, tol = 1e-6, label = '') {
+    assert.ok(Math.abs(actual - expected) < tol, `${label}: expected ${expected}, got ${actual} (tol ${tol})`);
+}
+test('mean', () => {
+    near(mean([1, 2, 3, 4, 5]), 3);
+    near(mean([10]), 10);
+});
+test('quantile (linear interpolation, numpy/R type 7)', () => {
+    // [1,2,3,4,5] with q=0.5 → 3, q=0.9 → 4.6
+    near(quantile([1, 2, 3, 4, 5], 0.5), 3);
+    near(quantile([1, 2, 3, 4, 5], 0.9), 4.6);
+    // sorts internally
+    near(quantile([5, 3, 1, 2, 4], 0.5), 3);
+    // single sample
+    near(quantile([42], 0.9), 42);
+});
+test("Welch's t-test: small samples", () => {
+    // Hand-verified: means 2 and 3, both sample variances = 1.
+    //   sea = seb = 1/3, denom = 2/3
+    //   t = -1 / sqrt(2/3) = -1.2247448713915892
+    //   df = (2/3)^2 / (2 * (1/3)^2 / 2) = (4/9) / (1/9) = 4
+    //   p ≈ 0.288 (two-sided, df=4)
+    const r = welchsTTest([1, 2, 3], [2, 3, 4]);
+    near(r.t, -1.2247448713915892, 1e-12, 't');
+    near(r.df, 4, 1e-12, 'df');
+    near(r.p, 0.288, 1e-3, 'p');
+});
+test("Welch's t-test: large clearly-different samples", () => {
+    // mean_a=12, mean_b=22, var_a=var_b=2.5 → t=-10 exactly, df=8 exactly.
+    const a = [10, 11, 12, 13, 14];
+    const b = [20, 21, 22, 23, 24];
+    const r = welchsTTest(a, b);
+    near(r.t, -10, 1e-12, 't');
+    near(r.df, 8, 1e-12, 'df');
+    // P(|T|>10 | df=8) is on the order of 8e-6.
+    assert.ok(r.p > 1e-6 && r.p < 1e-5, `expected p in (1e-6, 1e-5), got ${r.p}`);
+});
+test("Welch's t-test: identical samples → t=0, p=1", () => {
+    const r = welchsTTest([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]);
+    near(r.t, 0);
+    near(r.p, 1);
+});
+test('Welch handles unequal variance (small group variance)', () => {
+    // [1..5] vs [10, 10.1, 10.2, 10.3, 10.4]
+    // var_a = 2.5, var_b = 0.025 → very unequal.
+    // sea = 0.5, seb = 0.005, denom = 0.505
+    // t = -7.2 / sqrt(0.505) ≈ -10.1318
+    // df = 0.505^2 / (0.0625 + 6.25e-6) ≈ 4.080
+    const r = welchsTTest([1, 2, 3, 4, 5], [10, 10.1, 10.2, 10.3, 10.4]);
+    near(r.t, -10.131804644116203, 1e-9, 't');
+    near(r.df, 4.08, 1e-2, 'df');
+    // df is small (~4) so heavier tails than the df=8 case: p should be larger.
+    assert.ok(r.p < 1e-3, `expected p<1e-3, got ${r.p}`);
+});
+test('t-distribution CDF: known critical value', () => {
+    // df=10, |t|=2.228 → two-sided p ≈ 0.05 (standard table).
+    // We verify by constructing a sample with exactly that t-stat.
+    // Easier: use the fact that for df=∞ (large df), Welch's reduces to z-test.
+    // df=1000, t≈1.96 should give p≈0.05.
+    // Construct a=[0]*n, b shifted: we can't get exact df without specific values,
+    // so we just confirm the formula gives sane values across df range.
+    // Pair 1: df ≈ 10, t ≈ 2.228 — synthesize with two known groups.
+    // Simpler check: at very large df, p should match the normal-tail p for the same z.
+    const huge = Array.from({ length: 500 }, (_, i) => i);
+    const huger = Array.from({ length: 500 }, (_, i) => i + 0.2); // tiny shift
+    const r = welchsTTest(huge, huger);
+    // With this setup df is enormous (~1000) and t is small but well-defined.
+    // p should be between 0 and 1; finite.
+    assert.ok(Number.isFinite(r.p));
+    assert.ok(r.p >= 0 && r.p <= 1);
+});
+test('Mann–Whitney U: n=5 vs n=5, max separation', () => {
+    // [1..5] vs [6..10]: U=0. Exact two-sided p = 2/252 ≈ 0.00794;
+    // asymptotic with continuity correction ≈ 0.012. Both indicate a strong
+    // separation; we just verify U=0 and p is below 0.05.
+    const r = mannWhitneyU([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]);
+    assert.equal(r.u, 0);
+    assert.ok(r.p < 0.05, `expected p<0.05, got ${r.p}`);
+    assert.ok(r.p > 0.005, `expected p>0.005, got ${r.p}`);
+});
+test('Mann–Whitney U: fully overlapping → no rejection', () => {
+    const r = mannWhitneyU([1, 2, 3], [1, 2, 3]);
+    assert.ok(r.p > 0.5, `expected p>0.5, got ${r.p}`);
+});
+test('Mann–Whitney U: 3 vs 3 distinct, no ties', () => {
+    // U=0 for group A. Exact two-sided p = 0.1; asymptotic ≈ 0.081.
+    const r = mannWhitneyU([1, 2, 3], [4, 5, 6]);
+    assert.equal(r.u, 0);
+    assert.ok(r.p > 0.05 && r.p < 0.15, `expected p in (0.05, 0.15), got ${r.p}`);
+});
+test('Mann–Whitney U: medium samples use normal approximation', () => {
+    // Two clearly separated groups of 12.
+    // scipy two-sided p with continuity correction is in the ~1e-5 range.
+    const a = Array.from({ length: 12 }, (_, i) => i + 1);
+    const b = Array.from({ length: 12 }, (_, i) => i + 100);
+    const r = mannWhitneyU(a, b);
+    assert.equal(r.u, 0);
+    assert.ok(r.p < 1e-4, `expected p<1e-4, got ${r.p}`);
+});

package/dist/statistics.d.ts

@@ -0,0 +1,19 @@
+export interface Summary {
+    mean: number;
+    p50: number;
+    p90: number;
+}
+export declare function mean(xs: number[]): number;
+export declare function quantile(xs: number[], q: number): number;
+export declare function summary(samples: number[]): Summary;
+export interface WelchsTResult {
+    t: number;
+    df: number;
+    p: number;
+}
+export declare function welchsTTest(a: number[], b: number[]): WelchsTResult;
+export interface MannWhitneyResult {
+    u: number;
+    p: number;
+}
+export declare function mannWhitneyU(a: number[], b: number[]): MannWhitneyResult;

package/dist/statistics.js

@@ -0,0 +1,123 @@
+// Statistics helpers for repeated-sampling benchmarks.
+//
+// We use `jstat` for the underlying distribution CDFs (Student's t and
+// standard normal). The rest — Welch's t-statistic, average-rank ranking,
+// and the Mann–Whitney U statistic + asymptotic-tail p-value — is
+// implemented here directly.
+//
+// For Mann–Whitney we use the normal approximation with continuity
+// correction. For very small samples this approximation is less accurate
+// (n=5 vs n=5 has a minimum exact two-sided p ≈ 0.008 vs the
+// approximation's ≈ 0.012). Document this at the call site, not here.
+import jstat from 'jstat';
+export function mean(xs) {
+    if (xs.length === 0)
+        return NaN;
+    let s = 0;
+    for (const x of xs)
+        s += x;
+    return s / xs.length;
+}
+// Linear-interpolation quantile (numpy/R "type 7" default).
+export function quantile(xs, q) {
+    if (xs.length === 0)
+        return NaN;
+    if (xs.length === 1)
+        return xs[0];
+    const sorted = [...xs].sort((a, b) => a - b);
+    const pos = q * (sorted.length - 1);
+    const lo = Math.floor(pos);
+    const hi = Math.ceil(pos);
+    if (lo === hi)
+        return sorted[lo];
+    return sorted[lo] + (pos - lo) * (sorted[hi] - sorted[lo]);
+}
+export function summary(samples) {
+    return {
+        mean: mean(samples),
+        p50: quantile(samples, 0.5),
+        p90: quantile(samples, 0.9),
+    };
+}
+// Two-sample Welch's t-test (unequal variances, two-sided).
+export function welchsTTest(a, b) {
+    if (a.length < 2 || b.length < 2)
+        return { t: NaN, df: NaN, p: NaN };
+    if (allEqual(a) && allEqual(b)) {
+        const ma = a[0];
+        const mb = b[0];
+        return {
+            t: ma === mb ? 0 : ma > mb ? Infinity : -Infinity,
+            df: NaN,
+            p: ma === mb ? 1 : 0,
+        };
+    }
+    const ma = mean(a);
+    const mb = mean(b);
+    const va = sampleVariance(a, ma);
+    const vb = sampleVariance(b, mb);
+    const na = a.length;
+    const nb = b.length;
+    const sea = va / na;
+    const seb = vb / nb;
+    const t = (ma - mb) / Math.sqrt(sea + seb);
+    // Welch–Satterthwaite degrees of freedom.
+    const df = (sea + seb) ** 2 / ((sea * sea) / (na - 1) + (seb * seb) / (nb - 1));
+    const p = 2 * (1 - jstat.studentt.cdf(Math.abs(t), df));
+    return { t, df, p };
+}
+// Two-sided Mann–Whitney U test, asymptotic with continuity correction.
+export function mannWhitneyU(a, b) {
+    const na = a.length;
+    const nb = b.length;
+    if (na === 0 || nb === 0)
+        return { u: NaN, p: NaN };
+    const combined = [...a, ...b];
+    const r = averageRanks(combined);
+    let rankSumA = 0;
+    for (let i = 0; i < na; i++)
+        rankSumA += r[i];
+    const uA = rankSumA - (na * (na + 1)) / 2;
+    const uB = na * nb - uA;
+    const u = Math.min(uA, uB);
+    const meanU = (na * nb) / 2;
+    const sd = Math.sqrt((na * nb * (na + nb + 1)) / 12);
+    if (sd === 0)
+        return { u, p: 1 };
+    const z = Math.max(0, (Math.abs(uA - meanU) - 0.5) / sd);
+    const p = 2 * (1 - jstat.normal.cdf(z, 0, 1));
+    return { u, p: Math.min(1, Math.max(0, p)) };
+}
+// Average-rank ranking (R/scipy default tie correction): tied values share
+// the mean of the ranks they would have received.
+function averageRanks(xs) {
+    const n = xs.length;
+    const idx = xs.map((v, i) => [v, i]);
+    idx.sort((p, q) => p[0] - q[0]);
+    const r = new Array(n);
+    let i = 0;
+    while (i < n) {
+        let j = i;
+        while (j + 1 < n && idx[j + 1][0] === idx[i][0])
+            j++;
+        const avg = (i + j) / 2 + 1;
+        for (let k = i; k <= j; k++)
+            r[idx[k][1]] = avg;
+        i = j + 1;
+    }
+    return r;
+}
+function sampleVariance(xs, m) {
+    let s = 0;
+    for (const x of xs) {
+        const d = x - m;
+        s += d * d;
+    }
+    return s / (xs.length - 1);
+}
+function allEqual(xs) {
+    for (let i = 1; i < xs.length; i++)
+        if (xs[i] !== xs[0])
+            return false;
+    return true;
+}

package/dist/table.js

@@ -1,45 +1,45 @@
-import { readFile } from "fs/promises";
-import minimist from "minimist";
+import { readFile } from 'fs/promises';
+import minimist from 'minimist';
 (async () => {
     const args = minimist(process.argv.slice(2), {
         alias: {
-            r: "row",
-            c: "column",
-            "?": "help",
-            h: "help",
+            r: 'row',
+            c: 'column',
+            '?': 'help',
+            h: 'help',
         },
     });
-    const knownArgs = new Set(["row", "r", "column", "c", "help", "h", "?", "_"]);
+    const knownArgs = new Set(['row', 'r', 'column', 'c', 'help', 'h', '?', '_']);
     if (args.help || (Object.keys(args).length === 1 && args._.length === 0)) {
-        console.log("Usage: devlow-table <data.json>");
-        console.log("  --row=<name>      Key to show as row");
-        console.log("  --column=<name>   Key to show as column");
-        console.log("  --<prop>=<name>   Filter values");
-        console.log("  --help, -h, -?    Show this help");
+        console.log('Usage: devlow-table <data.json>');
+        console.log('  --row=<name>      Key to show as row');
+        console.log('  --column=<name>   Key to show as column');
+        console.log('  --<prop>=<name>   Filter values');
+        console.log('  --help, -h, -?    Show this help');
     }
-    let data = JSON.parse(await readFile(args._[0], "utf-8"));
-    const getValue = (data, name, includeKey) => {
-        if (name === "value") {
-            return data.text;
+    let data = JSON.parse(await readFile(args._[0], 'utf-8'));
+    const getValue = (entry, name, includeKey) => {
+        if (name === 'value') {
+            return entry.text;
         }
         if (Array.isArray(name)) {
             return name
-                .map((n) => getValue(data, n, true))
+                .map((n) => getValue(entry, n, true))
                 .filter((x) => x)
-                .join(" ");
+                .join(' ');
         }
-        const value = data.key[name];
+        const value = entry.key[name];
         if (value === undefined)
-            return "";
+            return '';
         if (value === true)
-            return includeKey ? name : "true";
+            return includeKey ? name : 'true';
         if (value === false)
-            return includeKey ? "" : "false";
+            return includeKey ? '' : 'false';
         if (value === null)
-            return "";
+            return '';
         if (includeKey)
             return `${name}=${value}`;
-        return value + "";
+        return value + '';
     };
     for (const [key, value] of Object.entries(args)) {
         if (knownArgs.has(key))
@@ -47,19 +47,19 @@ import minimist from "minimist";
         const values = (Array.isArray(value) ? value : [value]).map((v) => v.toString());
         data = data.filter((item) => {
             const itemValue = getValue(item, key, false);
-            if (itemValue === "")
+            if (itemValue === '')
                 return false;
             return values.some((v) => itemValue === v);
         });
     }
     if (data.length === 0) {
-        console.log("No data");
+        console.log('No data');
         return;
     }
-    const row = args.row || "name";
-    const column = args.column || "scenario";
-    const getRow = (data) => getValue(data, row, false);
-    const getColumn = (data) => getValue(data, column, false);
+    const rowKey = args.row || 'name';
+    const columnKey = args.column || 'scenario';
+    const getRow = (entry) => getValue(entry, rowKey, false);
+    const getColumn = (entry) => getValue(entry, columnKey, false);
     const allRows = new Set(data.map(getRow));
     const allColumns = new Set(data.map(getColumn));
     const table = [];
@@ -70,46 +70,46 @@ import minimist from "minimist";
         for (const column of allColumns) {
             let items = data
                 .filter((d) => getRow(d) === row && getColumn(d) === column)
-                .map((i) => i.text);
-            rowData.push(items.join(", "));
+                .map((item) => item.text);
+            rowData.push(items.join(', '));
             columnSizes[i] = Math.max(columnSizes[i], rowData[i].length);
             i++;
         }
         table.push(rowData);
     }
     const pad = (str, size) => {
-        return " ".repeat(size - str.length) + str;
+        return ' '.repeat(size - str.length) + str;
     };
     const firstColumnSize = Math.max(...[...allRows].map((r) => r.length));
     // Header
     {
-        let row = "| ";
-        let sepRow = "|:";
-        row += " ".repeat(firstColumnSize);
-        sepRow += "-".repeat(firstColumnSize);
+        let line = '| ';
+        let sepLine = '|:';
+        line += ' '.repeat(firstColumnSize);
+        sepLine += '-'.repeat(firstColumnSize);
         const allColumnsArray = [...allColumns];
         for (let i = 0; i < columnSizes.length; i++) {
-            row += " | ";
-            row += pad(allColumnsArray[i], columnSizes[i]);
-            sepRow += ":|-";
-            sepRow += "-".repeat(columnSizes[i]);
+            line += ' | ';
+            line += pad(allColumnsArray[i], columnSizes[i]);
+            sepLine += ':|-';
+            sepLine += '-'.repeat(columnSizes[i]);
         }
-        row += " |";
-        sepRow += ":|";
-        console.log(row);
-        console.log(sepRow);
+        line += ' |';
+        sepLine += ':|';
+        console.log(line);
+        console.log(sepLine);
     }
     // Separator
     let r = 0;
     for (const rowName of allRows) {
-        let row = "| ";
-        row += pad(rowName, firstColumnSize);
+        let line = '| ';
+        line += pad(rowName, firstColumnSize);
         for (let i = 0; i < columnSizes.length; i++) {
-            row += " | ";
-            row += pad(table[r][i], columnSizes[i]);
+            line += ' | ';
+            line += pad(table[r][i], columnSizes[i]);
         }
-        row += " |";
-        console.log(row);
+        line += ' |';
+        console.log(line);
         r++;
     }
 })().catch((e) => {

package/dist/units.js

@@ -1,14 +1,14 @@
 const UNITS = {
     ms: {
-        " s": 1000,
+        ' s': 1000,
     },
     bytes: {
-        " GB": 1024 * 1024 * 1024,
-        " MB": 1024 * 1024,
-        " KB": 1024,
+        ' GB': 1024 * 1024 * 1024,
+        ' MB': 1024 * 1024,
+        ' KB': 1024,
     },
     requests: {
-        "K requests": 1000,
+        'K requests': 1000,
     },
 };
 export function formatUnit(value, unit) {
@@ -20,5 +20,5 @@ export function formatUnit(value, unit) {
             }
         }
     }
-    return `${value.toFixed(2).replace(/\.00$/, "")} ${unit}`;
+    return `${value.toFixed(2).replace(/\.00$/, '')} ${unit}`;
 }

package/dist/utils.d.ts

@@ -1 +1,2 @@
 export declare function formatVariant(scenario: string, props: Record<string, string | number | boolean | null>): string;
+export declare function formatVariantProps(props: Record<string, string | number | boolean | null>): string;

package/dist/utils.js

@@ -1,9 +1,11 @@
 export function formatVariant(scenario, props) {
-    const keys = Object.keys(props)
+    const propsStr = formatVariantProps(props);
+    return propsStr ? `${scenario} ${propsStr}` : scenario;
+}
+// Just the props part (no scenario prefix). Stable key for snapshots/compare.
+export function formatVariantProps(props) {
+    return Object.keys(props)
         .filter((key) => props[key] !== false && props[key] !== null)
-        .map((key) => (props[key] === true ? key : `${key}=${props[key]}`));
-    if (keys.length === 0) {
-        return scenario;
-    }
-    return `${scenario} ${keys.join(" ")}`;
+        .map((key) => (props[key] === true ? key : `${key}=${props[key]}`))
+        .join(' ');
 }