aontu 0.53.0 → 0.55.0

package/src/provenance.ts

@@ -55,6 +55,12 @@ export type WhyConjunct = {
   // actually written. Empty when the contribution occupies no source —
   // a value unification minted rather than a document wrote.
   src: string
+  // The PREFERENCE RANK, 0-based, when the contribution is one: `*x`
+  // is 0, `**x` is 1. Absent for anything else. The engine's own
+  // number (PrefVal.rank), so a reader arbitrating between ranked
+  // contributions -- the meet ladder -- need not count stars in a
+  // canon string.
+  rank?: number
 }
 
 export type WhyRecord = {
@@ -76,7 +82,7 @@ export const FROM_SPREAD = '_fromSpread'
 // which is true of the parsed tree and of nothing derived from it. So
 // every value that reached a path through a CLONE was dark: a default
 // flowing into a `pack()`-generated child, a shape carried by a `$ref`,
-// one side of an id()-merge. `why` answered "(no contributions:
+// a value a spread template stamped. `why` answered "(no contributions:
 // nothing met at this path)" over a value it had just printed, with
 // exit 0 -- a false statement, and the one an audit surface may not
 // make (use-cases/BUGS.md §23, §24).
@@ -338,6 +344,7 @@ export class Provenance {
         row: v.site.row,
       },
       src: v.site.src,
+      ...(true === v.isPref ? { rank: v.rank } : {}),
     })
   }
 

package/src/query.ts

@@ -51,8 +51,10 @@ export type QueryOptions = {
   // The trust profile this run evaluates under (G5, docs/trust.md).
   // The source arrives from a caller, so the caller must be able to
   // say what it may reach: without this the include chain is the
-  // default one, and `@"x.js"` is arbitrary code execution in the
-  // evaluating process. A server passes `{include:'none'}`.
+  // default one, and `@"../../etc/passwd.aon"` reads whatever the
+  // process can. (`@"x.js"` no longer executes -- ADR-012 refuses the
+  // extension -- but reading is enough.) A server passes
+  // `{include:'none'}`.
   trust?: TrustOptions
 }
 

package/src/reach.ts

@@ -1,6 +1,6 @@
 /* Copyright (c) 2025 Richard Rodger, MIT License */
 
-// REACHABILITY OVER THE ENTITY GRAPH (the review's finding J,
+// REACHABILITY OVER THE LINK GRAPH (the review's finding J,
 // use-cases/REVIEW.md): "ship a transitive `reaches(a, b)` check verb".
 //
 // `relations` answers questions about the edge set as a whole --- is it
@@ -41,7 +41,7 @@ export type ReachVerdict = 'reaches' | 'unreachable' | 'error'
 export type ReachReport = {
   verdict: ReachVerdict
 
-  // The path found, as entity names from the source to the
+  // The path found, as `$.dotted` node paths from the source to the
   // destination, both included. Present ONLY on `reaches`: a path is
   // the evidence for the answer, and there is no evidence for a
   // negative one.
@@ -49,7 +49,7 @@ export type ReachReport = {
 
   // WHY the graph could not be looked at, in vet's finding shape (the
   // review's finding F): a document that does not stand up, or an
-  // endpoint that names no entity. Present ONLY on `error`.
+  // endpoint that names no node. Present ONLY on `error`.
   errors?: VetFinding[]
 }
 
@@ -66,14 +66,37 @@ export type ReachOptions = {
 }
 
 
-// The entity an address names --- everything before the first dot. A
-// link into `svc/auth.ports.http` reaches `svc/auth`: reachability is
-// between ENTITIES, and the path inside one says which part of it the
-// link arrives at. Same rule as relation.ts's entityOf, and it has to
-// be, or the two verbs would disagree about what an edge connects.
-function entityOf(addr: string): string {
-  const dot = addr.indexOf('.')
-  return dot < 0 ? addr : addr.slice(0, dot)
+// The segments a `$.dotted` endpoint spells, or undefined when it is
+// not one. Reachability is between TREE POSITIONS (ADR-014), so an
+// endpoint is a path and nothing else --- the same spelling the report
+// prints back.
+export function parseNodePath(s: string): string[] | undefined {
+  if ('$' === s) {
+    return []
+  }
+  if (!s.startsWith('$.')) {
+    return undefined
+  }
+  const parts = s.slice(2).split('.')
+  return parts.every((p) => /^[A-Za-z0-9_-]+$/.test(p)) ? parts : undefined
+}
+
+
+// Whether a path names a node of the evaluated tree. An endpoint that
+// exists but has no edges is a perfectly good question with the answer
+// `unreachable`; only one that names NOTHING is an error.
+function nodeAt(root: any, path: string[]): boolean {
+  let node: any = root
+  for (const seg of path) {
+    if (true !== node?.isMap && true !== node?.isList) {
+      return false
+    }
+    node = node.peg[seg]
+    if (null == node) {
+      return false
+    }
+  }
+  return null != node
 }
 
 
@@ -83,14 +106,14 @@ function endpointFinding(name: string, known: string[]): VetFinding {
     class: 'reference',
     severity: 'error',
     path: '$',
-    // NOT "unreachable". An endpoint that names no entity is a
-    // question the document cannot answer, and answering it `no` would
-    // report a typo as a fact about the model --- the fail-open shape
-    // this review exists to retire.
-    message: `${name} names no entity in this document.`,
+    // NOT "unreachable". An endpoint that names no node is a question
+    // the document cannot answer, and answering it `no` would report a
+    // typo as a fact about the model --- the fail-open shape this
+    // review exists to retire.
+    message: `${name} names no node in this document.`,
     sites: [],
     ...(0 === known.length ? {} : {
-      note: 'known entities: ' + known.join(', '),
+      note: 'nodes with links: ' + known.join(', '),
     }),
   }
 }
@@ -117,12 +140,19 @@ export function reachCheck(
   }
 
   const graph = graphOf(root)
-  const known = graph.entities.map((e) => e.id).sort(cmpCodePoint)
-  const missing = [from, to].filter((n) => !known.includes(n))
+  // The nodes the graph actually touches, for the error note: a
+  // document has every path in it, and listing them all would drown the
+  // one fact a mistyped endpoint needs.
+  const linked = [...new Set(graph.edges
+    .flatMap((e) => [e.from, e.to]))].sort(cmpCodePoint)
+  const missing = [from, to].filter((n) => {
+    const parts = parseNodePath(n)
+    return undefined === parts || !nodeAt(root, parts)
+  })
   if (0 < missing.length) {
     return {
       verdict: 'error',
-      errors: missing.map((n) => endpointFinding(n, known)),
+      errors: missing.map((n) => endpointFinding(n, linked)),
     }
   }
 
@@ -131,12 +161,11 @@ export function reachCheck(
   // both ports.
   const succ = new Map<string, string[]>()
   for (const e of graph.edges) {
-    if ('' === e.from ||
-      (null != options.relation && options.relation !== e.key)) {
+    if (null != options.relation && options.relation !== e.key) {
       continue
     }
     const list = succ.get(e.from)
-    const dest = entityOf(e.to)
+    const dest = e.to
     if (undefined === list) {
       succ.set(e.from, [dest])
     }

package/src/relation.ts

@@ -1,9 +1,10 @@
 /* Copyright (c) 2025 Richard Rodger, MIT License */
 
-// RELATION GRAPH CHECKS (G4 phase 5,
-// docs/capability-review/g4-identity-relations.md): acyclicity and
-// inverse consistency over the edge set, checked AFTER unification and
-// never by it.
+// RELATION GRAPH VERDICTS (RELATIONS.0.md §3.3, replacing the G4
+// phase 5 magic-key pass): acyclicity and inverse consistency over
+// the edge set, DECLARED by the graph atoms -- `acyclic()` and
+// `inverse(name)` conjoined at the field whose key is the predicate
+// -- and decided AFTER unification, never by it.
 //
 // Why not in the lattice. Both properties are GLOBAL and NON-MONOTONE:
 // an acyclic graph becomes cyclic when one more edge unifies in, and an
@@ -11,27 +12,27 @@
 // The lattice guarantee is that more information never falsifies what
 // has been observed, so a constraint that could be true and then false
 // is not a constraint the lattice may hold. These are facts about the
-// finished model, and the verb that reports facts about a finished
-// model is where they belong.
+// finished model, so the atoms only REGISTER during unification
+// (GraphAtomVal.register, onto ctx._reldecls), and the verdict lands
+// at GENERATION -- the sizing atoms' model -- where no more
+// information can arrive. The `relations` verb reports the same
+// verdict from the same declarations: one decision, two surfaces.
 //
-// A relation is DECLARED as data, under the `relations` key of the
-// document root, which is the `std/system` vocabulary's convention:
-//
-//   relations: dependsOn: $.std.Relation & {
-//     target: $.std.Service, inverse: dependedOnBy, acyclic: true
-//   }
-//
-// Nothing in the engine knows the name `relations`; this pass does,
-// and says so.
+// The old declaration channel -- a `relations:` key at the document
+// root, read by name -- is GONE, discharging ADR-010's grandfather
+// clause: the engine no longer knows any spellable key. The target
+// half of the old declaration is `rel(t)`'s flow at the site, which
+// checks by unifying rather than by a report-layer probe.
 
 import { Aontu } from './aontu'
 import { failureFinding } from './vet'
 import type { VetFinding } from './vet'
-import type { TrustOptions, Val } from './type'
+import type { TrustOptions } from './type'
 import { graphOf } from './graph'
-import type { Edge, EntityEntry, Graph } from './graph'
+import type { Edge, Graph } from './graph'
 import { cmpCodePoint } from './keyorder'
-import { unite } from './unify'
+import { makeNilErr } from './err'
+import type { RelDecl } from './val/GraphAtomVal'
 
 
 export type RelationVerdict = 'pass' | 'fail' | 'error'
@@ -42,7 +43,7 @@ export type RelationFinding = {
   relation: string
   // Where the offending edge is written, as a `$.dotted.path`.
   at: string
-  // For a cycle, the entities it runs through, in the order the walk
+  // For a cycle, the node paths it runs through, in the order the walk
   // found them, closing back on the first. For a missing inverse, the
   // two ends and the relation that should have mirrored it.
   detail: string[]
@@ -72,143 +73,7 @@ export type RelationOptions = {
 }
 
 
-// One declared relation, as the document spells it.
-type Declared = {
-  name: string
-  inverse?: string
-  acyclic: boolean
-  // What the FAR END must satisfy, if the relation says. Absent when
-  // the relation declares none, and when it declares `top` -- which
-  // constrains nothing and would report nothing, so reading it as a
-  // declaration would only cost a meet per edge.
-  target?: Val
-}
-
-
-// The entity an address names — everything before the first dot. An
-// edge into `svc/auth.ports.http` is an edge to `svc/auth`: a relation
-// holds between ENTITIES, and the path inside one says which part of it
-// the link reaches.
-function entityOf(addr: string): string {
-  const dot = addr.indexOf('.')
-  return dot < 0 ? addr : addr.slice(0, dot)
-}
-
-
-// The node an address names, or undefined. The entity's own position
-// comes from the graph (a merged entity sits at every position that
-// declared it, and they hold the same value, so the FIRST in the
-// graph's sorted list is as good as any and is the same one in both
-// ports); the rest of the address walks into it, exactly as the
-// address's own grammar says.
-// NO GUARD ON THE LOOKUP OR THE WALK. An edge exists only because
-// `refer()` RESOLVED its full address, so `find` cannot miss and no
-// segment can fall off: an address that does not walk is
-// `refer_unresolved` at unification and the document never reaches the
-// graph (probed for a missing key, a scalar mid-path and an
-// out-of-range index, in both ports). An unreachable `if` is a branch
-// arm the ADR-002 gate counts and no marker suppresses, so the Go twin
-// keeps its guards — where a nil would PANIC rather than propagate,
-// and where the marker mechanism can carry them — and this one relies
-// on optional chaining instead.
-function addressed(
-  root: any, graph: Graph, addr: string
-): any {
-  const dot = addr.indexOf('.')
-  const name = dot < 0 ? addr : addr.slice(0, dot)
-  const entry = graph.entities.find((e) => e.id === name) as EntityEntry
-  const segs = entry.paths[0].slice(2).split('.')
-    .concat(dot < 0 ? [] : addr.slice(dot + 1).split('.'))
-  let node: any = root
-  for (const seg of segs) {
-    node = node?.peg?.[seg]
-  }
-  return node
-}
-
-
-// Does the far end satisfy the declared target? A TEST, never a flow:
-// the check reports on a finished model and writing into it would be
-// generation, which `relations` does not do (the same rule that keeps
-// it from writing an author's inverse for them). So both sides are
-// CLONED into a throwaway context and the meet is taken there; what
-// the document holds is untouched either way.
-//
-// `refer(t)` is the other half of this and does flow, at the site. The
-// two agree on what "satisfies" means -- a meet that is not a nil --
-// which is what lets a relation declare once what every site would
-// otherwise repeat.
-// `root` is the DOCUMENT, not the node: a target lifted out of the
-// model (`target: $.std.Service`) can still hold a reference that
-// resolves against the document, and a probe rooted at the far end
-// answers `no_path` for it -- which the worked example in
-// test/spec/relation.tsv caught the moment this check existed.
-function meets(
-  aontu: any, root: any, node: any, target: any
-): string | undefined {
-  const ctx = aontu.ctx({ collect: true })
-  ctx.root = root
-  const out: any = unite(ctx, node.clone(ctx), target.clone(ctx), 'relation-target')
-  if (true === out?.isNil) {
-    return out.why as string
-  }
-  if (0 < ctx.err.length) {
-    return ctx.err[0].why as string
-  }
-
-  // A MEET THAT LEAVES A HOLE IS NOT SATISFACTION. `target:
-  // {kind: service, port: integer}` against a far end with no `port`
-  // does not CONFLICT -- the meet simply carries `integer` into a key
-  // that had none -- and a check that stopped at "no conflict" would
-  // pass a far end that is missing half of what the relation demands.
-  //
-  // What `refer(t)` does at the site is the yardstick: it flows `t` in,
-  // and the document then fails to generate, because `integer` is not a
-  // value. So the same question is asked here -- can the far end still
-  // generate once the target is met? -- and the answer is compared with
-  // the far end ALONE, so a node that was already incomplete for its
-  // own reasons is not blamed on the relation that points at it.
-  // The REASON reported is the engine's own -- the code `refer(t)` at
-  // the site would have raised -- rather than a name invented here.
-  const probe = (v: any): string | undefined => {
-    const gctx = aontu.ctx({ collect: true })
-    gctx.root = root
-    v.gen(gctx)
-    return 0 === gctx.err.length ? undefined : (gctx.err[0].why as string)
-  }
-  const alone = probe(node.clone(aontu.ctx({ collect: true })))
-  const met = probe(out)
-  return undefined === alone && undefined !== met ? met : undefined
-}
-
-
-function declaredRelations(root: any): Declared[] {
-  const rels = root?.peg?.relations
-  if (true !== rels?.isMap) {
-    return []
-  }
-  const out: Declared[] = []
-  for (const name of Object.keys(rels.peg).sort(cmpCodePoint)) {
-    const r: any = rels.peg[name]
-    if (true !== r?.isMap) {
-      continue
-    }
-    const inv: any = r.peg.inverse
-    const acy: any = r.peg.acyclic
-    const tgt: any = r.peg.target
-    out.push({
-      name,
-      inverse: true === inv?.isScalar && 'string' === typeof inv.peg
-        ? inv.peg : undefined,
-      acyclic: true === acy?.isScalar && true === acy.peg,
-      target: true === tgt?.isVal && true !== tgt.isTop ? tgt : undefined,
-    })
-  }
-  return out
-}
-
-
-// The first cycle reachable from `start`, as the entities it runs
+// The first cycle reachable from `start`, as the node paths it runs
 // through, or undefined. Depth-first with the path as the stack, and
 // the successors visited in sorted order, so the cycle a report names
 // is the same one in both ports.
@@ -245,44 +110,19 @@ function findCycle(
 }
 
 
-// The relation checks for one document.
-export function relationCheck(
-  src: string, opts?: RelationOptions): RelationReport {
-  const options = opts ?? {}
-  const aontu = new Aontu(
-    null == options.trust ? undefined : { trust: options.trust })
-  const ctx = aontu.ctx({ collect: true })
-  const parseOpts = null == options.path ? undefined : { path: options.path }
-  const root: any = aontu.unify(src, parseOpts, ctx)
-
-  // A document that does not stand up is not a document with a bad
-  // graph: the errors it already has are the answer, and blaming its
-  // relations on top would be noise.
-  if (0 < ctx.err.length || true === root?.isNil) {
-    return {
-      verdict: 'error',
-      findings: [],
-      errors: [failureFinding(ctx, options.path, root)],
-    }
-  }
-
-  const declared = declaredRelations(root)
-  if (0 === declared.length) {
-    return { verdict: 'pass', findings: [] }
-  }
-
-  const graph = graphOf(root)
-  const edges = graph.edges
+// The verdict itself, pure over what the evaluation produced: the
+// registered declarations and the edge set. Shared by the generation
+// hook (relationErrors) and the `relations` verb, so the two surfaces
+// cannot disagree.
+export function relationFindings(
+  decls: Map<string, RelDecl>, graph: Graph
+): RelationFinding[] {
   const findings: RelationFinding[] = []
 
   // The edge set, indexed the two ways the checks read it.
   const byRelation = new Map<string, Edge[]>()
   const pairs = new Set<string>()
-  for (const e of edges) {
-    if ('' === e.from) {
-      // An edge outside every entity has no source to be a relation OF.
-      continue
-    }
+  for (const e of graph.edges) {
     const list = byRelation.get(e.key)
     if (undefined === list) {
       byRelation.set(e.key, [e])
@@ -290,17 +130,22 @@ export function relationCheck(
     else {
       list.push(e)
     }
-    pairs.add(e.key + ' ' + e.from + ' ' + entityOf(e.to))
+    pairs.add(e.key + ' ' + e.from + ' ' + e.to)
   }
 
-  for (const rel of declared) {
-    const mine = byRelation.get(rel.name) ?? []
+  // Predicates in sorted order, so the findings arrive the same way
+  // in both ports (the registry is insertion-ordered here, random in
+  // Go).
+  const names = [...decls.keys()].sort(cmpCodePoint)
+  for (const name of names) {
+    const decl = decls.get(name) as RelDecl
+    const mine = byRelation.get(name) ?? []
 
-    if (rel.acyclic) {
+    if (true === decl.acyclic) {
       const succ = new Map<string, string[]>()
       for (const e of mine) {
         const list = succ.get(e.from)
-        const to = entityOf(e.to)
+        const to = e.to
         if (undefined === list) {
           succ.set(e.from, [to])
         }
@@ -325,7 +170,7 @@ export function relationCheck(
           const at = mine.find((e) => e.from === cycle[0]) as Edge
           findings.push({
             code: 'relation_cycle',
-            relation: rel.name,
+            relation: name,
             at: at.at,
             detail: cycle,
           })
@@ -334,45 +179,16 @@ export function relationCheck(
       }
     }
 
-    // TARGET: the far end IS what the relation says it is (the review's
-    // finding J). The declaration used to be inert -- `target` was read
-    // by nothing, on the reasoning that `refer(t)` already flows the
-    // type in at the site. It does, and that is exactly why the
-    // declaration was worth nothing: the site has to REPEAT it, and the
-    // idiom that avoids repeating it (`refer($.std.Service)`) tripped
-    // the fixpoint until §19 was fixed, so every real model wrote bare
-    // `refer()` and a typed-endpoint declaration checked nothing.
-    //
-    // Reported per EDGE, not per entity: an entity reached by two
-    // relations must satisfy both, and the report points at the link
-    // that made the demand.
-    if (undefined !== rel.target) {
+    const inverses = [...decl.inverses].sort(cmpCodePoint)
+    for (const inv of inverses) {
       for (const e of mine) {
-        // No guard on the node either, and for the same reason
-        // `addressed` needs none: an unresolved link is a nil in the
-        // tree, so this document would not have reached the graph.
-        const why = meets(aontu, root, addressed(root, graph, e.to),
-          rel.target)
-        if (undefined !== why) {
-          findings.push({
-            code: 'relation_target_unmet',
-            relation: rel.name,
-            at: e.at,
-            detail: [e.from, e.to, why],
-          })
-        }
-      }
-    }
-
-    if (undefined !== rel.inverse) {
-      for (const e of mine) {
-        const to = entityOf(e.to)
-        if (!pairs.has(rel.inverse + ' ' + to + ' ' + e.from)) {
+        const to = e.to
+        if (!pairs.has(inv + ' ' + to + ' ' + e.from)) {
           findings.push({
             code: 'relation_inverse_missing',
-            relation: rel.name,
+            relation: name,
             at: e.at,
-            detail: [e.from, to, rel.inverse],
+            detail: [e.from, to, inv],
           })
         }
       }
@@ -380,14 +196,101 @@ export function relationCheck(
   }
 
   // SORTED, because a report is read by a machine that diffs it: by the
-  // position the offending edge is written at, then by code. No third
-  // key: one edge sits under one key and one key is one relation, so
-  // two findings can share (at, code) only by being the same finding.
-  // The sort is STABLE, and the relations were iterated in sorted
-  // order, so what order remains is fixed anyway.
+  // position the offending edge is written at, then by code, then by
+  // the detail (two inverse declarations on one predicate can flag one
+  // edge twice). The sort is STABLE and the predicates were iterated
+  // in sorted order, so what order remains is fixed anyway.
   findings.sort((a, b) =>
-    cmpCodePoint(a.at, b.at) || cmpCodePoint(a.code, b.code))
+    cmpCodePoint(a.at, b.at) || cmpCodePoint(a.code, b.code)
+    || cmpCodePoint(a.detail.join(' '), b.detail.join(' ')))
+
+  return findings
+}
+
+
+// The generation hook (Aontu.generate, between unification success
+// and value generation): each finding becomes a LOCATED evaluation
+// error at the offending edge, exactly as an unmet sizing atom
+// refuses at generation. Findings name node paths and positions the
+// document spelled, so the walk to the site cannot miss.
+export function relationErrors(ctx: any, root: any): void {
+  const decls: Map<string, RelDecl> = ctx._reldecls
+  if (0 === decls.size) {
+    return
+  }
+  const findings = relationFindings(decls, graphOf(root))
+  for (const f of findings) {
+    let node: any = root
+    for (const seg of f.at.slice(2).split('.')) {
+      // Graph atoms hold the field's value -- possibly nested, one
+      // atom carrying another -- and the path steps through them
+      // exactly as the graph walk does.
+      while (true === node?.isGraphAtom) {
+        node = node.held
+      }
+      node = node?.peg?.[seg]
+    }
+    // No unwrap AFTER the walk: a finding's `at` names an edge
+    // element, and an edge's element is a string -- an atom-wrapped
+    // element mints no edge in the first place (the graph visit
+    // descends atoms only at field values), so the walk cannot end on
+    // an atom.
+    ctx.adderr(makeNilErr(ctx, f.code, node, undefined, 'relate', {
+      relation: f.relation,
+      detail: f.detail.join(' -> '),
+    }))
+  }
+}
+
+
+// The relation checks for one document: evaluate, then report the
+// same verdict generation enforces.
+export function relationCheck(
+  src: string, opts?: RelationOptions): RelationReport {
+  const options = opts ?? {}
+  const aontu = new Aontu(
+    null == options.trust ? undefined : { trust: options.trust })
+  const ctx = aontu.ctx({ collect: true })
+  const parseOpts = null == options.path ? undefined : { path: options.path }
+  const root: any = aontu.unify(src, parseOpts, ctx)
+
+  // A document that does not stand up is not a document with a bad
+  // graph: the errors it already has are the answer, and blaming its
+  // relations on top would be noise.
+  if (0 < ctx.err.length || true === root?.isNil) {
+    return {
+      verdict: 'error',
+      findings: [],
+      errors: [failureFinding(ctx, options.path, root)],
+    }
+  }
+
+  const decls: Map<string, RelDecl> = (ctx as any)._reldecls
+  if (0 === decls.size) {
+    return { verdict: 'pass', findings: [] }
+  }
+
+  // NOR IS A DOCUMENT THAT CANNOT BE GENERATED. Unification can
+  // succeed over a tree that still holds an unsettled disjunction --
+  // more than one alternative admitted, which `disjunct_no_gen`
+  // refuses at generation -- and the graph walk cannot read inside
+  // one: the links in every alternative are invisible, so a mirror
+  // the document plainly writes is missing from the edge set and
+  // `inverse(n)` calls it missing. Generation is therefore asked
+  // FIRST, on a collecting context of its own, and what it says is
+  // the answer. Generation is what the atoms' verdict lands at, so
+  // this is the same order the engine itself now runs in.
+  const gctx = ctx.clone({ err: [], collect: true })
+  root.gen(gctx)
+  if (0 < gctx.err.length) {
+    return {
+      verdict: 'error',
+      findings: [],
+      errors: [failureFinding(gctx, options.path, root)],
+    }
+  }
 
+  const findings = relationFindings(decls, graphOf(root))
   return {
     verdict: 0 === findings.length ? 'pass' : 'fail',
     findings,