@nite-framework/nite-zk-profiler 0.1.3 → 0.2.1

package/dist/report.js

@@ -1,74 +1,198 @@
+import { bold, costColor, dim, gray, green, red, visibleLength, yellow } from "./colors.js";
+import { formatBytes, formatMs } from "./deep.js";
+import { estimateProvingMs, formatDuration } from "./estimate.js";
+/** Pad accounting for ANSI escapes, which do not occupy screen columns. */
 function pad(text, width) {
-    return text.padEnd(width);
+    return text + " ".repeat(Math.max(0, width - visibleLength(text)));
 }
 function padLeft(text, width) {
-    return text.padStart(width);
+    return " ".repeat(Math.max(0, width - visibleLength(text))) + text;
 }
-function costLabel(relative) {
-    return `${relative}x`;
+function table(costs, opts, indent) {
+    const { deep, calibration, showEstimate } = opts;
+    const cells = costs.map((c) => {
+        const paint = costColor(c.relativeCost);
+        const d = deep?.get(c.circuit);
+        return {
+            circuit: c.circuit,
+            rows: String(c.rows),
+            k: paint(String(c.k)),
+            capacity: String(c.capacity),
+            cost: paint(`${c.relativeCost}x`),
+            prove: showEstimate ? `~${formatDuration(estimateProvingMs(c.k, calibration).ms)}` : "",
+            setup: d ? formatMs(d.setupMs) : "",
+            key: d ? formatBytes(d.proverKeyBytes) : "",
+        };
+    });
+    const width = (header, get) => Math.max(header.length, ...cells.map((c) => visibleLength(get(c))));
+    const w = {
+        name: width("circuit", (c) => c.circuit),
+        rows: width("rows", (c) => c.rows),
+        k: width("k", (c) => c.k),
+        cap: width("capacity", (c) => c.capacity),
+        cost: width("cost", (c) => c.cost),
+        prove: showEstimate ? width("est. prove", (c) => c.prove) : 0,
+        setup: deep ? width("setup", (c) => c.setup) : 0,
+        key: deep ? width("prover key", (c) => c.key) : 0,
+    };
+    const head = () => {
+        let h = `${indent}${pad("circuit", w.name)}  ${padLeft("rows", w.rows)}  ${padLeft("k", w.k)}  ` +
+            `${padLeft("capacity", w.cap)}  ${padLeft("cost", w.cost)}`;
+        if (showEstimate)
+            h += `  ${padLeft("est. prove", w.prove)}`;
+        if (deep)
+            h += `  ${padLeft("setup", w.setup)}  ${padLeft("prover key", w.key)}`;
+        return dim(h);
+    };
+    const lines = [head()];
+    for (const c of cells) {
+        let line = `${indent}${pad(c.circuit, w.name)}  ${padLeft(c.rows, w.rows)}  ${padLeft(c.k, w.k)}  ` +
+            `${padLeft(c.capacity, w.cap)}  ${padLeft(c.cost, w.cost)}`;
+        if (showEstimate)
+            line += `  ${padLeft(c.prove, w.prove)}`;
+        if (deep)
+            line += `  ${padLeft(c.setup, w.setup)}  ${padLeft(c.key, w.key)}`;
+        lines.push(line);
+    }
+    return lines;
 }
-/** Human readable per circuit cost table. */
-export function formatProfile(costs, toolchain, elapsedMs) {
-    const nameWidth = Math.max(7, ...costs.map((c) => c.circuit.length));
-    const rowsWidth = Math.max(4, ...costs.map((c) => String(c.rows).length));
-    const capWidth = Math.max(8, ...costs.map((c) => String(c.capacity).length));
-    const costWidth = Math.max(4, ...costs.map((c) => costLabel(c.relativeCost).length));
+/** Per circuit cost table, one block per contract. */
+export function formatProfile(contracts, opts) {
     const lines = [""];
-    lines.push(`  ${pad("circuit", nameWidth)}  ${padLeft("rows", rowsWidth)}  ${padLeft("k", 3)}  ` +
-        `${padLeft("capacity", capWidth)}  ${padLeft("cost", costWidth)}`);
-    for (const c of costs) {
-        lines.push(`  ${pad(c.circuit, nameWidth)}  ${padLeft(String(c.rows), rowsWidth)}  ` +
-            `${padLeft(String(c.k), 3)}  ${padLeft(String(c.capacity), capWidth)}  ` +
-            `${padLeft(costLabel(c.relativeCost), costWidth)}`);
+    const many = contracts.length > 1;
+    for (const { source, costs } of contracts) {
+        if (many) {
+            lines.push(bold(`  ${source}`));
+            lines.push(...table(costs, opts, "    "));
+            lines.push("");
+        }
+        else {
+            lines.push(...table(costs, opts, "  "));
+            lines.push("");
+        }
+    }
+    const all = contracts.flatMap((c) => c.costs);
+    const circuits = all.length;
+    const suffix = opts.cached ? " (cached)" : "";
+    const contractNote = many ? `${contracts.length} contracts, ` : "";
+    lines.push(gray(`  ${contractNote}${circuits} circuit${circuits === 1 ? "" : "s"}, ` +
+        `toolchain ${opts.toolchain.version}, ${opts.toolchain.zkirVersion}, ` +
+        `${(opts.elapsedMs / 1000).toFixed(1)}s${suffix}`));
+    if (all.length > 0) {
+        const worst = all.reduce((a, b) => (b.k > a.k ? b : a), all[0]);
+        const cheapest = Math.min(...all.map((c) => c.k));
+        if (worst.k > cheapest) {
+            lines.push(gray(`  ${bold(worst.circuit)} dominates at k=${worst.k}, ` +
+                `${2 ** (worst.k - cheapest)}x the cheapest circuit here.`));
+        }
+    }
+    if (opts.showEstimate) {
+        lines.push(gray(opts.calibration
+            ? `  est. prove is modelled as 2^k, calibrated from an observed ${formatDuration(opts.calibration.observedMs)} proof at k=${opts.calibration.observedK}.`
+            : "  est. prove is modelled as 2^k on an uncalibrated default. Run `nite-zk calibrate` to anchor it."));
     }
-    const plural = costs.length === 1 ? "circuit" : "circuits";
-    lines.push("");
-    lines.push(`  ${costs.length} ${plural}, toolchain ${toolchain.version}, ` +
-        `${toolchain.zkirVersion}, ${(elapsedMs / 1000).toFixed(1)}s`);
     lines.push("");
     return lines.join("\n");
 }
 const STATUS_NOTE = {
-    under: (r) => `under by ${(r.maxK ?? 0) - (r.k ?? 0)}`,
-    at: () => "at budget",
+    under: (r) => green(`under by ${(r.maxK ?? 0) - (r.k ?? 0)}`),
+    at: () => green("at budget"),
     over: (r) => {
         const by = (r.k ?? 0) - (r.maxK ?? 0);
-        return `over by ${by}, about ${2 ** by}x`;
+        return red(`over by ${by}, about ${2 ** by}x`);
     },
-    undeclared: () => "not in budget",
-    stale: () => "no longer in contract",
+    undeclared: () => yellow("not in budget"),
+    stale: () => dim("no longer in contract"),
 };
-/** Human readable budget comparison. */
+/** Budget comparison, grouped by contract when there is more than one. */
 export function formatCheck(result) {
-    const nameWidth = Math.max(7, ...result.rows.map((r) => r.circuit.length));
+    const contracts = [...new Set(result.rows.map((r) => r.contract))];
+    const many = contracts.length > 1;
     const lines = [""];
-    for (const row of result.rows) {
-        const k = row.k === undefined ? "  -" : padLeft(String(row.k), 3);
-        const maxK = row.maxK === undefined ? "  -" : padLeft(String(row.maxK), 3);
-        lines.push(`  ${pad(row.circuit, nameWidth)}  k ${k}   budget ${maxK}   ${STATUS_NOTE[row.status](row)}`);
+    for (const contract of contracts) {
+        const rows = result.rows.filter((r) => r.contract === contract);
+        const indent = many ? "    " : "  ";
+        if (many)
+            lines.push(bold(`  ${contract}`));
+        const wName = Math.max(7, ...rows.map((r) => r.circuit.length));
+        for (const row of rows) {
+            const k = row.k === undefined ? "  -" : padLeft(String(row.k), 3);
+            const maxK = row.maxK === undefined ? "  -" : padLeft(String(row.maxK), 3);
+            const paint = row.status === "over" ? red : (t) => t;
+            lines.push(`${indent}${pad(paint(row.circuit), wName)}  k ${k}   ${dim("budget")} ${maxK}   ` +
+                STATUS_NOTE[row.status](row));
+        }
+        if (many)
+            lines.push("");
     }
     const over = result.rows.filter((r) => r.status === "over").length;
     const undeclared = result.rows.filter((r) => r.status === "undeclared").length;
-    lines.push("");
+    if (!many)
+        lines.push("");
     if (over > 0) {
-        lines.push(`  FAIL: ${over} circuit${over === 1 ? "" : "s"} over budget`);
+        lines.push(red(bold(`  FAIL: ${over} circuit${over === 1 ? "" : "s"} over budget`)));
     }
     else if (result.failed) {
-        lines.push(`  FAIL: ${undeclared} circuit${undeclared === 1 ? "" : "s"} not declared in the budget (--strict)`);
+        lines.push(red(bold(`  FAIL: ${undeclared} circuit${undeclared === 1 ? "" : "s"} not declared (--strict)`)));
     }
     else {
-        lines.push("  OK: every circuit within budget");
+        lines.push(green(bold("  OK: every circuit within budget")));
     }
     lines.push("");
     return lines.join("\n");
 }
-export function profileJson(costs, toolchain) {
+/** Comparison against a git ref. */
+export function formatDiff(result) {
+    const lines = [""];
+    const wName = Math.max(7, ...result.rows.map((r) => r.circuit.length));
+    for (const row of result.rows) {
+        const before = row.before === undefined ? dim("  -") : padLeft(String(row.before), 3);
+        const after = row.after === undefined ? dim("  -") : padLeft(String(row.after), 3);
+        let note;
+        if (row.before === undefined)
+            note = yellow("new circuit");
+        else if (row.after === undefined)
+            note = dim("removed");
+        else if (row.after > row.before)
+            note = red(`+${row.after - row.before}, about ${2 ** (row.after - row.before)}x more expensive`);
+        else if (row.after < row.before)
+            note = green(`${row.after - row.before}, about ${2 ** (row.before - row.after)}x cheaper`);
+        else
+            note = dim("unchanged");
+        lines.push(`  ${pad(row.circuit, wName)}  k ${before} ${dim("->")} ${after}   ${note}`);
+    }
+    const worse = result.rows.filter((r) => r.before !== undefined && r.after !== undefined && r.after > r.before).length;
+    lines.push("");
+    lines.push(worse > 0
+        ? red(bold(`  ${worse} circuit${worse === 1 ? "" : "s"} more expensive than ${result.ref}`))
+        : green(bold(`  nothing more expensive than ${result.ref}`)));
+    lines.push("");
+    return lines.join("\n");
+}
+export function profileJson(contracts, opts) {
     return JSON.stringify({
-        toolchain: toolchain.version,
-        zkir: toolchain.zkirVersion,
-        circuits: costs,
+        toolchain: opts.toolchain.version,
+        zkir: opts.toolchain.zkirVersion,
+        contracts: contracts.map(({ source, costs }) => ({
+            source,
+            circuits: costs.map((c) => {
+                const d = opts.deep?.get(c.circuit);
+                const est = opts.showEstimate
+                    ? {
+                        estimatedProvingMs: Math.round(estimateProvingMs(c.k, opts.calibration).ms),
+                        estimateCalibrated: opts.calibration !== undefined,
+                    }
+                    : {};
+                return d
+                    ? { ...c, ...est, setupMs: Math.round(d.setupMs), proverKeyBytes: d.proverKeyBytes }
+                    : { ...c, ...est };
+            }),
+        })),
     }, null, 2);
 }
 export function checkJson(result) {
     return JSON.stringify(result, null, 2);
 }
+export function diffJson(result) {
+    return JSON.stringify(result, null, 2);
+}

package/dist/version.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read from package.json rather than hardcoded, because `npm version` updates
+ * the manifest and would silently leave a literal behind, so `--version` would
+ * report the wrong release.
+ *
+ * Resolves from this module, which sits one level below the manifest in both
+ * `src/` and the published `dist/`.
+ */
+export declare function toolVersion(): string;

package/dist/version.js

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Read from package.json rather than hardcoded, because `npm version` updates
+ * the manifest and would silently leave a literal behind, so `--version` would
+ * report the wrong release.
+ *
+ * Resolves from this module, which sits one level below the manifest in both
+ * `src/` and the published `dist/`.
+ */
+export function toolVersion() {
+    try {
+        const manifest = join(import.meta.dirname, "..", "package.json");
+        return JSON.parse(readFileSync(manifest, "utf8")).version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nite-framework/nite-zk-profiler",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "See what a Compact circuit costs to prove, without generating proving keys",
   "type": "module",
   "bin": {