1.13.0: measure + evidence compose; value-graph now a registry dep

- DSLValueGraph integrates the evidence DSL with @arbiter/value-graph: measures
  become typed value-graph nodes; attach() wires runtime.measure through the graph.
- DSLRuntime.check() now retrieves required MEASURE values and injects them as
  value-carrying self-edges, so an evidence comparator over a measure (e.g.
  budget_used(user) <= budget_limit(user)) evaluates — measure and evidence
  compose (provider-sourced AND value-graph-sourced), with 3 new composition tests.
- BUILTIN_TYPES: bigint → buffer (the value-graph wire is JSON-free/bigint-free).
- @arbiter/value-graph: file:../value-graph → ^0.1.0 (registry); CI auth adds
  @push-stream-std registry for the transitive dep.
- rigor core ^3.1.2 / probe ^0.0.8.

.gitea/workflows/ci.yaml

@@ -26,6 +26,8 @@ jobs:
           echo "//hub.kl1.tenere.ai/api/packages/Arbiter/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
           echo "@tenere:registry=https://hub.kl1.tenere.ai/api/packages/Tenere/npm/" >> .npmrc
           echo "//hub.kl1.tenere.ai/api/packages/Tenere/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
+          echo "@push-stream-std:registry=https://hub.kl1.tenere.ai/api/packages/push-stream-std/npm/" >> .npmrc
+          echo "//hub.kl1.tenere.ai/api/packages/push-stream-std/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
           echo "@rigor:registry=https://hub.kl1.tenere.ai/api/packages/Rigor/npm/" >> .npmrc
           echo "//hub.kl1.tenere.ai/api/packages/Rigor/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
 
@@ -52,6 +54,8 @@ jobs:
           echo "//hub.kl1.tenere.ai/api/packages/Arbiter/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
           echo "@tenere:registry=https://hub.kl1.tenere.ai/api/packages/Tenere/npm/" >> .npmrc
           echo "//hub.kl1.tenere.ai/api/packages/Tenere/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
+          echo "@push-stream-std:registry=https://hub.kl1.tenere.ai/api/packages/push-stream-std/npm/" >> .npmrc
+          echo "//hub.kl1.tenere.ai/api/packages/push-stream-std/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
           echo "@rigor:registry=https://hub.kl1.tenere.ai/api/packages/Rigor/npm/" >> .npmrc
           echo "//hub.kl1.tenere.ai/api/packages/Rigor/npm/:_authToken=${{ secrets.PACKAGE_TOKEN }}" >> .npmrc
 

.npmrc

@@ -4,3 +4,5 @@
 //hub.kl1.tenere.ai/api/packages/Tenere/npm/:_authToken=${PACKAGE_TOKEN}
 @rigor:registry=https://hub.kl1.tenere.ai/api/packages/Rigor/npm/
 //hub.kl1.tenere.ai/api/packages/Rigor/npm/:_authToken=${PACKAGE_TOKEN}
+@push-stream-std:registry=https://hub.kl1.tenere.ai/api/packages/push-stream-std/npm/
+//hub.kl1.tenere.ai/api/packages/push-stream-std/npm/:_authToken=${PACKAGE_TOKEN}

bench/measure-hotpath.mjs

@@ -0,0 +1,26 @@
+// DSLValueGraph measure hotpath (async retrieval for authorization checks).
+import { performance } from 'node:perf_hooks';
+import { DSLRuntime, DSLValueGraph } from '../src/index.js';
+import { Arbiter } from '@arbiter/core';
+
+const rt = new DSLRuntime(new Arbiter()).compile('measure budget(user: string) { } PROVIDES number', 'bench');
+const dvg = new DSLValueGraph(rt);
+dvg.attach();
+dvg.setValue('budget', { __subject: 'u:1', user: 'u:1' }, 1250);
+
+async function measureCached() { return dvg.measure('budget', { __subject: 'u:1', user: 'u:1' }); }
+await measureCached(); // warm
+let t0 = performance.now();
+let N = 20_000;
+for (let i = 0; i < N; i++) await measureCached();
+console.log(`dvg.measure cached (async)   ${(((performance.now() - t0) / N) * 1e6).toFixed(0).padStart(8)} ns/op  ${Math.round(N / ((performance.now() - t0) / 1000)).toLocaleString()} ops/sec`);
+
+// cold: a fresh measure with an external resolver computing on the fly
+const cold = new DSLValueGraph(new DSLRuntime(new Arbiter()).compile('measure b(user: string) { } PROVIDES number', 'b'));
+cold.resolve('b', (s) => 99);
+async function measureCold() { return cold.measure('b', { __subject: 'u:1', user: 'u:1' }); }
+await measureCold();
+t0 = performance.now();
+N = 20_000;
+for (let i = 0; i < N; i++) await measureCold();
+console.log(`dvg.measure cold (resolver)  ${(((performance.now() - t0) / N) * 1e6).toFixed(0).padStart(8)} ns/op`);

package-lock.json

@@ -1,25 +1,25 @@
 {
   "name": "@arbiter/evidence-dsl",
-  "version": "1.6.0",
+  "version": "1.13.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@arbiter/evidence-dsl",
-      "version": "1.6.0",
+      "version": "1.13.0",
       "license": "ISC",
       "dependencies": {
-        "@arbiter/core": "^1.0.4"
+        "@arbiter/core": "^1.0.8",
+        "@arbiter/value-graph": "^0.1.0",
+        "@rigor/probe": "^0.0.8"
       },
       "devDependencies": {
-        "@rigor/core": "^3.1.0",
+        "@rigor/core": "^3.1.2",
         "peggy": "^5.0.6"
       }
     },
     "node_modules/@arbiter/core": {
-      "version": "1.0.4",
+      "version": "1.0.8",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Arbiter/npm/%40arbiter%2Fcore/-/1.0.4/core-1.0.4.tgz",
-      "integrity": "sha512-1zXy3mZACjwELptsV8QpYvZJmMU7BhUQ4FsKNfp3/oJDwjfMqAImcAF3mJ+HNZpQnLQXScmELTwow5VduvN27g==",
       "license": "ISC",
       "dependencies": {
         "@tenere/pltc-core": "^0.6.3",
@@ -27,10 +27,19 @@
         "uuidv7": "^1.0.2"
       }
     },
+    "node_modules/@arbiter/value-graph": {
+      "version": "0.1.0",
+      "resolved": "https://hub.kl1.tenere.ai/api/packages/Arbiter/npm/%40arbiter%2Fvalue-graph/-/0.1.0/value-graph-0.1.0.tgz",
+      "integrity": "sha512-sofmF6O/o3bUf2Vzg24MxSB6NLQR8s2xjaBqL+k2LbGhlmt4/lHD9J6l/CjgObn+4UsXjb/QEccZ8rX0BFOUKg==",
+      "license": "ISC",
+      "dependencies": {
+        "@push-stream-std/push-pushable": "*",
+        "@push-stream-std/push-stream-base": "*",
+        "@rigor/probe": "^0.0.8"
+      }
+    },
     "node_modules/@peggyjs/from-mem": {
       "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/@peggyjs/from-mem/-/from-mem-3.1.3.tgz",
-      "integrity": "sha512-LLlgtfXIaeYXoOYovOI0spLM8ZXaqkAlmcRRrLzHJzLMqkU6Sw0R4KMoCoHx1PjaP815pSCBlS+BN6aD8t1Jgg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -40,53 +49,70 @@
         "node": ">=20.8"
       }
     },
+    "node_modules/@push-stream-std/push-pushable": {
+      "version": "0.0.10",
+      "resolved": "https://hub.kl1.tenere.ai/api/packages/push-stream-std/npm/%40push-stream-std%2Fpush-pushable/-/0.0.10/push-pushable-0.0.10.tgz",
+      "integrity": "sha512-xf8nt50zckM8G+WRKV5RTNl4EEe6rhzuplNfqpdZ/b8kx0HnuTawDHlL0R449PKqG9X4DOQ5RzBrX2jYAnfY2A==",
+      "license": "SEE LICENSE IN LICENSE",
+      "dependencies": {
+        "@push-stream-std/push-stream-base": "*"
+      }
+    },
+    "node_modules/@push-stream-std/push-stream-base": {
+      "version": "0.0.9",
+      "resolved": "https://hub.kl1.tenere.ai/api/packages/push-stream-std/npm/%40push-stream-std%2Fpush-stream-base/-/0.0.9/push-stream-base-0.0.9.tgz",
+      "integrity": "sha512-RCbTwQz88XR0j0f/0NWIWgQ3NBQUUICu+CRHzOAvYfG2YQ8j+aTczYWTEedJJhGA+svcFrAQ8Oai/UnjtQ0l3Q==",
+      "license": "SEE LICENSE IN LICENSE"
+    },
     "node_modules/@rigor/analysis": {
       "version": "0.0.7",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fanalysis/-/0.0.7/analysis-0.0.7.tgz",
-      "integrity": "sha512-CH9g9gU5P+aWZfneL7l91Q8wgZ0kwteYTpOdShqi6VFg2aoOSk4HMl8RTzkO4suxWa2VQ/mMnFJ/TAiHwJOobA==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/instrument": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@rigor/artifact": {
       "version": "0.1.3",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fartifact/-/0.1.3/artifact-0.1.3.tgz",
-      "integrity": "sha512-/SP5veJOpZ7y0dEBYOm+iBKQnBqZbTQzCXGd/LvQvmDtMGL7KJv2UbU7blnWp9CIwD8qU8t9U9c9oKO+qupUcA==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@rigor/benchmark": {
       "version": "0.0.6",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fbenchmark/-/0.0.6/benchmark-0.0.6.tgz",
-      "integrity": "sha512-uCCtEhCeY0t81aSgvV1Q7D3cgNU1WufEGJ/vcljhjXnx05hdMWnlK0NPdI/qkWRbRiz+4sSpcGOGO9NBFk7ExQ==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/artifact": "*",
         "@rigor/complexity": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/complexity": {
       "version": "0.0.7",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fcomplexity/-/0.0.7/complexity-0.0.7.tgz",
-      "integrity": "sha512-RfrkXLykb37WFwmB6OfZoXYMEZJLG78r2HqfDB27jWQmGt5l/4Hb9Zh77dEKl2CsUx2fgd5NafdDl9qFtTE6bg==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/core": {
-      "version": "3.1.0",
+      "version": "3.1.2",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fcore/-/3.1.0/core-3.1.0.tgz",
-      "integrity": "sha512-gUuq2YuaM0LNjdmHABcRbEW6FvPhO+U1ErokQ6ftPKpPBb38vDc+pPqu7KgGtr3R9NDU3Vj9OBV1Wq9AlzfraA==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -110,24 +136,25 @@
         "@rigor/spec": "*",
         "@rigor/storage": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@rigor/fault": {
       "version": "0.0.5",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Ffault/-/0.0.5/fault-0.0.5.tgz",
-      "integrity": "sha512-MxzAEk8tx/Nc9CL3dQZZwKXj7eqBgnfTC9dI9TiU9b1u3zW7EIoL28vGqtrr1ucqSTeNwD8BGGAenan2tvb1ZQ==",
-      "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/rng": "*",
         "@rigor/shrink": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/fuzzer": {
       "version": "0.0.4",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Ffuzzer/-/0.0.4/fuzzer-0.0.4.tgz",
-      "integrity": "sha512-cJu9bL0GqpkTsIne9PLMcsLtRfBlDz18DqPiarSi+MetH9R0joh7C+fp/e4guo0y+Q2RBJZwulA8gOh9AwgEaQ==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -135,40 +162,43 @@
         "@rigor/rng": "*",
         "@rigor/shrink": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/gen": {
       "version": "0.0.11",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fgen/-/0.0.11/gen-0.0.11.tgz",
-      "integrity": "sha512-PJG40PtiRJRbNDajdpGaachLYYR+tkSK/0ToIbG5BlG+l/enw7g80hkH674Vw4jeWoftzuwe2NM4dC9rj9rHbg==",
-      "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/rng": "*"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@rigor/instrument": {
       "version": "0.0.5",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Finstrument/-/0.0.5/instrument-0.0.5.tgz",
-      "integrity": "sha512-GXJa6kcEAbd86yM57hR+2g0vcxJlpBfBOoMldWk3mzLmAcCkyYXNSjJekTAwNovfUrtIcnYgQ187Zj3A2d8Tcw==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/probe": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/linearizability": {
       "version": "0.0.5",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Flinearizability/-/0.0.5/linearizability-0.0.5.tgz",
-      "integrity": "sha512-Ruw+/Zc1hiMfs6i/4qYxYuvUsBtCm5SUmpuXrrixSRglvJ9PYfL/H8xb/Pk3Ve1dFBj8TQN6M3AnwCeaJF2/tg==",
       "dev": true,
-      "license": "SEE LICENSE IN LICENSE"
+      "license": "SEE LICENSE IN LICENSE",
+      "engines": {
+        "node": ">=22.0.0"
+      }
     },
     "node_modules/@rigor/model": {
       "version": "0.2.13",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fmodel/-/0.2.13/model-0.2.13.tgz",
-      "integrity": "sha512-eZ/888p1zGJGCBFVMA9suvS2mUNX+iHhZn+Uwl9lWa9CSHVRUWH9dTYYB+Qr1hNrCSGIDjV7rOC34wzT+QA4fw==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -180,12 +210,13 @@
         "@rigor/rng": "*",
         "@rigor/shrink": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/network": {
       "version": "0.0.4",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fnetwork/-/0.0.4/network-0.0.4.tgz",
-      "integrity": "sha512-iNmiQA5QiCNkXnjAMPibGYzDk3Lf5hsgwXQGwRcSSVlZNBfVVw5fURzTsNen3TeAnqh9nozJnhD52yp3zdfP6Q==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -193,24 +224,25 @@
         "@rigor/rng": "*",
         "@rigor/scheduler": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/probe": {
-      "version": "0.0.6",
+      "version": "0.0.8",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fprobe/-/0.0.6/probe-0.0.6.tgz",
-      "integrity": "sha512-vUGY6vwciwYqxMaUYa3L2IIwipnnXdPANG8GONx+PrlII2eSbMCjb7BLZGso4yG/iaheRR0JwAnjV8mvtvUOOA==",
-      "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/fault": "*",
         "@rigor/gen": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@rigor/prop": {
       "version": "0.0.4",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fprop/-/0.0.4/prop-0.0.4.tgz",
-      "integrity": "sha512-z3+STJPeNpz080ZfFbw5h6LpNFjCNnSymoQPUsjyaSovq3euyJrGx9sqtosVgVVE7Rzld6K4QwchJSJOqIi73w==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -221,30 +253,32 @@
         "@rigor/rng": "*",
         "@rigor/shrink": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/reporters": {
       "version": "0.0.5",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Freporters/-/0.0.5/reporters-0.0.5.tgz",
-      "integrity": "sha512-+YYfOMlYDsmGIi9rKiJm7ZAptQ0rTeTU1Sp2uVG9UJteuVKW2eKZIC6TeJuM1qvjQmh7/IzBkl3PZVX9pKnYaw==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/artifact": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/rng": {
       "version": "0.0.3",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Frng/-/0.0.3/rng-0.0.3.tgz",
+      "license": "SEE LICENSE IN LICENSE",
-      "integrity": "sha512-OFERK5HlI6eV1yUadHoz9n88twqsd/lstAxMzBWFJiN1CCM0xG7IHUYMBCnYK6Di3TTcAarFNFL16Bchm3LrKg==",
+      "engines": {
-      "dev": true,
+        "node": ">=18.0.0"
-      "license": "SEE LICENSE IN LICENSE"
+      }
     },
     "node_modules/@rigor/scheduler": {
       "version": "0.0.4",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fscheduler/-/0.0.4/scheduler-0.0.4.tgz",
-      "integrity": "sha512-tY7KASEfufOw4L1vIGeD1bTArCv+zAEPqT/XqiXFz+fckGxY8Nux6zDhGcjkur3qWOUNoWap6KOjSZSORHhXiw==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -252,40 +286,43 @@
         "@rigor/rng": "*",
         "@rigor/shrink": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/search": {
       "version": "0.1.3",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fsearch/-/0.1.3/search-0.1.3.tgz",
-      "integrity": "sha512-NAq5zbUSc6QQO4YIUFq16+hPtrtkNrjAn75lH/4VDPpbCdQPbKvS6zsQ3v954u1u7I6x2jI5uilpX6/xfr69yA==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/gen": "*",
         "@rigor/shrink": "*"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/@rigor/shrink": {
       "version": "0.0.7",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fshrink/-/0.0.7/shrink-0.0.7.tgz",
+      "license": "SEE LICENSE IN LICENSE",
-      "integrity": "sha512-z0yaZqmyysn40BBqAnqTQlymLuaIIU5u2BijjayX0+XZxhhcPIyvs4PISzJ4nmfkx2yE6qKABe2HHub9wVVUQw==",
+      "engines": {
-      "dev": true,
+        "node": ">=18.0.0"
-      "license": "SEE LICENSE IN LICENSE"
+      }
     },
     "node_modules/@rigor/spec": {
       "version": "2.0.1",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fspec/-/2.0.1/spec-2.0.1.tgz",
-      "integrity": "sha512-0/lg19KenJy1e8D87+WqaMRh8Xad4h209/CgK6ofCQapwz/IcriMPHgOZZbHMA4C8G3B6/luVbSVT0EHZoJ8qg==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@rigor/gen": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/storage": {
       "version": "0.0.4",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Fstorage/-/0.0.4/storage-0.0.4.tgz",
-      "integrity": "sha512-7XapdgmvEg/C/kERldqFlw3mT1JkpjPMNK6fEcB2Ggx7+UR3ZeE9GyaodJ29my61b28SrQUWxLBHT5bm0bIVaA==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
@@ -293,34 +330,37 @@
         "@rigor/rng": "*",
         "@rigor/scheduler": "*",
         "@rigor/trace": "*"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@rigor/trace": {
       "version": "0.0.7",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Rigor/npm/%40rigor%2Ftrace/-/0.0.7/trace-0.0.7.tgz",
+      "license": "SEE LICENSE IN LICENSE",
-      "integrity": "sha512-vCLF+WTSdy0pwe9sTonPt8HnNeSkK9U5SAxNpdIeiT+IBP74t9K7JoHMmfo7ka+S0puWecDjjNtWCSqtvKkjNg==",
+      "engines": {
-      "dev": true,
+        "node": ">=18.0.0"
-      "license": "SEE LICENSE IN LICENSE"
+      }
     },
     "node_modules/@tenere/graph-core": {
       "version": "1.0.1",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Tenere/npm/%40tenere%2Fgraph-core/-/1.0.1/graph-core-1.0.1.tgz",
+      "license": "MIT",
-      "integrity": "sha512-29EzF1yBVLuaaapmrL+xNGRaWsM2Ln0G+WHVJURNzwQnDUC2ZSgaeVRMGj3aHFOj2K4mfSh9JqBP5Az2ZHU4pw==",
+      "engines": {
-      "license": "MIT"
+        "node": ">=18.0.0"
+      }
     },
     "node_modules/@tenere/pltc-core": {
       "version": "0.6.3",
-      "resolved": "https://hub.kl1.tenere.ai/api/packages/Tenere/npm/%40tenere%2Fpltc-core/-/0.6.3/pltc-core-0.6.3.tgz",
-      "integrity": "sha512-+XsxNw35fyX8ku19FfyFsb6DgYoaKb6wkAbo1VF+moeyZ0D3AqDTofsBnd2sv5o2y8RpB3XftBxt0Hv1sBcQtg==",
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@tenere/graph-core": "^1.0.1"
+      },
+      "engines": {
+        "node": ">=22.0.0"
       }
     },
     "node_modules/commander": {
       "version": "14.0.3",
-      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz",
-      "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -329,14 +369,10 @@
     },
     "node_modules/heapify": {
       "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/heapify/-/heapify-1.0.2.tgz",
-      "integrity": "sha512-h/b3y12Orh2VsISvDsF/vulkoKH38P7yr223hfWJILo3imy7dX8f9ZrBgkkfLsJG11g8GI1/y6+8POSxgR7YcQ==",
       "license": "MIT"
     },
     "node_modules/peggy": {
       "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/peggy/-/peggy-5.1.0.tgz",
-      "integrity": "sha512-IEo5aYRZ2kXH4Qby06cjtL114PZnwLoTiA41vUmg2vPZgANn+c87m5BUurhuDr5/cu758ZlpgsAfBVx+hhO5+w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -353,8 +389,6 @@
     },
     "node_modules/semver": {
       "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -366,8 +400,6 @@
     },
     "node_modules/source-map-generator": {
       "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/source-map-generator/-/source-map-generator-2.0.6.tgz",
-      "integrity": "sha512-IlassDs1Ve8nV6uyQZXF9kdkJpVKnMte2JZQXu13M0A5zwc+vu6+LNHfmxsHBMDtoZE21RHiKI0/xvpecZRCNg==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -376,8 +408,6 @@
     },
     "node_modules/uuidv7": {
       "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/uuidv7/-/uuidv7-1.2.1.tgz",
-      "integrity": "sha512-4kPkK3/XTQW9Hbm4CaqfICn+kY9LJtDVEOfgsRRra/+n2Ofg4NqzRFceAkxvQ/Ud/6BpHOPzj8cirqM7TzTN5Q==",
       "license": "Apache-2.0",
       "bin": {
         "uuidv7": "cli.js"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbiter/evidence-dsl",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "Evidence DSL v2 compiler: translates the natural Evidence DSL (ADR-000) into @arbiter/core relation configurations.",
   "license": "ISC",
   "type": "module",
@@ -21,13 +21,16 @@
   ],
   "scripts": {
     "test": "node --test --test-force-exit \"tests/**/*.test.js\"",
-    "generate:parser": "node scripts/generate-parser.js"
+    "generate:parser": "node scripts/generate-parser.js",
+    "bench": "node bench/measure-hotpath.mjs"
   },
   "dependencies": {
-    "@arbiter/core": "^1.0.4"
+    "@arbiter/core": "^1.0.8",
+    "@arbiter/value-graph": "^0.1.0",
+    "@rigor/probe": "^0.0.8"
   },
   "devDependencies": {
-    "@rigor/core": "^3.1.0",
+    "@rigor/core": "^3.1.2",
     "peggy": "^5.0.6"
   }
 }

src/DSLCompiler.js

@@ -39,13 +39,15 @@ export class DSLCompiler {
       const programNode = {
         definitions: program.body.filter(s => s.type === 'Definition'),
         facts: program.body.filter(s => s.type === 'Fact'),
+        sources: program.body.filter(s => s.type === 'Source'),
         evidence: program.body.filter(s => s.type === 'Evidence'),
         measures: program.body.filter(s => s.type === 'Measure'),
         validate: () => ({ isValid: true, errors: [], warnings: [] })
       };
 
-      // Generate rules from AST
+      // Generate rules from AST (scoped to the program name so recompiling a
-      const generationResult = this.generator.generateRules(programNode);
+      // scope revokes its stale relations without touching other scopes).
+      const generationResult = this.generator.generateRules(programNode, programName);
       
       if (!generationResult.success) {
         return {

src/generator/RuleGenerator.js

@@ -11,6 +11,14 @@ export class RuleGenerator {
     this.errors = [];
     this.dependencyIndex = new Map();
     this.evidenceNames = new Set();
+    // Relation names this generator has installed on the arbiter, tracked PER
+    // PROGRAM SCOPE (the compile() program name). Recompiling the same scope
+    // uninstalls relations that scope previously declared but no longer does —
+    // otherwise a revoked evidence/fact keeps its config and still grants
+    // (stale-permission leak). Relations from OTHER scopes (compileMultiple
+    // coexistence) are never touched.
+    this._installedByScope = new Map();
+    this._currentScope = 'default';
     // Default depth for bounded self-recursion when the DSL `limit N` is absent.
     this.maxRecursionDepth = options.maxRecursionDepth ?? 3;
   }
@@ -20,10 +28,25 @@ export class RuleGenerator {
    * @param {ProgramNode} program - AST program to generate rules from
    * @returns {Object} Generation result with success status and errors
    */
-  generateRules(program) {
+  generateRules(program, scopeName = 'default') {
     this.errors = [];
+    this._currentScope = scopeName;
+    this.program = program;
     this.generatedRules.clear();
     this.dependencyIndex.clear();
+    // Facts declared `BEHAVES AS transitive` are resolved as bounded transitive
+    // closure (multi_hop) everywhere they are referenced — both the fact's own
+    // config and any direct rule that references the fact. Without this the
+    // declaration parses but grants only direct edges (silent no-op). Value is
+    // the closure depth (the fact's `limit N`, or the recursion default).
+    this.transitiveFacts = new Map();
+    for (const fact of program.facts || []) {
+      const behavior = fact && fact.behavior;
+      if (behavior && (behavior.behavior === 'transitive' || behavior === 'transitive')) {
+        const depth = (fact.limit && typeof fact.limit === 'object' ? fact.limit.value : fact.limit) ?? this.maxRecursionDepth;
+        this.transitiveFacts.set(fact.name, depth);
+      }
+    }
 
     try {
       // Generate rules for each evidence definition
@@ -41,6 +64,14 @@ export class RuleGenerator {
         this.generateFactConfig(fact);
       });
 
+      // Generate source relation configs (injectable, recency-gated proofs).
+      // Without a config a source referenced by an evidence would never
+      // resolve — the reference would lower to a config-less direct rule that
+      // grants nothing.
+      (program.sources || []).forEach(source => {
+        this.generateSourceConfig(source);
+      });
+
       // Resolve evidence composition: a rule that references another derived
       // evidence (WHEN can_read(user, doc) where can_read is an evidence) is
       // lowered in place to that evidence's own config — compile-time inlining
@@ -109,9 +140,13 @@ export class RuleGenerator {
     const paramNames = params.map(p => p.name);
     const paramTypes = params.map(p => p.type);
 
-    this.generatedRules.set(name, {
+    // BEHAVES AS transitive: the fact resolves to bounded transitive closure.
-      type: 'direct',
+    // A multi_hop config walks the relation's edges up to maxDepth (the fact's
-      relation: name,
+    // `limit N`, or the recursion default), so a direct check on the fact —
+    // and any evidence that references it — follows multi-hop paths instead of
+    // only direct edges.
+    const transitiveDepth = this.transitiveFacts.get(name);
+    const base = {
       isFactRelation: true,
       requiresInjection: true,
       arity: paramTypes.length,
@@ -123,6 +158,39 @@ export class RuleGenerator {
           typeof p === 'string' ? [p, true] : Array.isArray(p) ? p : [p, true]
         )
       )
+    };
+
+    this.generatedRules.set(name, transitiveDepth !== undefined
+      ? {
+          type: 'multi_hop',
+          relation: name,
+          maxDepth: transitiveDepth,
+          pathAggregation: 'max',
+          reverse: false,
+          fallbackToBasicPaths: true,
+          collectValues: false,
+          ...base
+        }
+      : {
+          type: 'direct',
+          relation: name,
+          ...base
+        });
+  }
+
+  generateSourceConfig(source) {
+    const name = source.name;
+    const params = source.params || [];
+    const withinMs = source.within ? this._durationToMs(source.within) : null;
+    this.generatedRules.set(name, {
+      type: 'direct',
+      relation: name,
+      isSourceRelation: true,
+      requiresInjection: true,
+      arity: params.length,
+      paramTypes: params.map(p => p.paramType),
+      paramNames: params.map(p => p.name),
+      ...(withinMs !== null ? { withinMs } : {})
     });
   }
 
@@ -298,7 +366,7 @@ export class RuleGenerator {
       case 'PredicateCall':
         return this.buildPredicateRule(statement, evidence);
       case 'UnaryExpression':
-        return this.buildUnaryRule(statement);
+        return this.buildUnaryRule(statement, evidence);
       case 'BinaryExpression':
         // Top-level comparator — emit a relational_comparator rule. RF-24 closure.
         return this.buildRuleFromExpressionNode(statement, evidence);
@@ -317,15 +385,19 @@ export class RuleGenerator {
   /**
    * Build rule for unary expression (NOT)
    * @param {Object} expression - Unary expression
+   * @param {Object} evidence - Evidence definition (threaded through so a
+   *   unary inner predicate like NOT banned(user) keeps its _subjectAsObject
+   *   rewrite; without it the unary fact would be checked on the evidence's
+   *   OBJECT node instead of the subject, silently negating the wrong fact).
    * @returns {Object|null} Rule configuration or null
    */
-  buildUnaryRule(expression) {
+  buildUnaryRule(expression, evidence) {
     if (expression.operator !== 'NOT') {
       this.errors.push(`Unsupported unary operator: ${expression.operator}`);
       return null;
     }
 
-    const innerRule = this.buildRuleFromExpression(expression.operand);
+    const innerRule = this.buildRuleFromExpression(expression.operand, evidence);
     if (!innerRule) {
       return null;
     }
@@ -482,6 +554,12 @@ export class RuleGenerator {
     const predicate = directEvidence.predicate;
     const relation = predicate.name;
 
+    // A reference to a `BEHAVES AS transitive` fact resolves to closure.
+    const transitiveDepth = this.transitiveFacts.get(relation);
+    if (transitiveDepth !== undefined) {
+      return this._buildTransitiveRule(relation, transitiveDepth, predicate.arguments || [], evidence);
+    }
+
     const rule = {
       type: 'direct',
       relation: relation,
@@ -505,6 +583,12 @@ export class RuleGenerator {
       }
     }
 
+    // A literal value in the object position (balance(user, 5)) is a VALUE
+    // constraint, not a node key: the rule only grants when the matched edge
+    // carries exactly that value. Without this gate a value-carrying fact
+    // would match ANY edge regardless of its amount (silent over-grant).
+    this._applyExpectedValue(rule, args);
+
     return rule;
   }
 
@@ -947,7 +1031,7 @@ export class RuleGenerator {
     } else if (expression.type === 'PredicateCall') {
       return this.buildPredicateRule(expression, evidence);
     } else if (expression.type === 'UnaryExpression') {
-      return this.buildUnaryRule(expression);
+      return this.buildUnaryRule(expression, evidence);
     } else if (expression.type === 'BinaryExpression') {
       return this.buildRuleFromExpressionNode(expression, evidence);
     }
@@ -962,6 +1046,12 @@ export class RuleGenerator {
    * @returns {Object|null} Rule configuration or null
    */
   buildDirectRuleFromPredicate(predicate, evidence) {
+    // A reference to a `BEHAVES AS transitive` fact resolves to closure.
+    const transitiveDepth = this.transitiveFacts.get(predicate.name);
+    if (transitiveDepth !== undefined) {
+      return this._buildTransitiveRule(predicate.name, transitiveDepth, predicate.args || [], evidence);
+    }
+
     const rule = {
       type: 'direct',
       relation: predicate.name,
@@ -975,6 +1065,58 @@ export class RuleGenerator {
       rule._subjectAsObject = true;
     }
 
+    // Value constraint: a literal in the object position (balance(user, 5)).
+    this._applyExpectedValue(rule, predicate.args || []);
+
+    return rule;
+  }
+
+  /**
+   * Annotate a direct rule with `expectedValue` when its object-position
+   * argument is a literal. The engine only grants the rule if the matched
+   * edge's `value` field equals this literal — without the gate a
+   * value-carrying fact would match any edge of the same relation, silently
+   * over-granting (e.g. balance(user, 5) matching a value-3 edge).
+   */
+  _applyExpectedValue(rule, args) {
+    if (rule && args && args.length >= 2) {
+      const objectArg = args[1];
+      if (objectArg && objectArg.type === 'Literal' && objectArg.value !== undefined) {
+        rule.expectedValue = objectArg.value;
+      }
+    }
+    return rule;
+  }
+
+  /**
+   * Build a bounded transitive-closure rule for a `BEHAVES AS transitive`
+   * fact reference. Applies the same subject/object rewrite flags as the
+   * direct-rule builders so a unary or object-var reference still targets the
+   * correct nodes.
+   */
+  _buildTransitiveRule(relation, maxDepth, args, evidence) {
+    const rule = {
+      type: 'multi_hop',
+      relation: relation,
+      maxDepth: maxDepth,
+      pathAggregation: 'max',
+      reverse: false,
+      fallbackToBasicPaths: true,
+      collectValues: false
+    };
+
+    const evidenceParams = (evidence && evidence.params) || [];
+    const objectVar = evidenceParams[1] && evidenceParams[1].name;
+    const argName = a => a && (a.name !== undefined ? a.name : a.value);
+    if (objectVar !== undefined) {
+      const hasObjectArg = args.some(a => a && a.type === 'Variable' && a.name === objectVar);
+      if (args.length === 1 && argName(args[0]) === objectVar) {
+        rule._subjectIsObject = true;
+      } else if (!hasObjectArg) {
+        rule._subjectAsObject = true;
+      }
+    }
+
     return rule;
   }
 
@@ -1391,6 +1533,13 @@ export class RuleGenerator {
       return this.buildChallengeRule(expression, null);
     }
 
+    // A reference to a `BEHAVES AS transitive` fact resolves to bounded
+    // transitive closure, not a direct edge lookup.
+    const transitiveDepth = this.transitiveFacts.get(predicateName);
+    if (transitiveDepth !== undefined) {
+      return this._buildTransitiveRule(predicateName, transitiveDepth, expression.args || [], evidence);
+    }
+
     const rule = {
       type: 'direct',
       relation: predicateName,
@@ -1418,6 +1567,11 @@ export class RuleGenerator {
       }
     }
 
+    // Value constraint: a literal in the object position (balance(user, 5))
+    // is a VALUE gate, not a node key — the rule only grants when the matched
+    // edge carries exactly that value.
+    this._applyExpectedValue(rule, expression.args || []);
+
     return rule;
   }
 
@@ -1531,6 +1685,19 @@ export class RuleGenerator {
       return;
     }
     
+    // Recompile hygiene (per program scope): relations installed by a previous
+    // compile of THIS scope but absent from the current program are stale —
+    // remove their configs from every cache and index so a revoked relation
+    // stops granting immediately. Relations belonging to other scopes
+    // (compileMultiple coexistence) are left intact.
+    const scope = this._currentScope || 'default';
+    const previously = this._installedByScope.get(scope) || new Set();
+    for (const name of previously) {
+      if (!this.generatedRules.has(name)) {
+        this._uninstallRelation(name);
+      }
+    }
+
     this.generatedRules.forEach((config, relation) => {
       try {
         this.arbiter.setRelationConfig(relation, config);
@@ -1542,6 +1709,33 @@ export class RuleGenerator {
     if (typeof this.arbiter.registerDependencyIndex === 'function') {
       this.arbiter.registerDependencyIndex(this.dependencyIndex);
     }
+
+    this._installedByScope.set(scope, new Set(this.generatedRules.keys()));
+  }
+
+  /**
+   * Remove a relation's config and cached state from the arbiter. Mirrors the
+   * invalidation that setRelationConfig performs, applied to deletion.
+   */
+  _uninstallRelation(name) {
+    const arb = this.arbiter;
+    if (!arb) return;
+    if (arb.relationConfigs && typeof arb.relationConfigs.delete === 'function') {
+      arb.relationConfigs.delete(name);
+    }
+    const analysis = arb.graphManager && arb.graphManager.analysis;
+    if (analysis && analysis.relationConfigs && typeof analysis.relationConfigs.delete === 'function') {
+      analysis.relationConfigs.delete(name);
+    }
+    if (typeof arb._invalidateDirectCheckCache === 'function') {
+      arb._invalidateDirectCheckCache(null, name, null);
+    }
+    if (typeof arb.invalidateRuleResultCacheByRelation === 'function') {
+      arb.invalidateRuleResultCacheByRelation(name);
+    }
+    if (arb.authChecker && typeof arb.authChecker.invalidateRuleCaches === 'function') {
+      arb.authChecker.invalidateRuleCaches(name);
+    }
   }
 
   /**

src/index.js

@@ -18,6 +18,9 @@ export { validateDslText } from './validation/DSLValidation.js';
 // Runtime
 export { DSLRuntime } from './runtime/DSLRuntime.js';
 
+// Value-graph integration — DSL-declared measures as value-graph nodes
+export { DSLValueGraph } from './value-graph/DSLValueGraph.js';
+
 // All AST nodes
 export * from './nodes/index.js';
 

src/runtime/DSLRuntime.js

@@ -44,6 +44,7 @@ export class DSLRuntime {
     this.arbiter = arbiter;
     this.compiler = new DSLCompiler(this.arbiter);
     this.factProviders = options.factProviders || {};
+    this.measureProviders = new Map(); // measure name -> async (args, ctx) => { value, unit? }
     this.strictTypes = options.policy?.strictTypes !== false;
     this.program = null;
     this.types = new Map();      // typeName -> { fields: Map(field -> {type,isArray}) }
@@ -110,6 +111,9 @@ export class DSLRuntime {
     const facts = [...this.relations.entries()]
       .filter(([, r]) => r.kind === 'fact')
       .map(([name, r]) => ({ name, params: r.params, injectable: r.injectable }));
+    const sources = [...this.relations.entries()]
+      .filter(([, r]) => r.kind === 'source')
+      .map(([name, r]) => ({ name, params: r.params, injectable: true, withinMs: r.withinMs }));
     const evidence = [...this.relations.entries()]
       .filter(([, r]) => r.kind === 'evidence')
       .map(([name, r]) => ({
@@ -117,7 +121,10 @@ export class DSLRuntime {
         params: r.params,
         dependsOn: [...(this.dependsOn.get(name) || [])]
       }));
-    return { types, facts, evidence, providers: this.registeredFacts() };
+    const measures = [...this.relations.entries()]
+      .filter(([, r]) => r.kind === 'measure')
+      .map(([name, r]) => ({ name, params: r.params, returnType: r.returnType }));
+    return { types, facts, sources, evidence, measures, providers: this.registeredFacts() };
   }
 
   /** All relation names declared by the program (facts + evidence). */
@@ -148,6 +155,18 @@ export class DSLRuntime {
       });
     }
 
+    // Sources are injectable, recency-gated proofs: registered as retrievable
+    // relations so a provider can supply them and `within X` gates freshness.
+    for (const src of this.program.sources || []) {
+      this.relations.set(src.name, {
+        kind: 'source',
+        params: (src.params || []).map(p => ({ name: p.name, type: p.paramType, isArray: !!p.isArray })),
+        injectable: true,
+        ttlMs: 0,
+        withinMs: src.within ? this._durationToMs(src.within) : null
+      });
+    }
+
     for (const ev of this.program.evidence || []) {
       this.relations.set(ev.name, {
         kind: 'evidence',
@@ -156,6 +175,19 @@ export class DSLRuntime {
       });
     }
 
+    // Measures are derived-value lookups (kind: 'measure'). Their VALUES come
+    // from a registered provider (the ARRA adapter / value-graph), not the
+    // graph. `provides` declares the return type.
+    for (const m of this.program.measures || []) {
+      const provides = m.provides?.type || m.provides || 'number';
+      this.relations.set(m.name, {
+        kind: 'measure',
+        params: (m.params || []).map(p => ({ name: p.name, type: p.paramType, isArray: !!p.isArray })),
+        returnType: provides,
+        injectable: false
+      });
+    }
+
     // Index each evidence's fact dependencies from the compiled arbiter configs.
     for (const ev of this.program.evidence || []) {
       const config = this.arbiter.relationConfigs.get(ev.name);
@@ -235,6 +267,66 @@ export class DSLRuntime {
     return Object.keys(this.factProviders);
   }
 
+  /**
+   * Register a measure provider. A measure is a derived-value lookup declared
+   * in the DSL (`measure name(...) { ... } provides <type>`); its VALUE comes
+   * from a registered provider (e.g. the ARRA adapter bridging the value-graph),
+   * not from the graph.
+   *
+   * @param {string} name - declared measure name
+   * @param {Function} provider - async (args, ctx) => { value, unit? } | number
+   */
+  registerMeasure(name, provider) {
+    const meta = this.relations.get(name);
+    if (!meta || meta.kind !== 'measure') {
+      throw new Error(`DSLRuntime: '${name}' is not a declared measure`);
+    }
+    if (typeof provider !== 'function') {
+      throw new Error(`DSLRuntime: provider for measure '${name}' must be a function`);
+    }
+    this.measureProviders.set(name, provider);
+    return this;
+  }
+
+  /** Unregister a measure provider. */
+  unregisterMeasure(name) {
+    this.measureProviders.delete(name);
+    return this;
+  }
+
+  /**
+   * Resolve a measure value by its parameter bindings.
+   * @param {string} name - declared measure name
+   * @param {Object} args - positional or named args (positional for unary/arity-1)
+   * @returns {Promise<{value: *, unit?: string|null, source?: string}>}
+   */
+  async measure(name, args = {}) {
+    const meta = this.relations.get(name);
+    if (!meta || meta.kind !== 'measure') {
+      if (this.strictTypes) throw new Error(`DSLRuntime: unknown measure '${name}'`);
+      return null;
+    }
+    const provider = this.measureProviders.get(name);
+    if (!provider) {
+      throw new Error(`DSLRuntime: no provider registered for measure '${name}'`);
+    }
+    const params = meta.params || [];
+    // Normalize positional args (e.g. measure(userKey)) to named bindings.
+    let bindings = args;
+    if (Array.isArray(args)) {
+      bindings = {};
+      for (let i = 0; i < params.length; i++) bindings[params[i].name] = args[i];
+    }
+    const result = await provider(bindings, { runtime: this });
+    if (typeof result === 'number' || typeof result === 'string' || typeof result === 'boolean') {
+      return { value: result, unit: null };
+    }
+    if (result && typeof result === 'object' && 'value' in result) {
+      return { value: result.value, unit: result.unit ?? null, source: result.source };
+    }
+    throw new Error(`DSLRuntime: provider for measure '${name}' must return a value or { value, unit }`);
+  }
+
   // ---------------------------------------------------------------------------
   // Provider-result caching
   // ---------------------------------------------------------------------------
@@ -309,6 +401,17 @@ export class DSLRuntime {
     return null;
   }
 
+  /** Convert a Duration AST ({ value, unit }) to milliseconds. */
+  _durationToMs(duration) {
+    if (!duration || duration.value === undefined) return null;
+    const raw = typeof duration.value === 'string' ? duration.value : String(duration.value);
+    const unit = duration.unit || raw.slice(-1);
+    const numeric = parseFloat(raw);
+    if (!Number.isFinite(numeric)) return null;
+    const mult = { s: 1000, m: 60_000, h: 3600_000, d: 86_400_000, w: 604_800_000 }[unit];
+    return mult ? numeric * mult : null;
+  }
+
   /**
    * Normalize a provider result (boolean / number / { possibility, value } /
    * array of edge objects) into an array of partial-graph edge objects. The
@@ -323,6 +426,8 @@ export class DSLRuntime {
     const edges = Array.isArray(result) ? result : [result];
     const secondParamType = factMeta.params[1] && factMeta.params[1].type;
     const isValueFact = factMeta.params.length >= 2 && this._isValueType(secondParamType);
+    // Sources carry a timestamp in `value` for their recency (`within X`) gate.
+    const isSource = factMeta.kind === 'source';
     const defaultDst = isValueFact ? user : (factMeta.params.length >= 2 ? object : user);
     const label = `provider for '${fact}'`;
     const out = [];
@@ -340,10 +445,14 @@ export class DSLRuntime {
             const possibility = edge.possibility ?? 1;
             this._checkPossibility(possibility, label);
             if (edge.value !== undefined) {
-              if (!isValueFact) {
+              if (!isValueFact && !isSource) {
                 throw new Error(`DSLRuntime: ${label} returned a value for a non-value fact '${fact}'`);
               }
+              if (isValueFact) {
                 this._checkScalarValue(secondParamType, edge.value, `${label}.value`);
+              } else if (isSource && (typeof edge.value !== 'number' || Number.isNaN(edge.value))) {
+                throw new Error(`DSLRuntime: ${label} (a source) must return a numeric timestamp in value`);
+              }
             } else if (isValueFact) {
               throw new Error(`DSLRuntime: ${label} must supply a 'value' of type ${secondParamType}`);
             }
@@ -549,7 +658,7 @@ export class DSLRuntime {
 
   /**
    * The partial-graph requirements of an evidence relation: the declared
-   * injectable facts it depends on.
+   * injectable facts and sources it depends on.
    */
   requiredFacts(relation) {
     const deps = this.dependsOn.get(relation);
@@ -558,6 +667,24 @@ export class DSLRuntime {
     for (const dep of deps) {
       const meta = this.relations.get(dep);
       if (meta && meta.kind === 'fact' && meta.injectable) required.push(dep);
+      if (meta && meta.kind === 'source') required.push(dep);
+    }
+    return required;
+  }
+
+  /**
+   * The MEASURE requirements of an evidence relation: the derived measures its
+   * comparator operands reference (valueRelation deps that are `kind: measure`).
+   * These compose the measure system into the evidence system — the evidence's
+   * truth depends on a measure VALUE, which `check()` resolves and injects.
+   */
+  requiredMeasures(relation) {
+    const deps = this.dependsOn.get(relation);
+    if (!deps) return [];
+    const required = [];
+    for (const dep of deps) {
+      const meta = this.relations.get(dep);
+      if (meta && meta.kind === 'measure') required.push(dep);
     }
     return required;
   }
@@ -596,6 +723,11 @@ export class DSLRuntime {
     } else if (meta.params.length === 2) {
       this._checkNodeType(user, meta.params[0].type, 'subject');
       this._checkNodeType(object, meta.params[1].type, 'object');
+      // A value-typed object parameter (can_withdraw(user, amount: number))
+      // carries the expected EDGE VALUE, not a node key — validate the scalar.
+      if (this._isValueType(meta.params[1].type)) {
+        this._checkScalarValue(meta.params[1].type, object, `object of '${relation}'`);
+      }
     } else if (meta.params.length === 1) {
       this._checkNodeType(user, meta.params[0].type, 'subject');
     }
@@ -605,14 +737,16 @@ export class DSLRuntime {
     // provider, if registered, supplies the edge — checking `owns` directly
     // must consult the `owns` provider, not only evidence-mediated checks).
     const required = new Set(this.requiredFacts(relation));
-    if (meta && meta.kind === 'fact') required.add(relation);
+    if (meta && (meta.kind === 'fact' || meta.kind === 'source')) required.add(relation);
     const requiredList = [...required];
     const providers = { ...this.factProviders, ...(options.factProviders || {}) };
     const maxRounds = options.maxProviderRounds ?? 3;
     const partialRelations = [];
     const injectedRelations = []; // { relation, edges, round }
     const missingFacts = [];
+    const warnings = [];
     const satisfied = new Set();  // facts whose edges are in the partial graph
+    const now = this.clock ? this.clock() : Date.now();
 
     if (options.partialGraph && Array.isArray(options.partialGraph.relations)) {
       for (const rel of options.partialGraph.relations) {
@@ -678,11 +812,33 @@ export class DSLRuntime {
         }
 
         // A provider may return edges for relations other than its own; the
-        // injected relation names satisfy those facts too (fixed point).
+        // injected relation names satisfy those facts too (fixed point). Apply
+        // the source recency gate (within X) and drop ghost-node edges.
+        const accepted = [];
         for (const normalized of edges) {
           const injectedRelation = normalized.relation ?? fact;
-          partialRelations.push({ relation: injectedRelation, ...normalized });
+          if (factMeta.kind === 'source' && factMeta.withinMs !== null && factMeta.withinMs !== undefined) {
-          satisfied.add(injectedRelation);
+            if (normalized.value === undefined) {
+              throw new Error(`DSLRuntime: provider for recency-gated source '${fact}' must return a timestamp in value (within ${factMeta.withinMs}ms)`);
+            }
+            if (now - normalized.value > factMeta.withinMs) {
+              missingFacts.push({ relation: fact, reason: 'stale' });
+              continue;
+            }
+          }
+          if (normalized.src !== undefined && !this.arbiter.nodeIdByKey.has(normalized.src)) {
+            warnings.push(`provider for '${fact}' returned an edge with unknown source node '${normalized.src}' — dropped`);
+            continue;
+          }
+          if (normalized.dst !== undefined && !this.arbiter.nodeIdByKey.has(normalized.dst)) {
+            warnings.push(`provider for '${fact}' returned an edge with unknown target node '${normalized.dst}' — dropped`);
+            continue;
+          }
+          accepted.push({ relation: injectedRelation, ...normalized });
+        }
+        for (const normalized of accepted) {
+          partialRelations.push(normalized);
+          satisfied.add(normalized.relation);
         }
         injectedRelations.push({ relation: fact, edges: edges.length, round, cacheHit: fromCache });
         newRelationsThisRound += edges.length;
@@ -699,13 +855,75 @@ export class DSLRuntime {
       };
     }
 
-    const result = this.arbiter.check(user, relation, object, checkOptions);
+    // --- Measure + evidence composition ---
+    // An evidence whose comparator references a measure (a valueRelation with
+    // `_needsValues`) needs the measure VALUE in the partial graph before the
+    // core evaluator runs. Measures inject as value-carrying self-edges on the
+    // subject, resolved through `this.measure()` — which is the attached
+    // value-graph when DSLValueGraph is wired, so both systems compose.
+    const measureRequirements = this.requiredMeasures(relation);
+    if (measureRequirements.length > 0) {
+      const bound = {};
+      for (let i = 0; i < (meta?.params || []).length; i++) {
+        if (i === 0) bound[meta.params[i].name] = user;
+        else if (i === 1 && !this._isValueType(meta.params[i].type)) bound[meta.params[i].name] = object;
+      }
+      for (const measure of measureRequirements) {
+        if (satisfied.has(measure)) continue;
+        const measureMeta = this.relations.get(measure);
+        // `__subject` aligns with the value-graph's subjectOf default so the
+        // attached DSLValueGraph resolves the same key setValue() wrote.
+        const args = { __subject: user };
+        for (const p of (measureMeta?.params || [])) args[p.name] = (p.name in bound ? bound[p.name] : user);
+        let resolved = null;
+        let err = null;
+        try {
+          resolved = await this.measure(measure, args);
+        } catch (e) {
+          err = e;
+        }
+        if (err || resolved === null || resolved === undefined) {
+          missingFacts.push({ relation: measure, reason: err ? err.message : 'not_provided' });
+          satisfied.add(measure);
+          continue;
+        }
+        partialRelations.push({
+          relation: measure,
+          src: user,
+          dst: user,
+          value: resolved.value,
+          possibility: 1,
+          ...(resolved.unit != null ? { unit: resolved.unit } : {})
+        });
+        satisfied.add(measure);
+        injectedRelations.push({ relation: measure, edges: 1, round: 'measure', cacheHit: false });
+      }
+      if (partialRelations.length > 0) {
+        checkOptions.partialGraph = {
+          ...(checkOptions.partialGraph || {}),
+          relations: partialRelations
+        };
+      }
+    }
+
+    // A value-typed object parameter means the check object IS the expected
+    // edge value, not a node key. Value-carrying facts store edges as
+    // self-edges on the subject, so the underlying check runs on the subject
+    // with the value carried as a per-check gate (options.expectedValue).
+    const isValueObject = meta && meta.params.length === 2 && this._isValueType(meta.params[1].type);
+    const checkObject = isValueObject ? user : object;
+    if (isValueObject) {
+      checkOptions.expectedValue = object;
+    }
+
+    const result = this.arbiter.check(user, relation, checkObject, checkOptions);
 
     return {
       ...result,
       requiredFacts: requiredList,
       providedFacts: injectedRelations.map(r => r.relation),
-      missingFacts
+      missingFacts,
+      warnings
     };
   }
 

src/validation/DSLValidation.js

@@ -1,7 +1,9 @@
 import { parse } from '../parser/GeneratedParser.js';
 import { DSL_PRELUDE } from './DSLPrelude.js';
 
-const BUILTIN_TYPES = new Set(['string', 'number', 'boolean', 'timestamp', 'duration', 'object', 'any']);
+// NO JS bigint in the value model — large integers are `buffer` (Uint8Array),
+// matching the value-graph's JSON-free/bigint-free wire format.
+const BUILTIN_TYPES = new Set(['string', 'number', 'boolean', 'timestamp', 'duration', 'object', 'any', 'buffer', 'array', 'interval']);
 const BUILTIN_CHALLENGES = new Set([
   'mfa',
   'webauthn',
@@ -141,6 +143,22 @@ function validateDefinitions(program, tables, errors, warnings, source) {
         }));
       }
     }
+
+    // Duplicate field names within a definition silently keep the last
+    // declaration (e.g. `{ id: string id: string }`) — reject loudly instead.
+    const fieldSeen = new Set();
+    for (const field of def.fields || []) {
+      if (fieldSeen.has(field.name)) {
+        errors.push(createError({
+          message: `Duplicate field '${def.name}.${field.name}'.`,
+          rule: 'Each field name must be unique within a definition.',
+          fix: `Remove the duplicate declaration of '${def.name}.${field.name}'.`,
+          location: findLocation(source, field.name),
+          context: formatContext(source, findLocation(source, def.name))
+        }));
+      }
+      fieldSeen.add(field.name);
+    }
   }
 }
 
@@ -1006,6 +1024,31 @@ function formatPegError(error, sourceText, sourceName) {
     message = 'Missing colon after identifier.';
     fix = 'Add ":" between a name and its type.';
     rule = 'Types must be declared using name: Type syntax.';
+  } else {
+    // Targeted hints for common declaration mistakes. The peggy error only
+    // reports "unexpected X"; these heuristics read the source around the
+    // failure to point at the real constraint.
+    const offset = error.location?.start?.offset ?? -1;
+    const before = offset >= 0 ? sourceText.slice(0, offset) : '';
+    const tail = before.split(/\n/).pop() || '';
+    const lastKeyword = (() => {
+      const matches = [...before.matchAll(/\b(fact|relation|source|evidence|measure)\b/g)];
+      return matches.length ? matches[matches.length - 1][1] : null;
+    })();
+
+    if (found === 'w' && lastKeyword === 'fact' || (found === 'w' && lastKeyword === 'relation')) {
+      message = '`within` is only valid on `source` declarations.';
+      fix = 'Move the recency constraint to a `source` declaration, or drop `within` here.';
+      rule = 'Only sources accept a `within` freshness constraint.';
+    } else if (/\bBEHAVES\b/.test(before) && tail.includes('BEHAVES')) {
+      message = 'A declaration can carry only one `BEHAVES` clause.';
+      fix = 'Choose either a behavior (`BEHAVES AS transitive`) or a TTL (`BEHAVES { ttl 1h }`), not both.';
+      rule = '`BEHAVES` may appear at most once per declaration.';
+    } else if (found === 'l' && lastKeyword === 'evidence' && sourceText.slice(offset, offset + 5) === 'limit') {
+      message = '`limit` is only valid on pattern/recursive bodies.';
+      fix = 'Move `limit N` onto the pattern itself, e.g. reports_to(user, *m) { ... } limit N.';
+      rule = 'Only pattern bodies take a recursion depth limit.';
+    }
   }
 
   return createError({

src/value-graph/DSLValueGraph.js

@@ -0,0 +1,256 @@
+/**
+ * DSLValueGraph — wires a DSLRuntime's declared MEASURES to a @arbiter/value-graph.
+ *
+ * The DSL is the schema authority: each `measure name(params) { ... } PROVIDES type`
+ * becomes a value-graph relation whose spec carries the declared return type and
+ * parameter types. The value-graph is then:
+ *
+ *   - the STORAGE substrate for values/attributes that are supplied directly
+ *     (not cached or computed) — `setValue(name, args, value)` writes them;
+ *   - the RETRIEVAL substrate for measure lookups — `measure(name, args)` (and,
+ *     after `attach()`, `runtime.measure(...)`) read through `valueGraph.get(...)`,
+ *     so authorization evaluation pulls values "for partial graph purposes";
+ *   - the COMPUTE substrate for external value resolvers — `resolve(name, fn)`
+ *     registers a callback/sync resolver that becomes the node's operator fn
+ *     (ARRA/Overlay adapters plug here).
+ *
+ * Typing / validation: values written or resolved must match the DSL-declared
+ * PROVIDES type (enforced both here and by the value-graph itself), and bindings
+ * are validated against the declared parameter types. Unknown measure names and
+ * type mismatches fail loudly.
+ */
+import { ValueGraph, validateValueType } from '@arbiter/value-graph';
+
+const CONTROL_KEYS = new Set(['__subject', '__actor', '__source', '__meta']);
+
+function isControlKey(key) {
+  return CONTROL_KEYS.has(key) || (typeof key === 'string' && key.startsWith('_'));
+}
+
+export class DSLValueGraph {
+  /**
+   * @param {DSLRuntime} runtime - an already-compiled DSLRuntime
+   * @param {Object} [options]
+   * @param {ValueGraph} [options.valueGraph] - shared graph (default: a fresh one)
+   * @param {number} [options.defaultTTL] - per-node TTL for declared measures (default 0 = persist until set/invalidate)
+   * @param {Function} [options.subjectOf] - (name, args) => subject key (default: args.__subject ?? 'global')
+   * @param {boolean} [options.strict] - throw on unknown measures (default true)
+   */
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.vg = options.valueGraph || new ValueGraph({ defaultTTL: options.defaultTTL ?? 0 });
+    this.subjectOf = options.subjectOf || ((name, args) => (args && args.__subject) || 'global');
+    this.strict = options.strict !== false;
+    this.resolvers = new Map(); // measure name -> callback/sync resolver
+    this.measures = new Map();  // measure name -> { params, returnType }
+    this._attached = new Set(); // measure names attach() registered on the runtime
+    this._registerFromSchema();
+  }
+
+  // ---------------------------------------------------------------------------
+  // Schema registration — DSL declares the value-graph's typing / structure.
+  // ---------------------------------------------------------------------------
+
+  _registerFromSchema() {
+    return this.sync();
+  }
+
+  /**
+   * Re-read the runtime schema and re-register measure nodes. Call after the
+   * runtime recompiles a new program: new measures get value-graph nodes, removed
+   * ones are dropped, and changed return types/params are updated in place.
+   */
+  sync() {
+    const schema = this.runtime.getSchema();
+    const seen = new Set();
+    for (const m of schema.measures || []) {
+      const name = m.name;
+      seen.add(name);
+      const params = (m.params || []).map((p) => ({ name: p.name, type: p.type, isArray: !!p.isArray }));
+      const returnType = m.returnType || 'number';
+      const existing = this.measures.get(name);
+      if (existing) {
+        existing.params = params;
+        existing.returnType = returnType;
+      } else {
+        this.measures.set(name, { params, returnType });
+        this.vg.define(name, {
+          operator: 'source',
+          returnType,
+          params,
+          fn: (subject, bindings, ctx, cb) => this._resolve(name, subject, bindings, ctx, cb)
+        });
+      }
+    }
+    for (const name of [...this.measures.keys()]) {
+      if (!seen.has(name)) this.measures.delete(name);
+    }
+    return this;
+  }
+
+  /** The value-graph node schema derived from the DSL (name → spec). */
+  schema() {
+    const out = {};
+    for (const [name] of this.measures) out[name] = this.vg.relationSpec(name);
+    return out;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Measure metadata + binding normalization + validation
+  // ---------------------------------------------------------------------------
+
+  _measure(name) {
+    const meta = this.measures.get(name);
+    if (!meta) {
+      if (this.strict) throw new Error(`DSLValueGraph: '${name}' is not a declared measure`);
+      return null;
+    }
+    return meta;
+  }
+
+  /**
+   * Normalize positional (array) args to named bindings, strip control keys
+   * (`_subject` etc.), and validate the bound values against declared params.
+   * Positional args must match the declared arity exactly — otherwise the cache
+   * key would silently diverge from the caller's intent.
+   */
+  _bindings(name, args) {
+    const meta = this._measure(name);
+    if (!meta) return {};
+    let raw = args;
+    if (Array.isArray(args)) {
+      if (args.length !== meta.params.length) {
+        throw new Error(
+          `DSLValueGraph: measure '${name}' expects ${meta.params.length} positional argument(s), got ${args.length}`
+        );
+      }
+      raw = {};
+      for (let i = 0; i < meta.params.length; i++) raw[meta.params[i].name] = args[i];
+    }
+    const bindings = {};
+    for (const [key, value] of Object.entries(raw || {})) {
+      if (isControlKey(key)) continue;
+      bindings[key] = value;
+    }
+    for (const p of meta.params) {
+      if (!(p.name in bindings)) continue;
+      const v = bindings[p.name];
+      if (p.isArray) {
+        if (!Array.isArray(v)) throw new Error(`DSLValueGraph: parameter '${p.name}' of '${name}' must be an array`);
+      } else if (!validateValueType(v, p.type)) {
+        throw new Error(`DSLValueGraph: parameter '${p.name}' of '${name}' must match declared type '${p.type}'`);
+      }
+    }
+    return bindings;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Resolvers (the compute substrate)
+  // ---------------------------------------------------------------------------
+
+  _resolve(name, subject, bindings, ctx, cb) {
+    const resolver = this.resolvers.get(name);
+    if (resolver) return resolver(subject, bindings, ctx, cb);
+    cb(null, null); // stored-only measure with nothing stored → null
+  }
+
+  /**
+   * Register an external value resolver for a declared measure. The resolver is
+   * a value-graph callback/sync resolver: `(subject, params, ctx, cb)` → calls
+   * `cb(err, value)` (or `{ value, unit, source }`) or returns a value synchronously.
+   * Unknown measures are a no-op in non-strict mode, an error in strict mode.
+   */
+  resolve(name, fn) {
+    if (!this._measure(name)) return this;
+    if (typeof fn !== 'function') throw new Error(`DSLValueGraph: resolver for '${name}' must be a function`);
+    this.resolvers.set(name, fn);
+    return this;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Storage — values/attributes that are NOT cached or computed.
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Store a value/attribute directly into the value-graph. The value is validated
+   * against the measure's declared PROVIDES type and readable back via getValue /
+   * measure / runtime.measure until overwritten or invalidated.
+   * Unknown measures are a no-op in non-strict mode, an error in strict mode.
+   */
+  setValue(name, args, value, { unit = null, source = 'dsl' } = {}) {
+    const meta = this._measure(name);
+    if (!meta) return this;
+    if (!validateValueType(value, meta.returnType)) {
+      throw new Error(`DSLValueGraph: value for '${name}' must match declared type '${meta.returnType}'`);
+    }
+    const bindings = this._bindings(name, args);
+    const subject = this.subjectOf(name, args);
+    this.vg.set(subject, name, bindings, { value, unit, source });
+    return this;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Retrieval — partial-graph purposes.
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Synchronously retrieve a value from the value-graph (stored or resolved).
+   * Returns the entry `{ value, unit, at, source, fresh }` or `null`.
+   * Unknown measures are null in non-strict mode, an error in strict mode.
+   */
+  getValue(name, args) {
+    const meta = this._measure(name);
+    if (!meta) return null;
+    const bindings = this._bindings(name, args);
+    const subject = this.subjectOf(name, args);
+    let out = null;
+    let errOut = null;
+    this.vg.get(subject, name, bindings, (err, entry) => { errOut = err; out = entry; });
+    if (errOut) throw errOut;
+    return out;
+  }
+
+  /**
+   * Async measure retrieval matching `DSLRuntime.measure`'s shape:
+   * `{ value, unit, source }`. Missing → `{ value: null, unit: null, source: null }`.
+   * Unknown measures are `{ value: null, ... }` in non-strict mode, an error in strict mode.
+   */
+  async measure(name, args = {}) {
+    const meta = this._measure(name);
+    if (!meta) return { value: null, unit: null, source: null };
+    const bindings = this._bindings(name, args);
+    const subject = this.subjectOf(name, args);
+    return new Promise((resolve, reject) => {
+      this.vg.get(subject, name, bindings, (err, entry) => {
+        if (err) return reject(err);
+        resolve(entry
+          ? { value: entry.value, unit: entry.unit, source: entry.source }
+          : { value: null, unit: null, source: null });
+      });
+    });
+  }
+
+  /**
+   * Wire `runtime.measure(name, args)` through the value-graph by registering a
+   * value-graph-backed provider for every DECLARED measure. Re-syncs first, so a
+   * recompiled runtime picks up new measures and drops attach-registered
+   * providers for removed ones. A later manual `registerMeasure` overrides it
+   * until the next attach.
+   */
+  attach() {
+    this.sync();
+    const declared = new Set(this.measures.keys());
+    for (const name of this._attached) {
+      if (!declared.has(name) && this.runtime.measureProviders.has(name)) {
+        this.runtime.unregisterMeasure(name);
+      }
+    }
+    for (const name of declared) {
+      this.runtime.registerMeasure(name, async (bindings) => this.measure(name, bindings));
+      this._attached.add(name);
+    }
+    return this;
+  }
+}
+
+export default DSLValueGraph;

tests/DSLCompiler.test.js

@@ -196,6 +196,36 @@ describe('DSL Compiler', () => {
     assert.ok(invalidResult.errors.length > 0, 'Should have validation errors');
   });
 
+  test('Rejects duplicate fields within a definition', () => {
+    const dupFieldDSL = `
+      definition Employee { id: string id: string }
+    `;
+    const result = compiler.validate(dupFieldDSL);
+    assert.ok(!result.success, 'Duplicate field should fail validation');
+    assert.match(result.errors[0], /Duplicate field 'Employee.id'/);
+  });
+
+  test('Hints at the real constraint for common declaration mistakes', () => {
+    const withinOnFact = compiler.compile(`
+      definition Employee { id: string? }
+      fact owns(user: Employee, doc: Employee) within 1h
+    `, 'err-within');
+    assert.match(withinOnFact.errors[0], /within.*only valid on `source`/);
+
+    const doubleBehaves = compiler.compile(`
+      definition Employee { id: string? }
+      fact rel(user: Employee, doc: Employee) BEHAVES AS transitive BEHAVES { ttl 1h }
+    `, 'err-behaves');
+    assert.match(doubleBehaves.errors[0], /only one `BEHAVES` clause/);
+
+    const limitAfterBody = compiler.compile(`
+      definition Employee { id: string? }
+      fact owns(user: Employee, doc: Employee)
+      evidence can_read(user: Employee, doc: Employee) { owns(user, doc) } limit 5
+    `, 'err-limit');
+    assert.match(limitAfterBody.errors[0], /`limit` is only valid on pattern/);
+  });
+
   test('Rule generation', () => {
     const dsl = `
       definition Employee {

tests/DSLRuntime.test.js

@@ -205,4 +205,123 @@ describe('DSLRuntime', () => {
     // evidence's requirements, alongside the edge-traversal fact.
     assert.deepEqual(rt.requiredFacts('can_via'), ['member_of', 'can_view', 'banned']);
   });
+
+  it('negates a NOT predicate (1 - possibility)', async () => {
+    const dsl = `
+      definition Employee { id: string? }
+      fact banned(user: Employee)
+      evidence can_enter(user: Employee) { NOT banned(user) }
+    `;
+    // Absent predicate negates to allow.
+    const absent = new DSLRuntime(new Arbiter()).compile(dsl, 'rt-not-absent');
+    absent.addNode('u:1', 'Employee', {});
+    assert.equal((await absent.check('u:1', 'can_enter', 'u:1')).possibility, 1);
+    // Present predicate negates to its complement.
+    const present = new DSLRuntime(new Arbiter()).compile(dsl, 'rt-not-present');
+    present.addNode('u:1', 'Employee', {});
+    present.addRelation('u:1', 'banned', 'u:1', { possibility: 0.9 });
+    const denied = await present.check('u:1', 'can_enter', 'u:1');
+    assert.ok(Math.abs(denied.possibility - 0.1) < 1e-9, `expected 0.1, got ${denied.possibility}`);
+    // Nested inside an AND: the negated child still scopes to the subject.
+    const nested = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      definition Doc { id: string? }
+      fact owns(user: Employee, doc: Doc)
+      fact banned(user: Employee)
+      evidence can_open(user: Employee, doc: Doc) { owns(user, doc) NOT banned(user) }
+    `, 'rt-not-nested');
+    nested.addNode('u:1', 'Employee', {});
+    nested.addNode('doc:9', 'Doc', {});
+    nested.addRelation('u:1', 'owns', 'doc:9', { possibility: 0.8 });
+    nested.addRelation('u:1', 'banned', 'u:1', { possibility: 0.6 });
+    assert.equal((await nested.check('u:1', 'can_open', 'doc:9')).possibility, 0.4);
+  });
+
+  it('resolves BEHAVES AS transitive facts as bounded transitive closure', async () => {
+    const dsl = `
+      definition Employee { id: string? }
+      fact reports_to(user: Employee, boss: Employee) BEHAVES AS transitive
+      evidence can_see(user: Employee, doc: Employee) { reports_to(user, doc) }
+    `;
+    const rt = new DSLRuntime(new Arbiter()).compile(dsl, 'rt-transitive');
+    ['e:1', 'e:2', 'e:3', 'e:4'].forEach(k => rt.addNode(k, 'Employee', {}));
+    rt.addRelation('e:1', 'reports_to', 'e:2', { possibility: 1.0 });
+    rt.addRelation('e:2', 'reports_to', 'e:3', { possibility: 0.9 });
+    rt.addRelation('e:3', 'reports_to', 'e:4', { possibility: 0.8 });
+    // Direct checks on the transitive fact follow multi-hop paths.
+    assert.equal((await rt.check('e:1', 'reports_to', 'e:3')).possibility, 0.9);
+    assert.equal((await rt.check('e:1', 'reports_to', 'e:4')).possibility, 0.8);
+    // Reverse direction does not grant.
+    assert.equal((await rt.check('e:2', 'reports_to', 'e:1')).possibility, 0);
+    // Evidence references inherit the closure.
+    assert.equal((await rt.check('e:1', 'can_see', 'e:4')).possibility, 0.8);
+    // Non-transitive facts stay direct-only.
+    const direct = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      fact knows(user: Employee, peer: Employee)
+      evidence can_ping(user: Employee, doc: Employee) { knows(user, doc) }
+    `, 'rt-nontransitive');
+    ['a:1', 'a:2', 'a:3'].forEach(k => direct.addNode(k, 'Employee', {}));
+    direct.addRelation('a:1', 'knows', 'a:2', { possibility: 1.0 });
+    direct.addRelation('a:2', 'knows', 'a:3', { possibility: 1.0 });
+    assert.equal((await direct.check('a:1', 'can_ping', 'a:3')).possibility, 0);
+  });
+
+  it('bounds transitive closure depth by the fact limit', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      fact reports_to(user: Employee, boss: Employee) BEHAVES AS transitive limit 2
+      evidence can_see(user: Employee, doc: Employee) { reports_to(user, doc) }
+    `, 'rt-transitive-limit');
+    ['e:1', 'e:2', 'e:3', 'e:4'].forEach(k => rt.addNode(k, 'Employee', {}));
+    rt.addRelation('e:1', 'reports_to', 'e:2', { possibility: 1.0 });
+    rt.addRelation('e:2', 'reports_to', 'e:3', { possibility: 1.0 });
+    rt.addRelation('e:3', 'reports_to', 'e:4', { possibility: 1.0 });
+    assert.equal((await rt.check('e:1', 'can_see', 'e:3')).possibility, 1.0);
+    assert.equal((await rt.check('e:1', 'can_see', 'e:4')).possibility, 0);
+  });
+
+  it('retrieves sources through providers and gates them by within recency', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      definition Doc { id: string? }
+      source *session(user: Employee) within 1h
+      fact *owns(user: Employee, doc: Doc)
+      evidence can_read(user: Employee, doc: Doc) { session(user) owns(user, doc) }
+    `, 'rt-source');
+    rt.addNode('u:1', 'Employee', {});
+    rt.addNode('doc:9', 'Doc', {});
+    assert.ok(rt.relations.has('session'));
+    assert.equal(rt.relations.get('session').kind, 'source');
+    assert.equal(rt.relations.get('session').withinMs, 3_600_000);
+    // A fresh session proof grants.
+    const fresh = await rt.check('u:1', 'can_read', 'doc:9', {
+      factProviders: { session: async () => ({ possibility: 1.0, value: Date.now() }), owns: async () => 0.9 }
+    });
+    assert.equal(fresh.possibility, 0.9);
+    assert.deepEqual(fresh.providedFacts, ['session', 'owns']);
+    // A stale proof (2h old, beyond the 1h window) denies as stale.
+    const stale = await rt.check('u:1', 'can_read', 'doc:9', {
+      factProviders: { session: async () => ({ possibility: 1.0, value: Date.now() - 2 * 3600_000 }), owns: async () => 0.9 }
+    });
+    assert.equal(stale.possibility, 0);
+    assert.deepEqual(stale.missingFacts, [{ relation: 'session', reason: 'stale' }]);
+  });
+
+  it('warns about and drops provider edges referencing unknown nodes', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      definition Doc { id: string? }
+      fact *owns(user: Employee, doc: Doc)
+      evidence can_read(user: Employee, doc: Doc) { owns(user, doc) }
+    `, 'rt-ghost');
+    rt.addNode('u:1', 'Employee', {});
+    rt.addNode('doc:9', 'Doc', {});
+    const res = await rt.check('u:1', 'can_read', 'doc:9', {
+      factProviders: { owns: async () => [{ src: 'ghost:1', dst: 'doc:9', possibility: 0.9 }] }
+    });
+    assert.equal(res.possibility, 0);
+    assert.equal(res.warnings.length, 1);
+    assert.match(res.warnings[0], /unknown source node 'ghost:1'/);
+  });
 });

tests/DSLRuntimeExt.test.js

@@ -165,4 +165,69 @@ describe('DSLRuntime extended', () => {
     assert.equal(missed.possibility, 0);
     assert.deepEqual(missed.missingFacts, [{ relation: 'owns', reason: 'no_provider' }]);
   });
+
+  it('recompiling a scope uninstalls its stale relation configs', async () => {
+    const rt = new DSLRuntime(new Arbiter());
+    rt.compile(`
+      definition Employee { id: string? }
+      definition Doc { id: string? }
+      fact owns(user: Employee, doc: Doc)
+      evidence can_read(user: Employee, doc: Doc) { owns(user, doc) }
+    `, 'rt-stale');
+    rt.addNode('u:1', 'Employee', {});
+    rt.addNode('doc:9', 'Doc', {});
+    rt.addRelation('u:1', 'owns', 'doc:9', { possibility: 1.0 });
+    assert.equal(rt.arbiter.check('u:1', 'can_read', 'doc:9').possibility, 1.0);
+
+    // Recompile the SAME scope with a different program: can_read/owns are no
+    // longer declared and must not keep granting. A second scope's relations
+    // would be unaffected (compileMultiple coexistence).
+    rt.compile(`
+      definition Employee { id: string? }
+      definition Doc { id: string? }
+      fact shares(user: Employee, doc: Doc)
+      evidence can_share(user: Employee, doc: Doc) { shares(user, doc) }
+    `, 'rt-stale');
+    const stale = rt.arbiter.check('u:1', 'can_read', 'doc:9');
+    assert.equal(stale.possibility, 0, 'revoked can_read must not keep granting');
+    assert.ok(!rt.arbiter.relationConfigs.has('can_read'));
+    assert.ok(!rt.arbiter.relationConfigs.has('owns'));
+    assert.ok(rt.arbiter.relationConfigs.has('can_share'));
+  });
+
+  it('indexes measures and resolves them via a registered provider', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      definition Project { id: string? }
+      measure budget_available(tenant: Employee, feature: string) { } PROVIDES number
+      measure clearance(user: Employee) { } PROVIDES string
+    `, 'rt-measures');
+    // Schema exposes measures with their return type.
+    const schema = rt.getSchema();
+    const budget = schema.measures.find(m => m.name === 'budget_available');
+    assert.ok(budget);
+    assert.equal(budget.returnType, 'number');
+    assert.deepEqual(budget.params.map(p => p.name), ['tenant', 'feature']);
+    assert.ok(rt.relationNames().includes('clearance'));
+
+    // No provider yet → resolution fails loudly.
+    await assert.rejects(() => rt.measure('budget_available', { tenant: 'tenant:acme', feature: 'tokens_in:gpt-4' }), /no provider registered/);
+
+    // Register a provider (the ARRA adapter would bridge the value-graph).
+    rt.registerMeasure('budget_available', async ({ tenant, feature }) => {
+      assert.equal(tenant, 'tenant:acme');
+      assert.equal(feature, 'tokens_in:gpt-4');
+      return { value: 1250, unit: 'tokens' };
+    });
+    const resolved = await rt.measure('budget_available', { tenant: 'tenant:acme', feature: 'tokens_in:gpt-4' });
+    assert.equal(resolved.value, 1250);
+    assert.equal(resolved.unit, 'tokens');
+
+    // Positional args bind by param order for unary measures.
+    rt.registerMeasure('clearance', async () => ({ value: 'secret' }));
+    assert.equal((await rt.measure('clearance', ['user:alice'])).value, 'secret');
+
+    // registerMeasure rejects undeclared names.
+    assert.throws(() => rt.registerMeasure('nope', async () => 1), /not a declared measure/);
+  });
 });

tests/DSLRuntimeTyping.test.js

@@ -93,4 +93,44 @@ describe('DSLRuntime typing', () => {
     rt.registerFact('owns', async () => ({ possibility: 2.0 }));
     await assert.rejects(() => rt.check('u:1', 'can_read', 'doc:9'), /invalid possibility/);
   });
+
+  it('enforces a literal value in evidence as an exact edge-value gate', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      fact balance(user: Employee, amount: number)
+      evidence can_afford(user: Employee) { balance(user, 5) }
+    `, 'rt-expected-value');
+    rt.addNode('u:1', 'Employee', {});
+    // An edge carrying amount 3 must NOT satisfy balance(user, 5) — without the
+    // gate every balance edge matched regardless of amount (silent over-grant).
+    rt.addRelation('u:1', 'balance', 'u:1', { possibility: 1.0, value: 3 });
+    const denied = await rt.check('u:1', 'can_afford', 'u:1');
+    assert.equal(denied.possibility, 0, 'value-3 edge must not satisfy balance(user, 5)');
+    rt.addRelation('u:1', 'balance', 'u:1', { possibility: 0.8, value: 5 });
+    const granted = await rt.check('u:1', 'can_afford', 'u:1');
+    assert.equal(granted.possibility, 0.8, 'value-5 edge must satisfy balance(user, 5)');
+  });
+
+  it('treats a value-typed evidence OBJECT param as the expected edge value', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile(`
+      definition Employee { id: string? }
+      fact balance(user: Employee, amount: number)
+      evidence can_withdraw(user: Employee, amount: number) { balance(user, amount) }
+    `, 'rt-value-object');
+    rt.addNode('u:1', 'Employee', {});
+    rt.addRelation('u:1', 'balance', 'u:1', { possibility: 0.9, value: 5 });
+    // The check object is the VALUE, not a node key: grant only on exact match.
+    const granted = await rt.check('u:1', 'can_withdraw', 5);
+    assert.equal(granted.possibility, 0.9, 'value-5 check must match the value-5 edge');
+    const denied = await rt.check('u:1', 'can_withdraw', 3);
+    assert.equal(denied.possibility, 0, 'value-3 check must not match the value-5 edge');
+    // Re-checking the granted value must not hit a value-3 cache entry.
+    const again = await rt.check('u:1', 'can_withdraw', 5);
+    assert.equal(again.possibility, 0.9, 'value-5 re-check must not be served the value-3 result');
+    // Direct fact check with a value object works the same way.
+    const direct = await rt.check('u:1', 'balance', 5);
+    assert.equal(direct.possibility, 0.9, 'direct balance(user, 5) must match the value-5 edge');
+    // A non-scalar object for a value-typed param is rejected loudly.
+    await assert.rejects(() => rt.check('u:1', 'can_withdraw', 'u:1'), /must be number/);
+  });
 });

tests/DSLValueGraph.test.js

@@ -0,0 +1,201 @@
+/**
+ * DSLValueGraph — evidence DSL declares the value-graph's typing/structures;
+ * measures retrieve through the graph (partial-graph purposes), and attributes
+ * that are neither cached nor computed are stored directly via setValue.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Arbiter } from '@arbiter/core';
+import { ValueGraph } from '@arbiter/value-graph';
+import { DSLRuntime, DSLValueGraph } from '../src/index.js';
+
+function makeRuntime(dsl) {
+  return new DSLRuntime(new Arbiter()).compile(dsl, 'vg-test');
+}
+
+const DSL = `
+  definition Employee { id: string? }
+  definition Project { id: string? }
+  measure budget_available(tenant: Employee, feature: string) { } PROVIDES number
+  measure clearance(user: Employee) { } PROVIDES string
+  measure is_active(user: Employee) { } PROVIDES boolean
+`;
+
+describe('DSLValueGraph integration', () => {
+  it('derives the value-graph node schema from the DSL measures', () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    const schema = dvg.schema();
+    assert.equal(schema.budget_available.returnType, 'number');
+    assert.deepEqual(schema.budget_available.params.map((p) => p.name), ['tenant', 'feature']);
+    assert.equal(schema.clearance.returnType, 'string');
+    assert.equal(schema.is_active.returnType, 'boolean');
+  });
+
+  it('stores attributes that are neither cached nor computed, and reads them back', () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    dvg.setValue('budget_available', { __subject: 'tenant:acme', tenant: 'tenant:acme', feature: 'tokens_in:gpt-4' }, 1250, { unit: 'tokens' });
+    const entry = dvg.getValue('budget_available', { __subject: 'tenant:acme', tenant: 'tenant:acme', feature: 'tokens_in:gpt-4' });
+    assert.equal(entry.value, 1250);
+    assert.equal(entry.unit, 'tokens');
+    assert.equal(entry.source, 'dsl');
+    assert.equal(entry.fresh, true);
+  });
+
+  it('measure() retrieves through the value-graph (partial-graph purposes)', async () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    dvg.setValue('clearance', { __subject: 'user:alice', user: 'user:alice' }, 'secret');
+    const resolved = await dvg.measure('clearance', { __subject: 'user:alice', user: 'user:alice' });
+    assert.equal(resolved.value, 'secret');
+  });
+
+  it('attach() wires runtime.measure() through the value-graph', async () => {
+    const rt = makeRuntime(DSL);
+    const dvg = new DSLValueGraph(rt);
+    dvg.setValue('is_active', { __subject: 'user:alice', user: 'user:alice' }, true);
+    dvg.attach();
+    const resolved = await rt.measure('is_active', { __subject: 'user:alice', user: 'user:alice' });
+    assert.equal(resolved.value, true);
+    // A measure with nothing stored resolves to null — no provider explosion.
+    const missing = await rt.measure('clearance', { __subject: 'user:bob', user: 'user:bob' });
+    assert.equal(missing.value, null);
+  });
+
+  it('resolves a value via an external callback resolver (the compute substrate)', async () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    dvg.resolve('budget_available', (subject, params, ctx, cb) => {
+      cb(null, { value: 999, unit: 'tokens', source: 'overlay:balances' });
+    });
+    const entry = await dvg.measure('budget_available', { __subject: 'tenant:acme', tenant: 'tenant:acme', feature: 'x' });
+    assert.equal(entry.value, 999);
+    assert.equal(entry.unit, 'tokens');
+    assert.equal(entry.source, 'overlay:balances');
+  });
+
+  it('validates stored values against the declared PROVIDES type', () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    assert.throws(() => dvg.setValue('budget_available', { feature: 'x' }, 'not-a-number'), /must match declared type 'number'/);
+    assert.throws(() => dvg.setValue('clearance', { user: 'u' }, 42), /must match declared type 'string'/);
+  });
+
+  it('validates parameter bindings against the declared parameter types', () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    assert.throws(() => dvg.setValue('budget_available', { tenant: 't', feature: 42 }, 5),
+      /parameter 'feature' of 'budget_available' must match declared type 'string'/);
+  });
+
+  it('rejects unknown measure names', async () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    assert.throws(() => dvg.setValue('nope', {}, 1), /not a declared measure/);
+    assert.throws(() => dvg.getValue('nope', {}), /not a declared measure/);
+    assert.throws(() => dvg.resolve('nope', () => 1), /not a declared measure/);
+    await assert.rejects(() => dvg.measure('nope', {}), /not a declared measure/);
+  });
+
+  it('binds positional args by declared parameter order', () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    dvg.setValue('budget_available', ['tenant:acme', 'tokens_in:gpt-4'], 50);
+    const entry = dvg.getValue('budget_available', ['tenant:acme', 'tokens_in:gpt-4']);
+    assert.equal(entry.value, 50);
+  });
+
+  it('the value-graph itself enforces declared return types on resolver results', async () => {
+    const dvg = new DSLValueGraph(makeRuntime(DSL));
+    dvg.resolve('clearance', (s, p, ctx, cb) => cb(null, 12345)); // number, but PROVIDES string
+    const err = await dvg.measure('clearance', { __subject: 'user:alice', user: 'user:alice' }).then(() => null, (e) => e);
+    assert.ok(err, 'a wrong-typed resolver result must be rejected');
+    assert.match(err.message, /must match declared type 'string'/);
+  });
+
+  it('shares a caller-supplied value graph and supports subjectOf', () => {
+    const vg = new ValueGraph();
+    const dvg = new DSLValueGraph(makeRuntime(DSL), {
+      valueGraph: vg,
+      subjectOf: (name, args) => args.tenant || args.user || 'global'
+    });
+    assert.equal(dvg.vg, vg);
+    dvg.setValue('clearance', { user: 'user:alice' }, 'top-secret');
+    assert.equal(dvg.getValue('clearance', { user: 'user:alice' }).value, 'top-secret');
+  });
+
+  it('rigor: setValue/getValue round-trips always return the stored value', async () => {
+    const { rigor } = await import('@rigor/core');
+    const report = await rigor.campaign(
+      [rigor.fn('roundtrip', (value) => {
+        const dvg = new DSLValueGraph(makeRuntime(DSL));
+        dvg.setValue('budget_available', { __subject: 'tenant:acme', tenant: 'tenant:acme', feature: 'f' }, value);
+        const e = dvg.getValue('budget_available', { __subject: 'tenant:acme', tenant: 'tenant:acme', feature: 'f' });
+        return e ? e.value : 'MISSING';
+      }, rigor.args(rigor.gen.int(-100000, 100000)))],
+      rigor.crucible([rigor.invariant('roundtrip', (ctx) => ctx.actual === ctx.args[0])])
+    ).run({ effort: 150, seed: 'dsl-vg-roundtrip' });
+    if (report.status !== 'passed') {
+      throw new Error(`DSLValueGraph rigor roundtrip failed: ${JSON.stringify((report.failures || []).slice(0, 3))}`);
+    }
+  });
+
+  it('rigor: setValue rejects wrong-typed values for every generated value', async () => {
+    const { rigor } = await import('@rigor/core');
+    const report = await rigor.campaign(
+      [rigor.fn('typed-reject', (value) => {
+        const dvg = new DSLValueGraph(makeRuntime(DSL));
+        try {
+          dvg.setValue('clearance', { user: 'u' }, value); // PROVIDES string
+          return { ok: true };
+        } catch (e) {
+          return { ok: false, error: e.message };
+        }
+      }, rigor.args(rigor.gen.int(0, 100)))],
+      rigor.crucible([rigor.invariant('rejects', (ctx) => ctx.actual.ok === false && /must match declared type 'string'/.test(ctx.actual.error))])
+    ).run({ effort: 150, seed: 'dsl-vg-typecheck' });
+    if (report.status !== 'passed') {
+      throw new Error(`DSLValueGraph rigor typecheck failed: ${JSON.stringify((report.failures || []).slice(0, 3))}`);
+    }
+  });
+
+  it('the aligned type vocabulary round-trips buffer/interval/any/duration', () => {
+    const dvg = new DSLValueGraph(makeRuntime(`
+      definition T { id: string }
+      measure quota(user: string) { } PROVIDES buffer
+      measure span(user: string) { } PROVIDES interval
+      measure whatever(user: string) { } PROVIDES any
+      measure window(user: string) { } PROVIDES duration
+    `));
+    const bytes = new Uint8Array([1, 2, 3, 254, 255]);
+    dvg.setValue('quota', { __subject: 'u', user: 'u' }, bytes);
+    assert.deepEqual([...dvg.getValue('quota', { __subject: 'u', user: 'u' }).value], [...bytes]);
+    dvg.setValue('span', { __subject: 'u', user: 'u' }, { lower: 100, upper: 200 });
+    assert.deepEqual(dvg.getValue('span', { __subject: 'u', user: 'u' }).value, { lower: 100, upper: 200 });
+    dvg.setValue('whatever', { __subject: 'u', user: 'u' }, 42); // any → accepted
+    assert.equal(dvg.getValue('whatever', { __subject: 'u', user: 'u' }).value, 42);
+    dvg.setValue('window', { __subject: 'u', user: 'u' }, '1h');
+    assert.equal(dvg.getValue('window', { __subject: 'u', user: 'u' }).value, '1h');
+  });
+
+  it('sync() re-registers measures after the runtime recompiles', () => {
+    const rt = new DSLRuntime(new Arbiter()).compile('measure a() { } PROVIDES number', 'v1');
+    const dvg = new DSLValueGraph(rt);
+    rt.compile('measure b() { } PROVIDES string', 'v2'); // a removed, b added
+    // Before sync: stale schema.
+    assert.throws(() => dvg.setValue('b', {}, 'x'), /not a declared measure/);
+    // After sync: b is usable, a is gone.
+    dvg.sync();
+    dvg.setValue('b', {}, 'x');
+    assert.equal(dvg.getValue('b', {}).value, 'x');
+    assert.throws(() => dvg.setValue('a', {}, 1), /not a declared measure/);
+    // schema() reflects the current measure set
+    assert.ok(dvg.schema().b);
+    assert.ok(!dvg.schema().a);
+  });
+
+  it('attach() re-syncs and unregisters providers for removed measures after recompile', async () => {
+    const rt = new DSLRuntime(new Arbiter()).compile('measure a() { } PROVIDES number', 'v1');
+    const dvg = new DSLValueGraph(rt);
+    dvg.attach();
+    rt.compile('measure b() { } PROVIDES string', 'v2');
+    dvg.attach(); // re-sync + re-wire
+    dvg.setValue('b', { __subject: 't' }, 'hello');
+    assert.equal((await rt.measure('b', { __subject: 't' })).value, 'hello');
+    // a is no longer declared after the recompile → the runtime rejects it
+    await assert.rejects(() => rt.measure('a', { __subject: 't' }), /unknown measure/);
+  });
+});

tests/EvidenceComposition.test.js

@@ -12,6 +12,8 @@ import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { Arbiter } from '@arbiter/core';
 import { DSLCompiler } from '../src/DSLCompiler.js';
+import { DSLRuntime } from '../src/runtime/DSLRuntime.js';
+import { DSLValueGraph } from '../src/value-graph/DSLValueGraph.js';
 
 const DEFS = `
   definition Employee { id: string }
@@ -151,4 +153,64 @@ describe('Evidence composition', () => {
     assert.equal(arb.check('u:1', 'can_read', 'doc:9').possibility, 0.5);
     assert.equal(arb.check('u:1', 'can_browse', 'doc:9').possibility, 0.5);
   });
+
+  describe('measure + evidence composition', () => {
+    const M_DEFS = `
+      definition Employee { id: string }
+      measure budget_used(user: Employee) { } PROVIDES number
+      measure budget_limit(user: Employee) { } PROVIDES number
+      evidence can_use(user: Employee, doc: string) { budget_used(user) <= budget_limit(user) }
+    `;
+
+    it('compiles an evidence comparator over measure valueRelations', () => {
+      const { arb, result } = compile(M_DEFS, 'm+e-compile');
+      assert.ok(result.success, JSON.stringify(result.errors));
+      const cfg = arb.relationConfigs.get('can_use');
+      assert.equal(cfg.type, 'relational_comparator');
+      assert.equal(cfg.left.valueRelation, 'budget_used');
+      assert.equal(cfg.right.valueRelation, 'budget_limit');
+      assert.deepEqual(cfg.dependsOn, ['budget_used', 'budget_limit']);
+      assert.equal(cfg._needsValues, true);
+    });
+
+    it('evaluates with measure values from registered providers (measure → evidence)', async () => {
+      const rt = new DSLRuntime(new Arbiter()).compile(M_DEFS, 'm+e-provider');
+      const dvg = new DSLValueGraph(rt);
+      dvg.attach(); // wires runtime.measure through the value-graph
+      rt.registerMeasure('budget_used', async () => ({ value: 900 }));
+      rt.registerMeasure('budget_limit', async () => ({ value: 1000 }));
+      rt.arbiter.addNode('u:1', 'Employee');
+
+      // Both systems live: the measure resolves standalone...
+      assert.equal((await rt.measure('budget_used', { user: 'u:1' })).value, 900);
+      // ...and composes into the evidence comparator.
+      const allow = await rt.check('u:1', 'can_use', 'doc:9');
+      assert.equal(allow.possibility, 1);
+      assert.equal(allow.reason, 'allow_rule_matched');
+      assert.ok(allow.providedFacts.includes('budget_used'), 'measure injected as a partial-graph edge');
+    });
+
+    it('evaluates with measure values stored in the value-graph (setValue)', async () => {
+      const rt = new DSLRuntime(new Arbiter()).compile(M_DEFS, 'm+e-vg');
+      const dvg = new DSLValueGraph(rt);
+      dvg.attach();
+      dvg.setValue('budget_used', { __subject: 'u:1', user: 'u:1' }, 900);
+      dvg.setValue('budget_limit', { __subject: 'u:1', user: 'u:1' }, 1000);
+      rt.arbiter.addNode('u:1', 'Employee');
+
+      const allow = await rt.check('u:1', 'can_use', 'doc:9');
+      assert.equal(allow.possibility, 1, 'in-budget evidence allowed from graph-sourced measures');
+
+      // Over budget → the comparator denies.
+      const rt2 = new DSLRuntime(new Arbiter()).compile(M_DEFS, 'm+e-vg2');
+      const dvg2 = new DSLValueGraph(rt2);
+      dvg2.attach();
+      dvg2.setValue('budget_used', { __subject: 'u:1', user: 'u:1' }, 1200);
+      dvg2.setValue('budget_limit', { __subject: 'u:1', user: 'u:1' }, 1000);
+      rt2.arbiter.addNode('u:1', 'Employee');
+      const deny = await rt2.check('u:1', 'can_use', 'doc:9');
+      assert.equal(deny.possibility, 0);
+      assert.equal(deny.reason, 'values_compared_comparison_false');
+    });
+  });
 });

tests/rigor/dsl-value-graph-robustness.test.js

@@ -0,0 +1,338 @@
+/**
+ * tests/rigor/dsl-value-graph-robustness.test.js — js-rigor invariants for the
+ * DSLValueGraph wrapper's robustness: attach() semantics, resolver failure modes,
+ * stored-value lifecycle (overwrite / invalidation isolation / TTL), binding
+ * edge cases, strict-mode behavior, and concurrent retrieval.
+ */
+import { describe, it } from 'node:test';
+import { rigor, reducers } from '@rigor/core';
+import { Arbiter } from '@arbiter/core';
+import { ValueGraph } from '@arbiter/value-graph';
+import { DSLRuntime, DSLValueGraph } from '../../src/index.js';
+
+const DSL = `
+  definition Tenant { id: string }
+  measure budget(tenant: Tenant, feature: string) { } PROVIDES number
+  measure label(user: string) { } PROVIDES string
+`;
+
+function makeDvg() {
+  const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'vg-robust');
+  return new DSLValueGraph(rt);
+}
+
+async function expectPass(name, actions, checks, config = {}) {
+  const report = await rigor.campaign(actions, rigor.crucible(checks))
+    .run({ seed: `dsl-vg-robust-${name}`, effort: 100, artifacts: { dir: '', persist: 'never' }, ...config });
+  if (report.status !== 'passed') {
+    const detail = (report.failures || []).slice(0, 5)
+      .map((f) => JSON.stringify({ action: f.actionName || f.action, inv: f.name, args: f.args, msg: f.message }));
+    throw new Error(`campaign '${name}' failed.\n${detail.join('\n')}`);
+  }
+  return report;
+}
+
+describe('DSLValueGraph robustness (rigor)', () => {
+  it('attach() is idempotent and a manual registerMeasure overrides it', async () => {
+    const actions = [
+      rigor.fn('attach_idempotent', (value, cb) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'r');
+        const dvg = new DSLValueGraph(rt);
+        dvg.attach();
+        dvg.attach(); // idempotent
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, value);
+        rt.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, r.value), (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+      rigor.fn('attach_override', (cb) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'r');
+        const dvg = new DSLValueGraph(rt);
+        dvg.attach();
+        rt.registerMeasure('budget', async () => ({ value: 12345, unit: 'manual' }));
+        rt.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, r.value), (e) => cb(e)
+        );
+      }, rigor.args(rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('attach_idempotent', (ctx) => ctx.error == null && ctx.actual === ctx.args[0]),
+      rigor.after('attach_override', (ctx) => ctx.error == null && ctx.actual === 12345),
+    ];
+    await expectPass('attach', actions, checks);
+  });
+
+  it('resolver failure modes: sync-return, error propagation, wrong-typed result', async () => {
+    const actions = [
+      rigor.fn('resolver_sync', (value, cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p) => value * 2); // sync return
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, r.value), (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 50), rigor.handler(reducers.first()))),
+      rigor.fn('resolver_error', (cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p, ctx, done) => { done(new Error('provider down')); });
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, { ok: true, v: r.value }),
+          (e) => cb(null, { ok: false, msg: e.message })
+        );
+      }, rigor.args(rigor.handler(reducers.first()))),
+      rigor.fn('resolver_wrong_type', (cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p, ctx, done) => { done(null, 'not-a-number'); });
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, { ok: true, v: r.value }),
+          (e) => cb(null, { ok: false, msg: e.message })
+        );
+      }, rigor.args(rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('resolver_sync', (ctx) => ctx.error == null && ctx.actual === ctx.args[0] * 2),
+      rigor.after('resolver_error', (ctx) => ctx.actual.ok === false && /provider down/.test(ctx.actual.msg)),
+      rigor.after('resolver_wrong_type', (ctx) => ctx.actual.ok === false && /must match declared type 'number'/.test(ctx.actual.msg)),
+    ];
+    await expectPass('resolvers', actions, checks);
+  });
+
+  it('stored-value lifecycle: overwrite wins, cross-measure invalidation is isolated, TTL expires', async () => {
+    const actions = [
+      rigor.fn('overwrite', (a, b) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, a);
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, b); // last-write-wins
+        return dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' }).value;
+      }, rigor.args(rigor.gen.int(0, 100), rigor.gen.int(0, 100))),
+      rigor.fn('cross_measure_invalidate', (a, b) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, a);
+        dvg.setValue('label', { __subject: 't', user: 'u' }, String(b));
+        dvg.vg.invalidate('t', 'budget', { tenant: 't', feature: 'x' });
+        const budget = dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' });
+        const label = dvg.getValue('label', { __subject: 't', user: 'u' });
+        return { budget: budget === null ? 'null' : budget.value, label: label.value };
+      }, rigor.args(rigor.gen.int(0, 100), rigor.gen.int(0, 100))),
+      rigor.fn('ttl_expiry', (value, cb) => {
+        let t = 0;
+        const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'r');
+        const dvg = new DSLValueGraph(rt, {
+          valueGraph: new ValueGraph({ clock: () => t, defaultTTL: 100 })
+        });
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, value);
+        const before = dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' }).value;
+        t = 200;
+        const after = dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' });
+        cb(null, { before, after: after === null ? 'null' : after.value });
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('overwrite', (ctx) => ctx.actual === ctx.args[1]),
+      rigor.after('cross_measure_invalidate', (ctx) => ctx.actual.budget === 'null' && ctx.actual.label === String(ctx.args[1])),
+      rigor.after('ttl_expiry', (ctx) => ctx.actual.before === ctx.args[0] && ctx.actual.after === 'null'),
+    ];
+    await expectPass('lifecycle', actions, checks);
+  });
+
+  it('binding edge cases: array params, extra keys preserved, positional arity, unit/source', async () => {
+    const actions = [
+      rigor.fn('array_param', (arr, cb) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(`measure tags(user: string, xs: array) { } PROVIDES number`, 'r');
+        const dvg = new DSLValueGraph(rt);
+        dvg.setValue('tags', { __subject: 't', user: 'u', xs: arr }, 7);
+        const e = dvg.getValue('tags', { __subject: 't', user: 'u', xs: arr });
+        cb(null, e ? e.value : 'MISSING');
+      }, rigor.args(rigor.gen.array(rigor.gen.int(0, 9), 0, 4), rigor.handler(reducers.first()))),
+      rigor.fn('extra_keys', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x', extra: 'zzz' }, v);
+        return dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x', extra: 'zzz' }).value;
+      }, rigor.args(rigor.gen.int(0, 100))),
+      rigor.fn('positional_arity', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', ['t', 'x'], v);
+        return dvg.getValue('budget', ['t', 'x']).value;
+      }, rigor.args(rigor.gen.int(0, 100))),
+      rigor.fn('unit_preserved', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, v, { unit: 'tokens', source: 'ledger' });
+        const e = dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' });
+        return { value: e.value, unit: e.unit, source: e.source };
+      }, rigor.args(rigor.gen.int(0, 100))),
+    ];
+    const checks = [
+      rigor.after('array_param', (ctx) => ctx.error == null && ctx.actual === 7),
+      rigor.after('extra_keys', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('positional_arity', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('unit_preserved', (ctx) => ctx.actual.value === ctx.args[0] && ctx.actual.unit === 'tokens' && ctx.actual.source === 'ledger'),
+    ];
+    await expectPass('bindings', actions, checks);
+  });
+
+  it('strict:false degrades gracefully for unknown measures; strict mode throws', async () => {
+    const actions = [
+      rigor.fn('strict_false', (cb) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'r');
+        const dvg = new DSLValueGraph(rt, { strict: false });
+        dvg.setValue('nope', {}, 1);        // no-op
+        dvg.resolve('nope', () => 1);       // no-op
+        const g = dvg.getValue('nope', {}); // null
+        dvg.measure('nope', {}).then(
+          (r) => cb(null, { get: g, measure: r.value }),
+          () => cb(null, { get: g, measure: 'rejected' })
+        );
+      }, rigor.args(rigor.handler(reducers.first()))),
+      rigor.fn('no_value_null', () => {
+        const dvg = makeDvg();
+        return dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' }) === null ? 'null' : 'value';
+      }, rigor.args()),
+    ];
+    const checks = [
+      rigor.after('strict_false', (ctx) => ctx.actual.get === null && ctx.actual.measure === null),
+      rigor.after('no_value_null', (ctx) => ctx.actual === 'null'),
+    ];
+    await expectPass('strict', actions, checks);
+  });
+
+  it('concurrent measure retrievals all resolve to the same stored value', async () => {
+    const actions = [
+      rigor.fn('concurrent_measure', (value, cb) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, value);
+        const N = 5;
+        const calls = [];
+        for (let i = 0; i < N; i++) {
+          calls.push(dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then((r) => r.value));
+        }
+        Promise.all(calls).then((values) => cb(null, values), (e) => cb(e));
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('concurrent_measure', (ctx) =>
+        ctx.error == null && Array.isArray(ctx.actual) && ctx.actual.length === 5 && ctx.actual.every((v) => v === ctx.args[0])),
+    ];
+    await expectPass('concurrent', actions, checks);
+  });
+
+  it('stored values and resolvers coexist per subject (stored wins on its own subject)', async () => {
+    const actions = [
+      rigor.fn('subject_resolver_mix', (a, b, cb) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 'A', tenant: 'A', feature: 'x' }, a);
+        dvg.resolve('budget', (s) => b);
+        dvg.measure('budget', { __subject: 'A', tenant: 'A', feature: 'x' }).then(
+          (r1) => dvg.measure('budget', { __subject: 'B', tenant: 'B', feature: 'x' }).then(
+            (r2) => cb(null, { a: r1.value, b: r2.value }),
+            (e) => cb(e)
+          ),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('subject_resolver_mix', (ctx) =>
+        ctx.error == null && ctx.actual.a === ctx.args[0] && ctx.actual.b === ctx.args[1]),
+    ];
+    await expectPass('subject-resolver-mix', actions, checks);
+  });
+
+  it('final confirmation: positional arity enforced, zero-param measures, control keys stripped', async () => {
+    const actions = [
+      rigor.fn('arity_too_many', (v) => {
+        const dvg = makeDvg();
+        try { dvg.setValue('budget', ['t', 'x', 'extra'], v); return { ok: true }; }
+        catch (e) { return { ok: false, msg: e.message }; }
+      }, rigor.args(rigor.gen.int(0, 100))),
+      rigor.fn('arity_too_few', (v) => {
+        const dvg = makeDvg();
+        try { dvg.setValue('budget', ['t'], v); return { ok: true }; }
+        catch (e) { return { ok: false, msg: e.message }; }
+      }, rigor.args(rigor.gen.int(0, 100))),
+      rigor.fn('arity_exact', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', ['t', 'x'], v);
+        return dvg.getValue('budget', ['t', 'x']).value;
+      }, rigor.args(rigor.gen.int(0, 100))),
+      rigor.fn('zero_param_measure', (v) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(`measure heartbeat() { } PROVIDES number`, 'r');
+        const dvg = new DSLValueGraph(rt);
+        dvg.setValue('heartbeat', {}, v);
+        const e = dvg.getValue('heartbeat', {});
+        return e ? e.value : 'MISSING';
+      }, rigor.args(rigor.gen.int(0, 100))),
+      rigor.fn('actor_stripped', (v) => {
+        const dvg = makeDvg();
+        // __actor is a control key → stripped from the cache key, so differing
+        // actors hit the SAME stored entry.
+        dvg.setValue('budget', { __actor: 'actor:1', __subject: 't', tenant: 't', feature: 'x' }, v);
+        return dvg.getValue('budget', { __actor: 'actor:2', __subject: 't', tenant: 't', feature: 'x' }).value;
+      }, rigor.args(rigor.gen.int(0, 100))),
+    ];
+    const checks = [
+      rigor.after('arity_too_many', (ctx) => ctx.actual.ok === false && /expects 2 positional argument\(s\), got 3/.test(ctx.actual.msg)),
+      rigor.after('arity_too_few', (ctx) => ctx.actual.ok === false && /expects 2 positional argument\(s\), got 1/.test(ctx.actual.msg)),
+      rigor.after('arity_exact', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('zero_param_measure', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('actor_stripped', (ctx) => ctx.actual === ctx.args[0]),
+    ];
+    await expectPass('final-confirm', actions, checks);
+  });
+
+  it('hardening: retrieval paths, sync-throw resolvers, unregister, param-driven resolvers, NaN', async () => {
+    const actions = [
+      rigor.fn('get_sync_vs_measure_async', (value, cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p, ctx, done) => { setTimeout(() => done(null, value), 1); });
+        const syncPath = dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' });
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, { sync: syncPath === null ? 'null' : syncPath.value, async: r.value }),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+      rigor.fn('resolver_throws_sync', (cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', () => { throw new Error('boom'); });
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, { ok: true, v: r.value }),
+          (e) => cb(null, { ok: false, msg: e.message })
+        );
+      }, rigor.args(rigor.handler(reducers.first()))),
+      rigor.fn('unregister_after_attach', (cb) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'r');
+        const dvg = new DSLValueGraph(rt);
+        dvg.attach();
+        rt.unregisterMeasure('budget');
+        rt.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, { ok: true, v: r.value }),
+          (e) => cb(null, { ok: false, msg: e.message })
+        );
+      }, rigor.args(rigor.handler(reducers.first()))),
+      rigor.fn('resolver_from_params', (x, y, cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p, ctx, done) => done(null, p.feature === 'a' ? x : y));
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'a' }).then(
+          (r1) => dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'b' }).then(
+            (r2) => cb(null, { a: r1.value, b: r2.value }),
+            (e) => cb(e)
+          ),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+      rigor.fn('nan_rejected', () => {
+        const dvg = makeDvg();
+        try { dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, Number.NaN); return { ok: true }; }
+        catch (e) { return { ok: false, msg: e.message }; }
+      }, rigor.args()),
+    ];
+    const checks = [
+      rigor.after('get_sync_vs_measure_async', (ctx) =>
+        ctx.error == null && ctx.actual.sync === 'null' && ctx.actual.async === ctx.args[0]),
+      rigor.after('resolver_throws_sync', (ctx) => ctx.actual.ok === false && /boom/.test(ctx.actual.msg)),
+      rigor.after('unregister_after_attach', (ctx) => ctx.actual.ok === false && /no provider registered/.test(ctx.actual.msg)),
+      rigor.after('resolver_from_params', (ctx) =>
+        ctx.error == null && ctx.actual.a === ctx.args[0] && ctx.actual.b === ctx.args[1]),
+      rigor.after('nan_rejected', (ctx) => ctx.actual.ok === false && /must match declared type 'number'/.test(ctx.actual.msg)),
+    ];
+    await expectPass('hardening', actions, checks);
+  });
+});

tests/rigor/dsl-value-graph.test.js

@@ -0,0 +1,226 @@
+/**
+ * tests/rigor/dsl-value-graph.test.js — js-rigor deep tests for the
+ * DSLValueGraph integration (evidence DSL declares the value-graph's typing;
+ * measures retrieve through the graph; attributes are stored directly).
+ *
+ * Covers, as property campaigns:
+ *   - setValue/getValue round-trips across every declared value type
+ *   - type enforcement (wrong-typed writes always reject)
+ *   - parameter-binding validation (wrong-typed params always reject)
+ *   - subject scoping (different subjects never share entries)
+ *   - attach() parity (runtime.measure === value-graph retrieval)
+ *   - external resolvers compute, and a stored value wins over the resolver
+ *   - invalidation clears a stored value (next retrieval → null)
+ *   - schema derivation from generated measure declarations
+ *   - multi-measure independence
+ */
+import { describe, it } from 'node:test';
+import { rigor, reducers } from '@rigor/core';
+import { Arbiter } from '@arbiter/core';
+import { DSLRuntime, DSLValueGraph } from '../../src/index.js';
+
+const DSL = `
+  definition Tenant { id: string }
+  measure budget(tenant: Tenant, feature: string) { } PROVIDES number
+  measure label(user: string) { } PROVIDES string
+  measure active(user: string) { } PROVIDES boolean
+  measure tags(user: string) { } PROVIDES array
+`;
+
+function makeDvg() {
+  const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'vg-rigor');
+  return new DSLValueGraph(rt);
+}
+
+async function expectPass(name, actions, checks, config = {}) {
+  const report = await rigor.campaign(actions, rigor.crucible(checks))
+    .run({ seed: `dsl-vg-${name}`, effort: 120, artifacts: { dir: '', persist: 'never' }, ...config });
+  if (report.status !== 'passed') {
+    const detail = (report.failures || []).slice(0, 5)
+      .map((f) => JSON.stringify({ action: f.actionName || f.action, inv: f.name, args: f.args, msg: f.message }));
+    throw new Error(`campaign '${name}' failed.\n${detail.join('\n')}`);
+  }
+  return report;
+}
+
+describe('DSLValueGraph integration (rigor)', () => {
+  it('setValue/getValue round-trips every declared value type', async () => {
+    const actions = [
+      rigor.fn('rt_number', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, v);
+        const e = dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' });
+        return e ? e.value : 'MISSING';
+      }, rigor.args(rigor.gen.int(-100000, 100000))),
+      rigor.fn('rt_string', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('label', { __subject: 't', user: 'u' }, v);
+        const e = dvg.getValue('label', { __subject: 't', user: 'u' });
+        return e ? e.value : 'MISSING';
+      }, rigor.args(rigor.gen.asciiString())),
+      rigor.fn('rt_bool', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('active', { __subject: 't', user: 'u' }, v);
+        const e = dvg.getValue('active', { __subject: 't', user: 'u' });
+        return e ? e.value : 'MISSING';
+      }, rigor.args(rigor.gen.boolean())),
+      rigor.fn('rt_array', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('tags', { __subject: 't', user: 'u' }, v);
+        const e = dvg.getValue('tags', { __subject: 't', user: 'u' });
+        return e ? e.value : null;
+      }, rigor.args(rigor.gen.array(rigor.gen.string(), 0, 5))),
+    ];
+    const checks = [
+      rigor.after('rt_number', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('rt_string', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('rt_bool', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('rt_array', (ctx) => JSON.stringify(ctx.actual) === JSON.stringify(ctx.args[0])),
+    ];
+    await expectPass('roundtrip', actions, checks, { effort: 200 });
+  });
+
+  it('type enforcement: wrong-typed writes always reject, right-typed always pass', async () => {
+    const actions = [
+      rigor.fn('type_ok', (v) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, v);
+        return dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' }).value;
+      }, rigor.args(rigor.gen.int(-100, 100))),
+      rigor.fn('type_reject', (v) => {
+        const dvg = makeDvg();
+        try { dvg.setValue('label', { user: 'u' }, v); return { ok: true }; }
+        catch (e) { return { ok: false, msg: e.message }; }
+      }, rigor.args(rigor.gen.oneOf([rigor.gen.int(0, 100), rigor.gen.boolean(), rigor.gen.array(rigor.gen.int(0, 9), 1, 3)]))),
+      rigor.fn('param_reject', (v) => {
+        const dvg = makeDvg();
+        try { dvg.setValue('budget', { tenant: 't', feature: v }, 1); return { ok: true }; }
+        catch (e) { return { ok: false, msg: e.message }; }
+      }, rigor.args(rigor.gen.oneOf([rigor.gen.constant(42), rigor.gen.boolean(), rigor.gen.array(rigor.gen.int(0, 9), 1, 2)]))),
+    ];
+    const checks = [
+      rigor.after('type_ok', (ctx) => ctx.actual === ctx.args[0]),
+      rigor.after('type_reject', (ctx) => ctx.actual.ok === false && /must match declared type 'string'/.test(ctx.actual.msg)),
+      rigor.after('param_reject', (ctx) => ctx.actual.ok === false && /parameter 'feature'/.test(ctx.actual.msg)),
+    ];
+    await expectPass('typecheck', actions, checks, { effort: 200 });
+  });
+
+  it('subjects never share entries', async () => {
+    const actions = [
+      rigor.fn('subject_isolation', (a, b) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 'A', tenant: 'A', feature: 'x' }, a);
+        dvg.setValue('budget', { __subject: 'B', tenant: 'B', feature: 'x' }, b);
+        const ea = dvg.getValue('budget', { __subject: 'A', tenant: 'A', feature: 'x' });
+        const eb = dvg.getValue('budget', { __subject: 'B', tenant: 'B', feature: 'x' });
+        return { a: ea ? ea.value : null, b: eb ? eb.value : null };
+      }, rigor.args(rigor.gen.int(-50, 50), rigor.gen.int(-50, 50))),
+    ];
+    const checks = [
+      rigor.after('subject_isolation', (ctx) => ctx.actual.a === ctx.args[0] && ctx.actual.b === ctx.args[1]),
+    ];
+    await expectPass('subjects', actions, checks, { effort: 120 });
+  });
+
+  it('attach() makes runtime.measure retrieve through the value-graph', async () => {
+    const actions = [
+      rigor.fn('attach_parity', (value, cb) => {
+        const rt = new DSLRuntime(new Arbiter()).compile(DSL, 'vg-rigor');
+        const dvg = new DSLValueGraph(rt);
+        dvg.attach();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, value);
+        rt.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, r.value),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('attach_parity', (ctx) => ctx.error == null && ctx.actual === ctx.args[0]),
+    ];
+    await expectPass('attach', actions, checks, { effort: 120 });
+  });
+
+  it('external resolvers compute; a stored value wins over the resolver', async () => {
+    const actions = [
+      rigor.fn('resolver_compute', (value, cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p, ctx, done) => done(null, { value, unit: 'tokens', source: 'resolver' }));
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, { value: r.value, source: r.source }),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+      rigor.fn('stored_wins', (value, cb) => {
+        const dvg = makeDvg();
+        dvg.resolve('budget', (s, p, ctx, done) => done(null, 999));
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, value);
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, r.value),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('resolver_compute', (ctx) => ctx.error == null && ctx.actual.value === ctx.args[0] && ctx.actual.source === 'resolver'),
+      rigor.after('stored_wins', (ctx) => ctx.error == null && ctx.actual === ctx.args[0]),
+    ];
+    await expectPass('resolvers', actions, checks, { effort: 120 });
+  });
+
+  it('invalidation clears a stored value; the next retrieval is null', async () => {
+    const actions = [
+      rigor.fn('invalidate_clears', (value, cb) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, value);
+        dvg.vg.invalidate('t', 'budget', { tenant: 't', feature: 'x' });
+        dvg.measure('budget', { __subject: 't', tenant: 't', feature: 'x' }).then(
+          (r) => cb(null, r.value),
+          (e) => cb(e)
+        );
+      }, rigor.args(rigor.gen.int(0, 100), rigor.handler(reducers.first()))),
+    ];
+    const checks = [
+      rigor.after('invalidate_clears', (ctx) => ctx.error == null && ctx.actual === null),
+    ];
+    await expectPass('invalidate', actions, checks, { effort: 120 });
+  });
+
+  it('schema derivation: every generated measure gets its declared returnType and params', async () => {
+    const actions = [
+      rigor.fn('schema_ok', (name, type) => {
+        const dsl = `definition T { id: string } measure ${name}(p: T) { } PROVIDES ${type}`;
+        const rt = new DSLRuntime(new Arbiter()).compile(dsl, 'gen');
+        const dvg = new DSLValueGraph(rt);
+        const spec = dvg.schema()[name];
+        return { returnType: spec && spec.returnType, params: spec ? spec.params.map((x) => x.name) : null };
+      }, rigor.args(
+        rigor.gen.oneOf(['balance', 'rate', 'quota', 'volume', 'meter']),
+        rigor.gen.oneOf(['number', 'string', 'boolean', 'array'])
+      )),
+    ];
+    const checks = [
+      rigor.after('schema_ok', (ctx) => ctx.actual.returnType === ctx.args[1] && JSON.stringify(ctx.actual.params) === JSON.stringify(['p'])),
+    ];
+    await expectPass('schema', actions, checks, { effort: 120 });
+  });
+
+  it('measures are independent (no cross-measure cache sharing)', async () => {
+    const actions = [
+      rigor.fn('multi_measure', (a, b) => {
+        const dvg = makeDvg();
+        dvg.setValue('budget', { __subject: 't', tenant: 't', feature: 'x' }, a);
+        dvg.setValue('label', { __subject: 't', user: 'u' }, String(b));
+        return {
+          budget: dvg.getValue('budget', { __subject: 't', tenant: 't', feature: 'x' }).value,
+          label: dvg.getValue('label', { __subject: 't', user: 'u' }).value
+        };
+      }, rigor.args(rigor.gen.int(0, 100), rigor.gen.int(0, 100))),
+    ];
+    const checks = [
+      rigor.after('multi_measure', (ctx) => ctx.actual.budget === ctx.args[0] && ctx.actual.label === String(ctx.args[1])),
+    ];
+    await expectPass('independence', actions, checks, { effort: 120 });
+  });
+});