agent-receipt-verify 0.2.3 → 0.2.5

package/README.md

@@ -77,11 +77,23 @@ vectors, that is interop. One implementation agreeing with itself proves nothing
 | x402 settlement link (§5.6.4, same proposal) | own tests plus three live settlements | 22 offline, 3 live | yes, each resolves to its own settlement |
 
 ```sh
-npm test      # all of the above, no network, no keys
+npm test      # all of the above. No account, no key, and nobody else's server
 ```
 
-Node built-ins only, apart from keccak256. Only the settlement link below touches
-the network, and then only a public read-only RPC.
+Node built-ins only, apart from keccak256. Two honest footnotes, because "no network"
+was not quite true and is the kind of claim this package should not make loosely:
+
+- One case dials a closed port on localhost on purpose, to prove that a dead address
+  reports not-measured instead of crashing the tool. That is a socket, but it leaves
+  the machine alone and reaches no third party.
+- Until recently the suite also fetched a live discovery index belonging to someone
+  else, roughly twenty thousand entries, because one test handed an unknown flag to
+  `census` and `census` ignored unknown flags and went to work. That flag is now
+  refused, so the suite finishes in about eleven seconds and contacts nobody. A single
+  index round alone used to take over thirty.
+
+Only the settlement link below reaches a real network, and then only a public,
+read-only RPC.
 
 Confirmed from the other side, which matters more than the table: the author of
 the x402 specification ran their own implementation, which shares no code with
@@ -98,6 +110,7 @@ taken on trust:
 ```sh
 npx -y agent-receipt-verify kanon
 npx -y agent-receipt-verify beleid
+npx -y agent-receipt-verify link-vectors
 ```
 
 The first checks our EIP-3009 verifier against the ten published vectors of
@@ -107,6 +120,28 @@ about one nonce reused across two payers. Those are the two open questions in
 [x402#2725](https://github.com/x402-foundation/x402/issues/2725), and the command
 prints exactly where the two possible answers diverge and where they do not.
 
+The third runs twelve vectors for the half AFTER paying: does this receipt belong to
+that one settlement. Eleven of them need no network at all; the twelfth reads the chain
+and is marked and skipped rather than reported as a failure, because a check that could
+not run says nothing about the receipt. The same twelve also exist in the field layout
+of the Kanon vectors, in `vectors/settlement-link-kanon`, so the two corpora can sit
+side by side.
+
+Two more commands, both of which measure other people's endpoints rather than our own,
+and both read-only:
+
+```sh
+npx -y agent-receipt-verify census [out.json]
+npx -y agent-receipt-verify liveness [out.json]
+```
+
+`census` counts a discovery index per HOST rather than per resource, so a party with
+three hundred paths does not outweigh three hundred parties with one. `liveness` takes
+that census and asks each host whether it still answers 402 today, because a
+registration in an index is not a promise that the endpoint is alive. Both are slow by
+design: they pause between requests, because the hosts in that list did not ask to be
+measured.
+
 ## Linking a receipt to its settlement
 
 A receipt with an empty `transaction` field can be matched to a payment only by

package/bin/cli.mjs

@@ -9,7 +9,7 @@
 // BEWUST GEEN NPM-PUBLICATIE NODIG. npx kan een pakket rechtstreeks uit een git-repo
 // draaien, dus dit werkt zonder dat er iets op npm staat:
 //
-//   npx github:holistis/agent-receipt-verify https://een-eindpunt.example/pad
+//   npx -y agent-receipt-verify https://een-eindpunt.example/pad
 //
 // Dat is geen trucje maar een echte eigenschap van npx, en het haalt een hele
 // publicatie-stap plus een naamclaim weg. Het betekent ook dat niemand een
@@ -23,45 +23,61 @@
 const args = process.argv.slice(2)
 const eerste = args[0]
 
+// De helptekst is ENGELS, en dat is geen voorkeur maar een gemeten noodzaak. Koud
+// gedraaid vanuit een lege map op 18 oktober 2026 bleek het eerste scherm dat een vreemde
+// ziet half Nederlands, terwijl iedereen die dit gereedschap in de x402- en
+// erc-8004-draden gaat draaien Engels schrijft. Het meetresultaat zelf was al Engels, dus
+// alleen de ingang stond nog in de weg. En de regel over wat dit NIET meet stond midden
+// in de lijst in plaats van eronder, waar een lezer hem pas leest nadat hij weet wat het
+// wel doet.
 function gebruik() {
-  console.log('agent-receipt-verify, een onafhankelijke controle op bonnetjes van agent-betalingen')
+  console.log('agent-receipt-verify, an independent check on receipts for agent payments')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify <url> [url ...]')
-  console.log('        meet een x402-eindpunt tegen de ladder in CONFORMANCE.md (trede 0 tot 2,')
-  console.log('        zonder te betalen). Trede 3 tot 5 vereisen een echte afrekening en komen')
-  console.log('        terug als ONGEMETEN, nooit als afgekeurd.')
+  console.log('  npx -y agent-receipt-verify <url> [url ...]')
+  console.log('        measures an x402 endpoint against the ladder in CONFORMANCE.md (levels 0')
+  console.log('        to 2, without paying). Levels 3 to 5 need a real settlement and come back')
+  console.log('        as NOT MEASURED, never as a failure.')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify census [uit.json]')
-  console.log('        telt een discovery-index per host in plaats van per resource.')
+  console.log('  npx -y agent-receipt-verify census [out.json]')
+  console.log('        counts a discovery index per host instead of per resource.')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify link --receipt=<bestand>')
-  console.log('        zoekt bij een bonnetje van versie 2 de bijbehorende afrekening op de keten.')
+  console.log('  npx -y agent-receipt-verify link --receipt=<file>')
+  console.log('        for a version 2 receipt, finds the settlement it belongs to on chain.')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify mcp')
-  console.log('        draait als MCP-server over stdio, zodat een agent deze controle AANROEPT')
-  console.log('        in plaats van hem aanbevolen te krijgen. Twee gereedschappen: controleer een')
-  console.log('        eindpunt voor je betaalt, en link een bonnetje aan een echte afrekening.')
+  console.log('  npx -y agent-receipt-verify mcp')
+  console.log('        runs as an MCP server over stdio, so an agent CALLS this check instead of')
+  console.log('        being advised to run it. Two tools: check an endpoint before you pay, and')
+  console.log('        link a receipt to a real settlement.')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify inam <vectors.json>')
-  console.log('        controleert countersigned bonnetjes tegen gepubliceerde vectoren.')
+  console.log('  npx -y agent-receipt-verify inam <vectors.json>')
+  console.log('        checks countersigned receipts against published vectors.')
   console.log('')
-  console.log('Wat dit NIET doet: het oordeelt over de VORM van een bonnetje, niet over de')
-  console.log('eerlijkheid van de partij die het afgaf. Zie CONFORMANCE.md voor wat met opzet')
-  console.log('niet gemeten wordt.')
-  console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify kanon')
+  console.log('  npx -y agent-receipt-verify kanon')
   console.log('        cross-check our independent EIP-3009 verifier against the ten published')
   console.log('        vectors of iamonuwa/kanon, offline, no account and no key.')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify beleid')
+  console.log('  npx -y agent-receipt-verify beleid')
   console.log('        the same ten vectors under both amount policies, plus the two cases no')
   console.log('        published vector covers: overpayment, and one nonce across two payers.')
   console.log('        Those two are the open questions in x402 issue 2725.')
   console.log('')
-  console.log('  npx github:holistis/agent-receipt-verify link-vectors')
+  console.log('  npx -y agent-receipt-verify liveness [out.json]')
+  console.log('        takes the census and asks each host whether it still answers 402 today.')
+  console.log('        A registration in an index is not a promise that the endpoint is alive.')
+  console.log('')
+  console.log('  npx -y agent-receipt-verify verify-delivery --answer=<file> --endpoint=<url>')
+  console.log('        reads, at the source, whether a paid answer is TRUE. The location is')
+  console.log('        DERIVED from --endpoint and never taken from the answer, because a seller')
+  console.log('        who picks both the token and the place can stage any outcome.')
+  console.log('')
+  console.log('  npx -y agent-receipt-verify link-vectors')
   console.log('        twelve vectors for the half AFTER paying: does this receipt belong to')
   console.log('        that one settlement? Eleven run offline, the chain-reading one is')
   console.log('        marked and skipped rather than failed.')
+  console.log('')
+  console.log('What this does NOT do: it judges the SHAPE of a receipt, not the honesty of')
+  console.log('the party that issued it. See CONFORMANCE.md for what is deliberately left')
+  console.log('unmeasured.')
 }
 
 // Het argument bepaalt welke module draait. De modules zijn ook los te draaien en te
@@ -76,6 +92,7 @@ const onderdelen = {
   kanon: '../src/eip3009-autorisatie.mjs',
   beleid: '../bench/eip3009-beleid.mjs',
   'link-vectors': '../src/settlement-link-vectors.mjs',
+  'verify-delivery': '../src/verify-delivery.mjs',
 }
 
 if (!eerste || eerste === '--help' || eerste === '-h' || eerste === 'help') {
@@ -94,7 +111,7 @@ if (!eerste || eerste === '--help' || eerste === '-h' || eerste === 'help') {
   process.argv = [process.argv[0], pad, ...args]
   await import('../src/x402-conformance-check.mjs')
 } else {
-  console.log('onbekend: ' + eerste)
+  console.log('unknown command: ' + eerste)
   console.log('')
   gebruik()
   process.exitCode = 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-receipt-verify",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Checks x402 endpoint conformance before an agent pays, and links the receipt to its settlement.",
   "license": "Apache-2.0",
   "type": "module",
@@ -8,7 +8,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node test/interop.mjs && node test/canonical.mjs && node test/link-onchain.mjs && node test/profiel.mjs && node test/eip3009.mjs && node test/conformance.mjs && node test/jws-offer.mjs && node test/census.mjs && node test/poortwachters.mjs && node test/metingen-bundel.mjs && node test/mcp-server.mjs && node test/cli.mjs && node test/bundel.mjs && node test/settlement-link-vectors.mjs",
+    "test": "node test/interop.mjs && node test/canonical.mjs && node test/link-onchain.mjs && node test/profiel.mjs && node test/eip3009.mjs && node test/conformance.mjs && node test/jws-offer.mjs && node test/census.mjs && node test/poortwachters.mjs && node test/metingen-bundel.mjs && node test/mcp-server.mjs && node test/cli.mjs && node test/bundel.mjs && node test/settlement-link-vectors.mjs && node test/naar-kanon-vorm.mjs && node test/verify-delivery.mjs && node test/acceptance-binding.mjs",
     "link-example": "node src/x402-link-onchain.mjs --receipt=examples/receipt-live-base-sepolia.json && node src/x402-link-onchain.mjs --receipt=examples/receipt-live-base-sepolia-2.json && node src/x402-link-onchain.mjs --receipt=examples/receipt-live-base-sepolia-3.json",
     "conformance": "node src/x402-conformance-check.mjs",
     "bench": "node bench/robustness.mjs",
@@ -20,7 +20,9 @@
     "bundel": "node tools/bundel-bouw.mjs build/bundle",
     "kanon": "node src/eip3009-autorisatie.mjs --vectoren",
     "bench-eip3009": "node bench/eip3009-beleid.mjs",
-    "link-vectors": "node src/settlement-link-vectors.mjs"
+    "link-vectors": "node src/settlement-link-vectors.mjs",
+    "verify-delivery": "node src/verify-delivery.mjs",
+    "kanon-vorm": "node tools/naar-kanon-vorm.mjs"
   },
   "optionalDependencies": {
     "ethers": "^6.17.0"

package/src/acceptance-binding.mjs

@@ -0,0 +1,309 @@
+// Koppelt laag 3 aan laag 4: hoort dit acceptatierecord bij dit bonnetje.
+//
+// WAAROM DIT EEN EIGEN BESTAND IS EN NIET BIJ DE SETTLEMENT-LINK HOORT. De
+// settlement-link-vectoren beantwoorden een andere vraag: opent de gezouten belofte in
+// een bonnetje op precies een afrekening op de keten. Dat is betaalbewijs. Een
+// acceptatierecord beantwoordt iets anders: heeft een onafhankelijke partij het geleverde
+// bestand getoetst aan criteria die al vastlagen. Een uitgever die beide door elkaar
+// haalt levert een lezer een vlaggetje "onderbouwd" waarvan niemand meer kan zien welke
+// van de twee vragen nu eigenlijk beantwoord is. Daarom twee sets, twee uitkomsten.
+//
+// WAT HIER WEL GEMETEN WORDT. Uitsluitend de BINDING. Noemen het bonnetje en het
+// acceptatierecord hetzelfde opgeleverde bestand, dezelfde machtiging en dezelfde belofte,
+// en lagen de criteria vast voordat er getoetst werd.
+//
+// WAT HIER MET OPZET NIET GEMETEN WORDT, en dat is geen tekortkoming maar de grens van
+// deze laag. Wij toetsen de handtekening van het acceptatierecord NIET, en wij
+// beoordelen zijn criteria NIET. Dat is het werk van de controleur die het record
+// uitgaf, met zijn eigen sleutel en zijn eigen verifieerder. Wie hier een groen antwoord
+// krijgt weet dus dat de twee bewijsstukken over hetzelfde gaan, en niet dat het
+// acceptatierecord zelf klopt. Die twee door elkaar halen is precies de fout die deze
+// module bestaat om te voorkomen.
+//
+// GEMETEN OP EEN ECHT RECORD, 18 oktober 2026, en dat veranderde deze module wezenlijk.
+// De uitgever publiceerde een live record (invinoveritas, trilatic.acceptance-receipt/1.2).
+// Daaruit bleek dat onze eerste aannames over de VORM niet klopten:
+//
+//  1. De hash van het bonnetje staat BOVENIN de sidecar, naast `bindings`, niet erin.
+//  2. De hash van het opgeleverde bestand staat in het ONDERTEKENDE record, op
+//     `record.receipt.files.remediated.sha256`, en helemaal niet in de sidecar.
+//  3. De partijen staan genest in `record.receipt.parties`, met een `key_id` dat leeg
+//     kan zijn, en niet als twee platte tekstvelden.
+//  4. Het tijdstip van de toets heet `issued_utc`, niet `checked_at`.
+//  5. De x402-velden zijn TWEE aparte sleutels, en dat is met opzet zo: een belofte mag
+//     nooit met een nonce vergeleken worden. `x402_receipt_commitment` hoort bij
+//     `authorizationCommitment`, `x402_authorization_nonce` bij `authorizationNonce`.
+//
+// Daarom leest deze module nu de ECHTE vorm, met de vlakke vorm uit onze eerste
+// vectoren als tweede mogelijkheid. Een module die alleen zijn eigen verzonnen vorm
+// aankan, toetst niets in de wereld.
+//
+// EEN AANNAME DIE WEG IS. Onze eerste versie nam aan dat een machtiging in de sidecar
+// gelijk zou zijn aan de nonce in het bonnetje, en las daarvoor ook een generiek veld
+// `authorization`. Dat generieke veld is nu bewust GESCHRAPT. De uitgever splitste de
+// sleutels juist om te voorkomen dat een belofte met een nonce vergeleken wordt, en een
+// generieke terugval zou die bescherming meteen weer weggooien.
+
+const HEX32 = /^[0-9a-f]{64}$/
+
+const genormaliseerdeHash = (w) => {
+  if (typeof w !== 'string') return null
+  const kaal = w.trim().toLowerCase().replace(/^0x/, '')
+  return HEX32.test(kaal) ? kaal : null
+}
+
+const gelijkeHash = (a, b) => {
+  const x = genormaliseerdeHash(a)
+  const y = genormaliseerdeHash(b)
+  return x !== null && y !== null && x === y
+}
+
+const tijdstip = (w) => {
+  if (typeof w === 'number' && Number.isFinite(w)) return w
+  if (typeof w !== 'string' || !w.trim()) return null
+  const ms = Date.parse(w)
+  return Number.isFinite(ms) ? ms / 1000 : null
+}
+
+const tekst = (w) => (typeof w === 'string' && w.trim() ? w.trim().toLowerCase() : null)
+
+/**
+ * Normaliseert zowel het ECHTE record als de vlakke vorm uit onze eerste vectoren naar
+ * de velden die deze module vergelijkt. Een veld dat niet te vinden is wordt null, nooit
+ * een gok, want een gegokt veld levert een oordeel op dat niemand kan narekenen.
+ *
+ * De `naamruimte` bij elke partij is er met opzet: een key_id en een weergavenaam zijn
+ * twee verschillende soorten namen, en die mag je niet met elkaar vergelijken. Zie
+ * onafhankelijkheid() voor waarom dat hier het verschil maakt tussen een hard oordeel en
+ * een onmeetbaar geval.
+ */
+export function leesRecord(doc) {
+  const d = doc && typeof doc === 'object' ? doc : {}
+  const echt = d.record?.receipt ?? null
+  const acceptance = d.acceptance ?? null
+  const sidecar = d.bindings_sidecar ?? d.sidecar ?? null
+
+  const partij = (knoop, plat) => {
+    if (knoop && typeof knoop === 'object') {
+      if (tekst(knoop.key_id)) return { id: tekst(knoop.key_id), naamruimte: 'key_id' }
+      if (tekst(knoop.name)) return { id: tekst(knoop.name), naamruimte: 'name' }
+      return { id: null, naamruimte: null }
+    }
+    return { id: tekst(plat), naamruimte: tekst(plat) ? 'plat' : null }
+  }
+
+  return {
+    // De hash van het opgeleverde bestand, zoals het ONDERTEKENDE record hem noemt.
+    acceptatieLevering:
+      echt?.files?.remediated?.sha256 ?? acceptance?.deliverable_sha256 ?? d.deliverable_sha256 ?? null,
+    // De hash van het bonnetje, bovenin de sidecar.
+    sidecarBonHash: sidecar?.receipt_sha256 ?? d.bindings?.receipt_sha256 ?? null,
+    // De x402-sleutels, in het subobject dat daarvoor bedoeld is.
+    sidecarBindings: sidecar?.bindings ?? d.bindings ?? {},
+    // De vlakke vorm uit onze eerste vectoren noemde de levering ook in de sidecar. Die
+    // staat in een echt record NIET in de sidecar, dus dit is puur terugwaartse steun.
+    sidecarLevering: d.bindings?.deliverable_sha256 ?? sidecar?.deliverable_sha256 ?? null,
+    controleur: partij(echt?.parties?.checker, acceptance?.checker ?? d.checker),
+    producent: partij(echt?.parties?.producer, acceptance?.producer ?? d.producer),
+    onafhankelijkheidVerklaard: tekst(echt?.independence ?? acceptance?.independence ?? null),
+    criteriaVastgelegd:
+      echt?.criteria?.committed_at ?? acceptance?.criteria_committed_at ?? d.criteria_committed_at ?? null,
+    getoetstOp: echt?.issued_utc ?? acceptance?.checked_at ?? d.checked_at ?? null,
+    schema: echt?.schema ?? acceptance?.format ?? null,
+  }
+}
+
+export const ONAFHANKELIJKHEID = [
+  'VERIFIEERBAAR_ONAFHANKELIJK',
+  'NIET_ONAFHANKELIJK',
+  'ZELFVERKLAARD_ONVERIFIEERBAAR',
+  'ONBEKEND',
+]
+
+/**
+ * Kan een DERDE narekenen dat de controleur niet de producent is?
+ *
+ * Dit is bewust een drieweg en geen ja of nee, en daar zit de hele waarde. Het live
+ * record van 18 oktober 2026 zegt `independence: "independent"` terwijl
+ * `parties.producer.key_id` LEEG is. Er is dus niets om de controleur tegen af te zetten:
+ * de onafhankelijkheid is door de uitgever zelf verklaard en door niemand anders na te
+ * rekenen. Dat is geen afkeuring en geen goedkeuring, het is onmeetbaar, en precies dat
+ * onderscheid gaat verloren in een boolean.
+ *
+ * Even belangrijk: een key_id vergelijken met een weergavenaam is GEEN vergelijking. Dat
+ * zijn twee verschillende soorten namen, en "ze zijn verschillend dus onafhankelijk" zou
+ * dan een conclusie zijn die uit het formaat komt en niet uit de werkelijkheid.
+ */
+export function onafhankelijkheid(doc) {
+  const r = leesRecord(doc)
+  const c = r.controleur
+  const p = r.producent
+  if (c.id === null && p.id === null) {
+    return { staat: 'ONBEKEND', reden: 'geen van beide partijen is benoemd', vergelekenOp: null }
+  }
+  if (c.id === null || p.id === null) {
+    return {
+      staat: r.onafhankelijkheidVerklaard === 'independent' ? 'ZELFVERKLAARD_ONVERIFIEERBAAR' : 'ONBEKEND',
+      reden:
+        'een van beide partijen heeft geen identiteit in het record, dus een derde kan niet narekenen ' +
+        'of de controleur en de producent dezelfde partij zijn',
+      vergelekenOp: null,
+    }
+  }
+  if (c.naamruimte !== p.naamruimte) {
+    return {
+      staat: r.onafhankelijkheidVerklaard === 'independent' ? 'ZELFVERKLAARD_ONVERIFIEERBAAR' : 'ONBEKEND',
+      reden:
+        `de partijen zijn in verschillende soorten namen vastgelegd (${c.naamruimte} tegen ${p.naamruimte}), ` +
+        'en die mag je niet met elkaar vergelijken',
+      vergelekenOp: null,
+    }
+  }
+  if (c.id === p.id) {
+    return { staat: 'NIET_ONAFHANKELIJK', reden: 'de controleur en de producent zijn dezelfde partij', vergelekenOp: c.naamruimte }
+  }
+  return { staat: 'VERIFIEERBAAR_ONAFHANKELIJK', reden: null, vergelekenOp: c.naamruimte }
+}
+
+// Is er genoeg om uberhaupt een oordeel te vellen? Ontbreekt er iets aan ONZE kant van de
+// vergelijking, dan is het antwoord NOT_MEASURED en nooit NOT_LINKED. Een ontbrekend veld
+// als "niet gekoppeld" lezen zou een ongemeten geval als een afkeuring laten tellen.
+export function bindingMeetbaar(doc) {
+  const r = leesRecord(doc)
+  const mist = []
+  if (genormaliseerdeHash(r.sidecarBonHash) === null) mist.push('sidecar.receipt_sha256')
+  if (genormaliseerdeHash(r.acceptatieLevering) === null) mist.push('record.receipt.files.remediated.sha256')
+  return mist.length ? { meetbaar: false, mist } : { meetbaar: true, mist: [] }
+}
+
+// De twee voorwaarden van de uitgever zelf (trilatic.acceptance-receipt/1.2): een record
+// telt alleen als de controleur niet de producent is, en als de criteria vastlagen
+// voordat er getoetst werd. Ze staan hier in code omdat een voorwaarde die alleen in
+// proza staat bij de eerste drukke dag wordt overgeslagen.
+//
+// De uitkomst is drieledig, want "ik kan het niet nagaan" is iets anders dan "het is
+// mis". Dat onderscheid is dezelfde correctie die de Kanon-auteur op 17 oktober 2026
+// overnam voor zijn eigen controleur.
+export function recordTelt(doc) {
+  const r = leesRecord(doc)
+  const o = onafhankelijkheid(doc)
+  if (o.staat === 'NIET_ONAFHANKELIJK') return { telt: false, meetbaar: true, reden: 'CHECKER_IS_PRODUCER' }
+  if (o.staat !== 'VERIFIEERBAAR_ONAFHANKELIJK') {
+    return { telt: false, meetbaar: false, reden: 'INDEPENDENCE_NOT_VERIFIABLE', toelichting: o.reden }
+  }
+  const vastgelegd = tijdstip(r.criteriaVastgelegd)
+  const getoetst = tijdstip(r.getoetstOp)
+  if (vastgelegd === null || getoetst === null) {
+    return { telt: false, meetbaar: false, reden: 'CRITERIA_TIMING_UNKNOWN' }
+  }
+  if (!(vastgelegd < getoetst)) {
+    return { telt: false, meetbaar: true, reden: 'CRITERIA_NOT_COMMITTED_FIRST' }
+  }
+  return { telt: true, meetbaar: true, reden: null }
+}
+
+/**
+ * Het eigenlijke oordeel. Drie uitkomsten, nooit twee: gekoppeld, niet gekoppeld, of
+ * niet te meten.
+ *
+ * `receiptSha256` en het bonnetje zelf komen van de AANROEPER, want dat is de kant die
+ * hij in handen heeft. Alles aan de record-kant wordt uit het document gelezen.
+ */
+export function koppelAcceptatie({ receipt, acceptance, bindings, sidecar, doc, receiptSha256, deliverableSha256 }) {
+  // Een aanroeper mag het hele document meegeven, of de losse stukken zoals onze eerste
+  // vectoren dat deden. Beide komen hier op dezelfde genormaliseerde vorm uit.
+  const document = doc ?? {
+    record: acceptance?.record ? acceptance.record : undefined,
+    acceptance,
+    bindings,
+    bindings_sidecar: sidecar,
+  }
+  const r = leesRecord(document)
+
+  const m = bindingMeetbaar(document)
+  if (!m.meetbaar) {
+    return { valid: false, measurable: false, reason_code: 'NOT_MEASURED', missing: m.mist, independence: onafhankelijkheid(document).staat }
+  }
+
+  const telt = recordTelt(document)
+  if (!telt.telt) {
+    return telt.meetbaar
+      ? { valid: false, measurable: true, reason_code: 'NOT_LINKED', detail: telt.reden, independence: onafhankelijkheid(document).staat }
+      : {
+          valid: false,
+          measurable: false,
+          reason_code: 'NOT_MEASURED',
+          missing: [telt.reden],
+          detail: telt.toelichting ?? null,
+          independence: onafhankelijkheid(document).staat,
+        }
+  }
+
+  // Noemt de sidecar het bonnetje dat wij in handen hebben? Zonder een meegegeven hash van
+  // ons eigen bonnetje kan die helft niet getoetst worden, en dan is het niet gemeten.
+  if (receiptSha256 !== undefined) {
+    if (genormaliseerdeHash(receiptSha256) === null) {
+      return { valid: false, measurable: false, reason_code: 'NOT_MEASURED', missing: ['receiptSha256'] }
+    }
+    if (!gelijkeHash(receiptSha256, r.sidecarBonHash)) {
+      return { valid: false, measurable: true, reason_code: 'NOT_LINKED', detail: 'RECEIPT_HASH_MISMATCH' }
+    }
+  }
+
+  // De kern: wijzen het record en wat wij in handen hebben naar hetzelfde opgeleverde
+  // bestand. De aanroeper mag de hash van het bestand dat hij ECHT ontving meegeven; dat
+  // is sterker dan een hash die ook uit de sidecar komt, want dan vergelijk je twee
+  // velden van dezelfde uitgever met elkaar.
+  const onzeKant = deliverableSha256 ?? r.sidecarLevering
+  if (onzeKant === null || onzeKant === undefined) {
+    return {
+      valid: false,
+      measurable: false,
+      reason_code: 'NOT_MEASURED',
+      missing: ['deliverableSha256'],
+      detail: 'het record noemt een opgeleverd bestand, maar er is geen eigen hash om het tegen af te zetten',
+      independence: onafhankelijkheid(document).staat,
+    }
+  }
+  if (!gelijkeHash(r.acceptatieLevering, onzeKant)) {
+    return { valid: false, measurable: true, reason_code: 'NOT_LINKED', detail: 'DELIVERABLE_HASH_MISMATCH' }
+  }
+
+  // De twee x402-sleutels, ELK met zijn eigen tegenhanger. Een belofte wordt nooit met
+  // een nonce vergeleken: daarvoor zijn het twee sleutels. Staat een van de twee kanten
+  // niet in het stuk, dan wordt er niet vergeleken, en dat is geen afkeuring.
+  const b = r.sidecarBindings ?? {}
+  const paren = [
+    {
+      naam: 'COMMITMENT_MISMATCH',
+      sidecar: b.x402_receipt_commitment,
+      bon: receipt?.authorizationCommitment ?? receipt?.payload?.authorizationCommitment,
+    },
+    {
+      naam: 'AUTHORIZATION_MISMATCH',
+      sidecar: b.x402_authorization_nonce,
+      bon: receipt?.authorizationNonce ?? receipt?.payload?.authorizationNonce,
+    },
+  ]
+  const vergeleken = []
+  for (const p of paren) {
+    if (p.sidecar === undefined || p.sidecar === null) continue
+    if (p.bon === undefined || p.bon === null) continue
+    if (!gelijkeHash(p.sidecar, p.bon)) {
+      return { valid: false, measurable: true, reason_code: 'NOT_LINKED', detail: p.naam }
+    }
+    vergeleken.push(p.naam.replace('_MISMATCH', ''))
+  }
+
+  return {
+    valid: true,
+    measurable: true,
+    reason_code: 'LINKED',
+    independence: onafhankelijkheid(document).staat,
+    // Wat er WEL en NIET vergeleken is, want een groen antwoord zonder dat lijstje laat
+    // een lezer denken dat alles getoetst is.
+    compared: vergeleken,
+  }
+}
+
+export const UITKOMSTEN = ['LINKED', 'NOT_LINKED', 'NOT_MEASURED']