@nite-framework/nite-zk-profiler 0.2.3 → 0.2.5

package/dist/budget.js

@@ -115,12 +115,10 @@ export function check(measured, budget, strict) {
     const rows = [];
     let failed = false;
     for (const { source, costs } of measured) {
-        const declared = budget.contracts[source]?.circuits ??
-            // A legacy budget stores its single contract under "", so fall back to it
-            // when only one contract is declared and the path does not match.
-            (Object.keys(budget.contracts).length === 1
-                ? Object.values(budget.contracts)[0].circuits
-                : {});
+        // A legacy budget stores its single contract under the empty key, so fall
+        // back to it only in that case. Matching any single contract budget would
+        // silently check a second contract against the first one's ceilings.
+        const declared = budget.contracts[source]?.circuits ?? budget.contracts[""]?.circuits ?? {};
         for (const cost of costs) {
             const entry = declared[cost.circuit];
             if (!entry) {

package/dist/cache.d.ts

@@ -10,7 +10,14 @@ import type { Toolchain } from "./toolchain.ts";
  * timestamp or a partial import scan could.
  */
 export declare function cacheDir(): string;
-/** Hash every emitted IR file, plus the toolchain that produced and reads it. */
-export declare function cacheKey(zkirDir: string, toolchain: Toolchain): string;
+/**
+ * Hash every emitted IR file, plus the toolchain that produced and reads it.
+ *
+ * Returns undefined when the IR directory cannot be read, which happens for a
+ * contract with no provable circuits. Caching is an optimisation, so it must
+ * never be the thing that reports that: it would preempt the guard in
+ * `measure` and surface a raw ENOENT instead of the explanation.
+ */
+export declare function cacheKey(zkirDir: string, toolchain: Toolchain): string | undefined;
 export declare function readCache(key: string): Measurement[] | undefined;
 export declare function writeCache(key: string, measurements: Measurement[]): void;

package/dist/cache.js

@@ -15,8 +15,22 @@ import { toolVersion } from "./version.js";
 export function cacheDir() {
     return process.env.NITE_ZK_CACHE || join(tmpdir(), "nite-zk-profiler-cache");
 }
-/** Hash every emitted IR file, plus the toolchain that produced and reads it. */
+/**
+ * Hash every emitted IR file, plus the toolchain that produced and reads it.
+ *
+ * Returns undefined when the IR directory cannot be read, which happens for a
+ * contract with no provable circuits. Caching is an optimisation, so it must
+ * never be the thing that reports that: it would preempt the guard in
+ * `measure` and surface a raw ENOENT instead of the explanation.
+ */
 export function cacheKey(zkirDir, toolchain) {
+    let files;
+    try {
+        files = readdirSync(zkirDir).filter((f) => f.endsWith(".zkir")).sort();
+    }
+    catch {
+        return undefined;
+    }
     const hash = createHash("sha256");
     // The profiler's own version is part of the key. Without it, upgrading the
     // tool would keep serving results produced by the previous measurement code,
@@ -24,7 +38,7 @@ export function cacheKey(zkirDir, toolchain) {
     hash.update(toolVersion());
     hash.update(toolchain.version);
     hash.update(toolchain.zkirVersion);
-    for (const file of readdirSync(zkirDir).filter((f) => f.endsWith(".zkir")).sort()) {
+    for (const file of files) {
         hash.update(file);
         hash.update(readFileSync(join(zkirDir, file)));
     }

package/package.json

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