aontu 0.53.0 → 0.55.0

package/src/val/DisjunctVal.ts

@@ -14,6 +14,7 @@ import {
 import { AontuContext } from '../ctx'
 
 import { AontuError, descErr, makeNilErr } from '../err'
+import { exactJSON } from '../exactjson'
 import { unite } from '../unify'
 
 import {
@@ -70,7 +71,12 @@ class DisjunctVal extends JunctionVal {
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Disjunct', this, peer)
 
     if (!this.prefsRanked) {
-      this.rankPrefs(ctx)
+      const ranked = this.rankPrefs(ctx)
+      // A clash between equal-rank defaults refuses for the whole
+      // disjunction (R2): the disagreement IS the answer.
+      if (null != ranked && ranked.isNil) {
+        return ranked
+      }
     }
 
     // // // console.log('DISJUNCT-unify-A', this.id, this.canon)
@@ -95,6 +101,16 @@ class DisjunctVal extends JunctionVal {
     // before return.
     const savedErr = ctx.err
     const savedTrialMode = ctx._trialMode
+    // A MEMBER'S TYPE FLOW IS PART OF THAT MEMBER. `refer(t)`/`rel(t)`
+    // assert `t` on ANOTHER node, and the assertion may only take
+    // effect if the member that makes it survives: committing every
+    // member's flow puts `t_A & t_B` on the target, which no reading
+    // of `A | B` licenses and which leaves the target MORE constrained
+    // than either alternative. The flow record is therefore staged per
+    // trial, like `ctx.err`, and only the survivors' records are
+    // merged into the real one below.
+    const savedFlows: Map<string, Val> | undefined = (ctx as any).referflows
+    const staged: (Map<string, Val> | undefined)[] = []
     // C1-inner: tell `makeNilErr` to return TRIAL_NIL in this scope
     // instead of allocating per-failure NilVals. Save/restore so
     // nested DisjunctVal trials (and the outer non-trial code) are
@@ -108,6 +124,10 @@ class DisjunctVal extends JunctionVal {
         const v = this.peg[vI]
         const trialErr: any[] = []
         ctx.err = trialErr
+        if (undefined !== savedFlows) {
+          staged[vI] = new Map()
+          ;(ctx as any).referflows = staged[vI]
+        }
 
         oval[vI] = unite(te ? ctx.clone({ explain: ec(te, 'DIST:' + vI) }) : ctx, v, peer, 'dj-peer')
 
@@ -140,7 +160,7 @@ class DisjunctVal extends JunctionVal {
       // plus `k:'autoo'` answered "autoo", and `*8080|(integer&neq(80))`
       // admitted 80 (use-cases/BUGS.md §1-2). An inadmissible override
       // now fails the pref member's trial, and when every member is
-      // gone the meet is the existing `|:empty` refusal.
+      // gone the meet is the existing `empty` refusal.
       //
       // SCALAR preferred values only, exactly the kind gate's own
       // boundary (test/spec/pref.tsv, "THE GATE IS A SCALAR GATE"): a
@@ -176,6 +196,7 @@ class DisjunctVal extends JunctionVal {
     finally {
       ctx._trialMode = savedTrialMode
       ctx.err = savedErr
+      ;(ctx as any).referflows = savedFlows
     }
 
     // // // console.log('DISJUNCT-unify-B', this.id, oval.map(v => v.canon))
@@ -224,6 +245,31 @@ class DisjunctVal extends JunctionVal {
         for (let kI = vI + 1; kI < oval.length; kI++) {
           if (oval[kI].same(oval[vI])) {
             oval[kI] = TRIAL_NIL
+            continue
+          }
+
+          // TWO PREFERENCES OVER ONE VALUE ARE ONE PREFERENCE, and
+          // the lower rank is the one that generates: `*1 | **1` is
+          // `*1`. Ranking folds EQUAL ranks (R2); this folds the rest,
+          // which R5 stopped discarding.
+          //
+          // A PLAIN arm holding that same value is NOT a duplicate of
+          // it and must not be folded away: it is the sibling that
+          // ADMITS an override under ADR-004's gate, which is the
+          // whole point of writing `*x | x`. Folding it turned that
+          // idiom's own default into a `pref_not_instance` finding,
+          // and `*top | top` is pinned as its control.
+          const a: any = oval[vI]
+          const b: any = oval[kI]
+          if (true === a.isPref && true === b.isPref
+            && prefInnerPeg(a).same(prefInnerPeg(b))) {
+            if ((a as PrefVal).rank <= (b as PrefVal).rank) {
+              oval[kI] = TRIAL_NIL
+            }
+            else {
+              oval[vI] = TRIAL_NIL
+              break
+            }
           }
         }
       }
@@ -231,9 +277,27 @@ class DisjunctVal extends JunctionVal {
       // // // console.log('DISJUNCT-unify-D', this.id, oval.map(v => v.canon))
     }
 
+    // THE SURVIVORS' FLOWS, AND ONLY THEIRS. Members knocked out by
+    // the trial, by the admission gate or by the dedup above are all
+    // nil here, so this runs after every one of those and before the
+    // filter that drops them.
+    if (undefined !== savedFlows) {
+      for (let vI = 0; vI < staged.length; vI++) {
+        const st = staged[vI]
+        if (undefined === st || true === oval[vI]?.isNil) {
+          continue
+        }
+        for (const [k, fv] of st) {
+          const prev = savedFlows.get(k)
+          savedFlows.set(k, undefined === prev ? fv
+            : unite(ctx, prev, fv, 'refer-flow-record'))
+        }
+      }
+    }
+
     // Outside the 1<length block: a SINGLE-member disjunction (e.g. a
     // rankPrefs collapse) whose one member fails the trial or the
-    // admission gate must reach the `|:empty` refusal below, not
+    // admission gate must reach the `empty` refusal below, not
     // return the trial sentinel as if it were the answer.
     oval = oval.filter(v => !v.isNil)
 
@@ -243,7 +307,7 @@ class DisjunctVal extends JunctionVal {
       out = oval[0]
     }
     else if (0 == oval.length) {
-      return makeNilErr(ctx, '|:empty', this, peer)
+      return makeNilErr(ctx, 'empty', this, peer)
     }
     else {
       out = new DisjunctVal({ peg: oval }, ctx)
@@ -268,52 +332,61 @@ class DisjunctVal extends JunctionVal {
   }
 
 
-  // Answers the sole surviving preference when ranking collapsed the
-  // disjunction to one -- which the RECURSIVE call below consumes to
-  // lift a nested disjunct's winner into this one. Undefined when
-  // more than one alternative survives, so the type says both.
-  rankPrefs(ctx: AontuContext): PrefVal | undefined {
-    let lastpref: PrefVal | undefined = undefined
-    let lastprefI = -1
+  // RANK ORDERS THE SURVIVORS, IT DOES NOT DISCARD AT PARSE (ADR-011
+  // R5, docs/design/DEFAULTS.0.md). Every rank is KEPT here, and
+  // generation takes the lowest-rank preference still standing -- so
+  // eliminating the lower arm PROMOTES the next instead of taking the
+  // whole ladder with it. This ran once, before the member trials,
+  // and discarded every arm but the lowest: `*1 | **2` met by
+  // `neq(1)` lost the default entirely and refused, where the ladder
+  // exists precisely to answer 2. Rank is a preference order over
+  // WHAT SURVIVES, which is not knowable until the trials have run.
+  //
+  // Only EQUAL ranks fold, because two defaults at one rank are one
+  // decision: compatible pegs merge, and a disagreement is the
+  // `pref_rank_clash` refusal (R2), which belongs to the whole
+  // disjunction -- there is no alternative to fall back to.
+  //
+  // Answers the sole surviving preference when the disjunction holds
+  // exactly one -- which the RECURSIVE call below consumes to lift a
+  // nested disjunct's winner into this one -- or the clash refusal.
+  rankPrefs(ctx: AontuContext): Val | undefined {
+    // The kept index per rank, so an equal-rank twin folds into the
+    // arm already standing for that rank.
+    const atRank: Record<number, number> = {}
 
     // // // console.log('RP-A', this.peg.map((p: Val) => p.canon))
 
     for (let vI = 0; vI < this.peg.length; vI++) {
       const v = this.peg[vI]
+      let pref: PrefVal | undefined = undefined
+
       if (v instanceof PrefVal) {
-        if (null != lastpref) {
-          if (v.rank === lastpref.rank) {
-            const pref = v.unify(lastpref, ctx) as PrefVal
-            if (pref.isNil) {
-              return pref
-            }
-            else {
-              this.peg[lastprefI] = pref
-              lastpref = pref
-              this.peg[vI] = null
-            }
-            // return Nil.make(ctx, '|:prefs', lastpref, v, 'associate')
-          }
-          else if (v.rank < lastpref.rank) {
-            this.peg[lastprefI] = null
-            lastpref = v
-            lastprefI = vI
-          }
-          else {
-            this.peg[vI] = null
-          }
-        }
-        else {
-          lastpref = v
-          lastprefI = vI
-        }
+        pref = v
       }
       else if (v.isDisjunct) {
         const subrank = (v as DisjunctVal).rankPrefs(ctx)
+        if (null != subrank && subrank.isNil) {
+          return subrank
+        }
         if (subrank instanceof PrefVal) {
           this.peg[vI] = subrank
-          lastpref = subrank
-          lastprefI = vI
+          pref = subrank
+        }
+      }
+
+      if (undefined !== pref) {
+        const at = atRank[pref.rank]
+        if (undefined === at) {
+          atRank[pref.rank] = vI
+        }
+        else {
+          const folded = pref.unify(this.peg[at], ctx)
+          if (folded.isNil) {
+            return folded
+          }
+          this.peg[at] = folded
+          this.peg[vI] = null
         }
       }
     }
@@ -373,6 +446,33 @@ class DisjunctVal extends JunctionVal {
 
       const prefs = this.peg.filter((v: Val) => v instanceof PrefVal)
 
+      // ALTERNATIVES THAT GENERATE THE SAME VALUE ARE RESOLVED
+      // (ADR-007's rule, asked at the moment it matters): `[] | [&:
+      // T]` met by an empty list keeps both arms -- they differ as
+      // SCHEMAS, which is what stops the dedup collapsing the
+      // template away (BUGS.md §52 regime 4) -- but both generate
+      // the empty list, and one generated value is one value.
+      if (0 === prefs.length && 1 < this.peg.length) {
+        const gctx = ctx.clone({ err: [], collect: true })
+        let firstOut: any
+        let allSame = true
+        for (let gI = 0; gI < this.peg.length && allSame; gI++) {
+          const gout = this.peg[gI].gen(gctx)
+          if (0 < gctx.err.length || undefined === gout) {
+            allSame = false
+          }
+          else if (0 === gI) {
+            firstOut = gout
+          }
+          else {
+            allSame = exactJSON(gout) === exactJSON(firstOut)
+          }
+        }
+        if (allSame) {
+          return firstOut
+        }
+      }
+
       if (0 === prefs.length && 1 < this.peg.length) {
         const nerr = makeNilErr(ctx, 'disjunct_no_gen', this)
         descErr(nerr, ctx)
@@ -385,7 +485,19 @@ class DisjunctVal extends JunctionVal {
         return undefined
       }
 
-      return (0 < prefs.length ? prefs[0] : this.peg[0]).gen(ctx)
+      // THE LOWEST-RANK SURVIVOR (R5). Ranking no longer discards the
+      // weaker arms, so the choice is made here, over what is left:
+      // `*1 | **2` answers 1, and answers 2 once `*1` is gone.
+      let best: any = this.peg[0]
+      if (0 < prefs.length) {
+        best = prefs[0]
+        for (const p of prefs) {
+          if ((p as PrefVal).rank < best.rank) {
+            best = p
+          }
+        }
+      }
+      return best.gen(ctx)
     }
 
     return super.gen(ctx)

package/src/val/ExpectVal.ts

@@ -47,6 +47,9 @@ class ExpectVal extends FeatureVal {
   // canon reparsed into a document that accepts values the original
   // rejects. A canon that silently drops a constraint is worse than one
   // that fails to parse. Go's ExpectVal.Canon renders the same peg.
+  //
+  // Which is why `peg` is kept the WHOLE expectation as peers arrive
+  // (BUGS.md §48) rather than only what was first written: see unify.
   get canon() { return this.peg.canon }
 
   constructor(
@@ -73,12 +76,27 @@ class ExpectVal extends FeatureVal {
     let out: Val = this
 
     if (!peer.isTop) {
+      // THE PEER MEETS THE WHOLE EXPECTATION. `peg` already carries
+      // every peer met so far (see below), so meeting the incoming peer
+      // against the ACCUMULATED `peer` first -- as this did -- refused
+      // against only the atom that happened to reject. A conflict with
+      // `peg` is a conflict with the accumulation too, since peg
+      // subsumes it, so nothing stops being refused: only the sentence
+      // changes, to the residual the error's own hint promises
+      // (BUGS.md §48).
+      const peeru =
+        unite(te ? ctx.clone({ explain: ec(te, 'EXPECT') }) : ctx, peer, this.peg, 'expect-self')
+
+      // Accumulated for the `expect` finding's operand. Computed BEFORE
+      // the escape below, where it has always been: an expectation that
+      // escapes still passed through here, and moving it after the
+      // escape leaves the accumulating arm reachable only by a node
+      // that both carries an accumulation AND fails to escape -- which
+      // the suite never produces, so it reads as dead code against the
+      // ADR-002 gate. Go's ExpectVal.Unify keeps the same order.
       const acc = undefined === this.peer ? peer :
         unite(te ? ctx.clone({ explain: ec(te, 'PEER') }) : ctx, this.peer, peer, 'expect-peer')
 
-      const peeru =
-        unite(te ? ctx.clone({ explain: ec(te, 'EXPECT') }) : ctx, acc, this.peg, 'expect-self')
-
       if (peeru.isGenable) {
         out = peeru
       }
@@ -86,7 +104,24 @@ class ExpectVal extends FeatureVal {
         // Still an expectation: carry the accumulated peer forward in a
         // fresh node stored at THIS destination by the caller, leaving
         // `this` -- possibly a shared template's child -- untouched.
-        const e = new ExpectVal({ peg: this.peg }, ctx)
+        //
+        // THE MEET IS THE NEW PEG (BUGS.md §48). An expectation that
+        // has met a peer without being freed by it stands for `peg &
+        // peer` from then on -- that is what a later peer must satisfy,
+        // and what canon has to state. Rebuilding from the ORIGINAL peg
+        // dropped the peer everywhere the node was later copied (the
+        // bag re-wrap, Val.clone), so `b:{z:1} b:{u8:min(0)}
+        // a:$.b.u8&max(15)` -- whose reference resolves a pass late, so
+        // `max(15)` arrives as a peer -- canoned as `min(0)`. That text
+        // reparses into a document admitting 20, which the original
+        // rejects, and hashed differently in each port. Storing the
+        // meet in `peg` needs no new field and no carrying: every copy
+        // site already preserves `peg`.
+        //
+        // Purity is untouched -- this is a NEW node, so a shared
+        // template's own expectation keeps the peg it was written with
+        // (§6-§7).
+        const e = new ExpectVal({ peg: peeru }, ctx)
         e.key = this.key
         e.parent = this.parent
         e.peer = acc

package/src/val/FuncBaseVal.ts

@@ -22,6 +22,7 @@ import {
 } from '../utility'
 
 import { makeNilErr, AontuError } from '../err'
+import { sigRefuse } from '../siggate'
 
 import {
   top
@@ -271,16 +272,17 @@ class FuncBaseVal extends FeatureVal {
 
         // console.log('FUNCBASE-PEG', this.id, pegdone, this.peg.map((p: any) => p?.canon))
 
-        if (pegdone) {
-          const resolved = this.resolve(ctx, newpeg)
+        if (pegdone && !this.deferResolve(ctx, newpeg)) {
+          // THE SIGNATURE GATE (docs/design/SIGNATURES.0.md): the
+          // driven arguments against the declared signature, before
+          // the builtin's own logic sees them. See siggate.ts for
+          // what the gate owns and what stays with the builtins.
+          const resolved = sigRefuse(ctx, this, newpeg) ??
+            this.resolve(ctx, newpeg)
           // console.log('FUNC-RESOLVED', ctx.cc, resolved?.canon)
 
-          // The TOP peer is DROPPED as the unit it is — unless it
-          // carries an identity (G4 phase 1), which is content rather
-          // than the unit: `id(x) & id(y)` resolves both sides to a
-          // top, and taking this shortcut would silently keep one
-          // name and lose the other instead of refusing the pair.
-          out = resolved.done && peer.isTop && null == peer.entity ? resolved :
+          // The TOP peer is DROPPED as the unit it is.
+          out = resolved.done && peer.isTop ? resolved :
             unite(te ? ctx.clone({ explain: ec(te, 'PEG') }) : ctx,
               resolved, peer, 'func-' + this.funcname() + '/' + this.id)
           propagateMarks(this, out)
@@ -393,6 +395,17 @@ class FuncBaseVal extends FeatureVal {
   }
 
 
+  // A function may hold its resolution for a later pass even with its
+  // arguments settled -- it then rides the ordinary args-not-done
+  // path, residuating as any unresolved call does. super() defers on a
+  // recursion residual argument (SuperFuncVal), which is why the DRIVEN
+  // arguments are passed: this.peg still holds the undriven originals
+  // at the decision point.
+  deferResolve(_ctx: AontuContext, _args?: Val[]): boolean {
+    return false
+  }
+
+
 } /* node:coverage ignore next 6 */
 
 

package/src/val/GraphAtomVal.ts

@@ -0,0 +1,264 @@
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+
+// THE GRAPH ATOMS (RELATIONS.0.md §3.3): `acyclic()` and
+// `inverse(name)`, conjoined at the same field as the `rel()` they
+// govern. Their model is the sizing atoms -- a property that cannot be
+// decided while information can still arrive is HELD during
+// unification and DECIDED at generation, where no more can.
+//
+// During unification they are lattice-inert: both properties are
+// global and non-monotone (one more edge can make an acyclic graph
+// cyclic), and the lattice guarantee -- more information never
+// falsifies what has been observed -- forbids a constraint that could
+// answer true and then false. So the atoms only RESIDUATE: they ride
+// the field through meets, dedup additively, appear in canon and reach
+// the `aon1-` hash, and REGISTER the declaration on the context. The
+// predicate they govern is the key they sit on, evaluation-global,
+// additive across declarations.
+//
+// The verdict lands at generation (relationVerdict,
+// ts/src/relation.ts) and is reported identically by the `relations`
+// verb -- one decision, two surfaces.
+
+import type {
+  Val,
+  ValSpec,
+} from '../type'
+
+import {
+  DONE,
+} from '../type'
+
+import {
+  AontuContext,
+} from '../ctx'
+
+import { makeNilErr } from '../err'
+
+import { FuncBaseVal } from './FuncBaseVal'
+import { FeatureVal } from './FeatureVal'
+import { unite } from '../unify'
+import { propagateMarks } from '../utility'
+
+
+// The declarations one evaluation accumulates: predicate -> what its
+// atoms said. Additive, exactly as two statements of one map are. The
+// map lives on the CONTEXT (created in the constructor, like the
+// _depth box), so every clone shares one registry.
+export type RelDecl = {
+  acyclic?: boolean
+  inverses: Set<string>
+}
+
+export function relDecls(ctx: any): Map<string, RelDecl> {
+  return ctx._reldecls
+}
+
+
+class GraphAtomVal extends FeatureVal {
+  isGraphAtom = true
+  isGenable = true
+  // AFTER rel() (45000): the atoms say nothing about the value.
+  cjo = 46000
+
+  akind: 'acyclic' | 'inverse'
+  invname?: string
+  // The value the atom rides on -- the sizing-constraint shape: the
+  // atom ABSORBS its fold neighbours (the rel, the container, another
+  // atom) and carries them, so the fold's pairwise walk still merges
+  // the value across it. Absent until the atom meets one.
+  held?: Val
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+    this.akind = (spec as any).akind ?? 'acyclic'
+    this.invname = (spec as any).invname
+    this.held = (spec as any).held
+    // A settled residual, like an unmet rel(): the bare atom is its
+    // own value, and a type() body carrying one must settle. Holding
+    // an unsettled value, it is exactly as done as the value.
+    this.dc = undefined === this.held || true === this.held.done
+      ? DONE : 0
+  }
+
+  clone(ctx: AontuContext, spec?: ValSpec): Val {
+    const out: any = super.clone(ctx, spec)
+    out.akind = this.akind
+    out.invname = this.invname
+    out.held = this.held
+    out.dc = this.dc
+    return out
+  }
+
+  // A rebuilt atom around a new held, at this atom's position.
+  private carry(ctx: AontuContext, held: Val): Val {
+    const out: any = new GraphAtomVal(
+      { akind: this.akind, invname: this.invname, held } as any, ctx)
+    propagateMarks(this, out)
+    out.site = this.site
+    out.path = this.path
+    return out
+  }
+
+  // The predicate is the key the atom sits on -- and a predicate is a
+  // D-1 NAME, by exactly fieldkey's rule: an atom landed anywhere
+  // else declares nothing. Registration is idempotent (the
+  // declaration set is a set) and happens at every drive, so
+  // whichever pass first sees the atom at its landed position records
+  // it.
+  register(ctx: AontuContext): void {
+    const seg = this.path[this.path.length - 1]
+    if ('string' !== typeof seg || !GRAPH_ATOM_NAME.test(seg)) {
+      return
+    }
+    const decls = relDecls(ctx)
+    let d = decls.get(seg)
+    if (undefined === d) {
+      d = { inverses: new Set() }
+      decls.set(seg, d)
+    }
+    if ('acyclic' === this.akind) {
+      d.acyclic = true
+    }
+    else if (undefined !== this.invname) {
+      d.inverses.add(this.invname)
+    }
+  }
+
+  unify(peer: Val, ctx: AontuContext): Val {
+    const p: any = peer
+    this.register(ctx)
+
+    // The self-drive: unite's tail calls unify(top) directly on any
+    // not-done result, and the held is what still has work to do.
+    // (A null/nil peer never arrives -- unite's ladder absorbs both.)
+    if (null == peer || true === p.isTop) {
+      if (undefined === this.held) {
+        return this
+      }
+      if (true === this.held.done) {
+        // Doneness is monotone, so recording it in place is safe --
+        // and without it the bag walk keeps asking and generation
+        // refuses a finished value.
+        this.dc = DONE
+        return this
+      }
+      // The self-drive refines IN PLACE (the MapVal top-peer
+      // pattern): a fresh atom per pass changes object identity, so
+      // spread apply-once stamps and the entity merge's fast paths
+      // stop holding, and the enclosing bags re-open every pass --
+      // the service catalog never converged.
+      const held = unite(ctx, this.held, undefined, 'atom-drive')
+      if (true === held.isNil) {
+        return held
+      }
+      this.held = held
+      if (true === held.done) {
+        this.dc = DONE
+      }
+      return this
+    }
+
+    // The SAME declaration twice is one declaration; their helds
+    // merge.
+    if (true === p.isGraphAtom &&
+      p.akind === this.akind && p.invname === this.invname) {
+      const held = undefined === this.held ? p.held
+        : undefined === p.held ? this.held
+          : unite(ctx, this.held, p.held, 'atom-dup')
+      if (undefined !== held && true === held.isNil) {
+        return held
+      }
+      return undefined === held ? this : this.carry(ctx, held)
+    }
+
+    // Anything else -- the rel, the container, a different atom -- is
+    // ABSORBED: the atom carries the value and the fold's pairwise
+    // walk merges across it.
+    const held = undefined === this.held ? peer
+      : unite(ctx, this.held, peer, 'atom-held')
+    return true === held.isNil ? held : this.carry(ctx, held)
+  }
+
+  get canon(): string {
+    const own = 'acyclic' === this.akind
+      ? 'acyclic()'
+      : 'inverse(' + JSON.stringify(this.invname) + ')'
+    return undefined === this.held ? own : this.held.canon + '&' + own
+  }
+
+  gen(ctx: AontuContext) {
+    // The atom is transparent at generation -- its verdict is global
+    // (relationVerdict), never a value at this field -- and a BARE
+    // atom is silent, exactly as an unmet rel() is.
+    return undefined === this.held ? undefined : this.held.gen(ctx)
+  }
+}
+
+
+// D-1 (docs/design/RELATIONS.0.md): the name grammar shared by entity
+// names, edge predicates and inverse names.
+const GRAPH_ATOM_NAME = /^[_a-zA-Z][-_a-zA-Z0-9]*$/
+
+
+class AcyclicFuncVal extends FuncBaseVal {
+  isAcyclicFunc = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+  }
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new AcyclicFuncVal(spec)
+  }
+
+  funcname() {
+    return 'acyclic'
+  }
+
+  resolve(ctx: AontuContext, _args: Val[]) {
+    const out: any = new GraphAtomVal({ akind: 'acyclic' } as any, ctx)
+    out.site = this.site
+    out.path = this.path
+    return out
+  }
+}
+
+
+class InverseFuncVal extends FuncBaseVal {
+  isInverseFunc = true
+
+  constructor(spec: ValSpec, ctx?: AontuContext) {
+    super(spec, ctx)
+  }
+
+  make(_ctx: AontuContext, spec: ValSpec): Val {
+    return new InverseFuncVal(spec)
+  }
+
+  funcname() {
+    return 'inverse'
+  }
+
+  resolve(ctx: AontuContext, args: Val[]) {
+    const a: any = args[0]
+    // The mirroring predicate is a NAME -- D-1, spelled bare or
+    // quoted. A relation is a vocabulary term, not an address.
+    if (true !== a?.isScalar || 'string' !== typeof a.peg
+      || !GRAPH_ATOM_NAME.test(a.peg)) {
+      return makeNilErr(ctx, 'inverse_name', this, undefined, 'inverse')
+    }
+    const out: any = new GraphAtomVal(
+      { akind: 'inverse', invname: a.peg } as any, ctx)
+    out.site = this.site
+    out.path = this.path
+    return out
+  }
+} /* node:coverage ignore next 7 */
+
+
+export {
+  GraphAtomVal,
+  AcyclicFuncVal,
+  InverseFuncVal,
+}