aontu 0.62.0 → 0.64.0

package/src/val/FuncBaseVal.ts

@@ -33,16 +33,6 @@ import { FeatureVal } from '../val/FeatureVal'
 import { hasPlace, fillPlace } from '../val/PlaceVal'
 
 
-// A TRIAL meet: does `a` unify with `b`, and if so as what? Failure is
-// an ANSWER here rather than an error, which is exactly what
-// DisjunctVal already needs when it tries each member against a peer —
-// so this is that mechanism (`ctx._trialMode`, which makes makeNilErr
-// return the shared TRIAL_NIL instead of allocating and recording),
-// lent to the combinators that select by unifiability.
-//
-// The error list and the trial flag are saved and restored in a
-// `finally`: a trial that throws must not leave the surrounding
-// evaluation collapsing every later error into the sentinel.
 function trialUnify(ctx: AontuContext, a: Val, b: Val): Val | undefined {
   const savedErr = ctx.err
   const savedTrial = ctx._trialMode
@@ -83,15 +73,10 @@ function trialUnify(ctx: AontuContext, a: Val, b: Val): Val | undefined {
 
 class FuncBaseVal extends FeatureVal {
   isFunc = true
+
+  forgives = false
   isGenable = true
 
-  // THE STAGING RULE (G8 phase 0, see AontuContext.settle). A func
-  // whose answer depends on WHERE IT IS -- `key()`, whose answer is a
-  // segment of its own path, and the generation combinators, whose
-  // data argument can still be merged into by a sibling -- sets this
-  // and residuates until the model stops moving. Everything else
-  // resolves as soon as its arguments are done, which is the rule that
-  // has always been here.
   staged = false
 
   constructor(
@@ -99,13 +84,11 @@ class FuncBaseVal extends FeatureVal {
     ctx?: AontuContext
   ) {
     super(spec, ctx)
-    // console.log('FBV', this.id, this.constructor.name, this.peg?.[0]?.canon)
   }
 
 
   validateArgs(args: Val[], min: number) {
     if (min < args.length) {
-      // TODO: this is an error as as a parse error, needs to be handled same way
       throw new AontuError('The ' + this.funcname() + ' function needs at least ' +
         min + ' argument' + (1 === min ? '' : 's') + '.')
     }
@@ -117,28 +100,10 @@ class FuncBaseVal extends FeatureVal {
   }
 
 
-  // Drive the first `count` arguments IN PLACE, every pass — not only
-  // on the settle pass. A staged func waits for the model to settle,
-  // and its own arguments are part of that model: leaving them
-  // standing until settle would guarantee the model was still moving
-  // when settle arrived. Answers whether they are all done, which is
-  // the other half of "ready to fire".
   driveStagedArgs(ctx: AontuContext, count: number): boolean {
     const TOP = top()
     let alldone = true
 
-    // THE SNAPSHOT WAITS FOR THE SOURCE (the spread-then-pack defect,
-    // use-cases/BUGS.md pack-refs family). A reference resolving inside
-    // a staged argument is this argument's SNAPSHOT of its source, and
-    // the snapshot is not part of the tree: a spread-injected relative
-    // reference inside a too-early copy dangles at the argument's
-    // location (`.containerPort` rebased under the generator, where no
-    // root traversal reaches it) and the generator never fires. The
-    // `argsnap` flag makes RefVal.find defer until the target has
-    // finished resolving IN THE TREE — where its own spreads and
-    // relative references answer at their real location — and only then
-    // take the copy. Inherited by every descended ctx, so a reference
-    // anywhere in the argument subtree waits the same way.
     const actx: AontuContext = ctx.clone({})
     ; (actx as any).argsnap = true
 
@@ -156,47 +121,15 @@ class FuncBaseVal extends FeatureVal {
   }
 
 
-  // THE STAGED READINESS GATE, stated once for the generators that
-  // drive their own data argument. Such a func fires when the model
-  // has settled AND that argument is done -- EXCEPT when the argument
-  // is a HOLE and a PEER has arrived to fill it. `_` is never done: it
-  // is FILLED, and the peer is what fills it, so gating on doneness
-  // alone held every placeheld generator residual for ever and the
-  // fill in `unify` below was never reached (`["a"] & pack(_, {x:1})`
-  // was `*_no_gen`, while the unstaged `"hello" & upper(_)` filled as
-  // documented -- an undriven `_` makes an ordinary call's `pegdone`
-  // false, and a generator's prepare() forces it true). Against TOP
-  // there is nothing to fill with, so a placeheld generator waits
-  // exactly as the hole itself does.
   stagedReady(peer: Val, ctx: AontuContext, count: number): boolean {
     const ready = this.driveStagedArgs(ctx, count)
     return (ready || (!peer.isTop && hasPlace(this))) && true === ctx.settle
   }
 
 
-  // THE PER-DESTINATION INSTANTIATION RULE (ADR-005). The default
-  // clone shares the argument array AND the argument Vals — the
-  // residuation clone, which stays at one position and wants the
-  // sharing, and the reference copy of a target that still holds a
-  // staged call, which pins the move()/copy() ghost artifacts
-  // (test/spec/func.tsv, ghost-*-innard-canon; ADR-025) — but a clone
-  // that is an INSTANCE must own the full inner structure: with the
-  // args shared, `pack($.names, close({name: key()}))` resolved key()
-  // once inside the one shared inner map and stamped the FIRST
-  // child's key on every child (use-cases/BUGS.md §8). The `dup` spec
-  // flag asks for that depth; everything else keeps the sharing it
-  // has always had.
   clone(ctx: AontuContext, spec?: ValSpec): Val {
     const out = super.clone(ctx, spec) as FuncBaseVal
     if (true === spec?.dup && Array.isArray(this.peg)) {
-      // Every argument is a Val by construction (the parser builds
-      // them; make() rebuilds from driven Vals), as the Go twin's
-      // []Val typing states outright. The generator and spread
-      // instantiation sites then normalise every path in the clone
-      // (repathInstance), so the argument-shaped parse paths never
-      // leak into an instance; the reference copy takes the paths
-      // this rebasing gives, which is what an absolute address in a
-      // copied model already expects (ADR-014).
       out.peg = this.peg.map((a: Val) => a.clone(ctx, { dup: true }))
     }
     return out
@@ -237,16 +170,7 @@ class FuncBaseVal extends FeatureVal {
       return this.residuate(peer, ctx)
     }
 
-    // THE PLACEHOLDER (G8 phase 3, see PlaceVal). A call holding a hole
-    // waits for a peer, and the peer is what fills it: the call is
-    // rebuilt with the hole replaced and resolved on the spot, so
-    // `upper(_) & hello` is `"HELLO"` and not `"HELLO" & "hello"` --
-    // the peer went INTO the call, it is not also a constraint on the
-    // way out.
     if (!peer.isTop && !peer.isNil && this.id !== peer.id && hasPlace(this)) {
-      // TWO HOLES AND NOTHING TO FILL THEM. `upper(_) & lower(_)` has
-      // no value on either side, and picking one call to be the other's
-      // filling would be inventing an order the language does not have.
       if (hasPlace(peer)) {
         return makeNilErr(ctx, 'place_pair', this, peer)
       }
@@ -256,16 +180,11 @@ class FuncBaseVal extends FeatureVal {
     const TOP = top()
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Func:' + this.funcname(), this, peer)
 
-    // const sc = this.id + '=' + this.canon
-    // const pc = peer.id + '=' + peer.canon
-
 
     let why = ''
     let out: Val = this
 
 
-    // console.log('FBV', this.id, this.constructor.name, this.mark.type, this.peg?.canon, 'PEER', peer.id, peer.canon)
-
     let pegdone = true
 
     if (this.id !== peer.id) {
@@ -290,20 +209,13 @@ class FuncBaseVal extends FeatureVal {
           this.peg = pegprep
 
           for (let arg of this.peg) {
-            // console.log('FUNCBASE-UNIFY-PEG-A', arg.canon)
 
             let newarg = arg
             if (!arg.done) {
-              // Charged to the depth budget: this recurses without going
-              // through `unite`, so the counter would otherwise stay flat
-              // while the stack grows (see withDepth in unify.ts). The
-              // arg context is built OUTSIDE the closure so its explain
-              // ternary stays one branch rather than one per call.
               const argctx = te ? ctx.clone({ explain: ec(te, 'ARG') }) : ctx
               newarg = withDepth(ctx, arg, TOP, () => arg.unify(TOP, argctx))
               newtype = newtype || newarg.mark.type
               newhide = newhide || newarg.mark.hide
-              // console.log('FUNCBASE-UNIFY-PEG-B', arg.canon, arg.done, '->', newarg.canon, newarg.done)
             }
             // pegdone &&= arg.done
             pegdone &&= newarg.done
@@ -313,14 +225,18 @@ class FuncBaseVal extends FeatureVal {
 
         // console.log('FUNCBASE-PEG', this.id, pegdone, this.peg.map((p: any) => p?.canon))
 
-        if (pegdone && !this.deferResolve(ctx, newpeg)) {
+        // ABSENCE PROPAGATES (ADR-034), ahead of deferResolve.
+        const gone = this.forgives ? undefined :
+          newpeg.find((a: Val) => true === (a as any).isAbsent)
+
+        if (pegdone &&
+          (undefined !== gone || !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) ??
+          const resolved = gone ?? 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.
           out = resolved.done && peer.isTop ? resolved :
@@ -328,19 +244,9 @@ class FuncBaseVal extends FeatureVal {
               resolved, peer, 'func-' + this.funcname() + '/' + this.id)
           propagateMarks(this, out)
 
-          // TODO: make should handle this using ctx?
           out.site.row = this.site.row
           out.site.col = this.site.col
           out.site.url = this.site.url
-          // THE SPAN COMES WITH THE POSITION, always. Moving row and
-          // col onto the result while leaving its own text behind
-          // produced a site that contradicted itself: `close({...})`
-          // reported the call's column and the map's `{`, so reading
-          // the document at (row, col, len) found `c` where `src` said
-          // `{`. A consumer following the verification contract would
-          // refuse every such repair; one skipping it would edit the
-          // wrong token. Whatever the position names, the text names
-          // too. Twin: the same assignment in go/func.go.
           out.site.len = this.site.len
           out.site.src = this.site.src
           out.path = this.path
@@ -351,19 +257,9 @@ class FuncBaseVal extends FeatureVal {
           this.notdone()
           out = this.make(ctx, { peg: newpeg, mark: { type: newtype, hide: newhide } })
 
-          // TODO: make should handle this using ctx?
           out.site.row = this.site.row
           out.site.col = this.site.col
           out.site.url = this.site.url
-          // THE SPAN COMES WITH THE POSITION, always. Moving row and
-          // col onto the result while leaving its own text behind
-          // produced a site that contradicted itself: `close({...})`
-          // reported the call's column and the map's `{`, so reading
-          // the document at (row, col, len) found `c` where `src` said
-          // `{`. A consumer following the verification contract would
-          // refuse every such repair; one skipping it would edit the
-          // wrong token. Whatever the position names, the text names
-          // too. Twin: the same assignment in go/func.go.
           out.site.len = this.site.len
           out.site.src = this.site.src
           out.path = this.path
@@ -381,19 +277,9 @@ class FuncBaseVal extends FeatureVal {
             peg: [this, peer], mark: { type: newtype, hide: newhide }
           }, ctx)
 
-          // TODO: make should handle this using ctx?
           out.site.row = this.site.row
           out.site.col = this.site.col
           out.site.url = this.site.url
-          // THE SPAN COMES WITH THE POSITION, always. Moving row and
-          // col onto the result while leaving its own text behind
-          // produced a site that contradicted itself: `close({...})`
-          // reported the call's column and the map's `{`, so reading
-          // the document at (row, col, len) found `c` where `src` said
-          // `{`. A consumer following the verification contract would
-          // refuse every such repair; one skipping it would edit the
-          // wrong token. Whatever the position names, the text names
-          // too. Twin: the same assignment in go/func.go.
           out.site.len = this.site.len
           out.site.src = this.site.src
           out.path = this.path
@@ -411,7 +297,6 @@ class FuncBaseVal extends FeatureVal {
   }
 
 
-
   get canon() {
     return '' +
       // (this.type ? '<type>' : '') +
@@ -436,12 +321,6 @@ 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
   }

package/src/val/GraphAtomVal.ts

@@ -1,24 +1,5 @@
 /* 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,
@@ -41,10 +22,6 @@ 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>
@@ -63,10 +40,6 @@ class GraphAtomVal extends FeatureVal {
 
   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) {
@@ -74,9 +47,6 @@ class GraphAtomVal extends FeatureVal {
     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
   }
@@ -90,7 +60,6 @@ class GraphAtomVal extends FeatureVal {
     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)
@@ -100,12 +69,6 @@ class GraphAtomVal extends FeatureVal {
     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)) {
@@ -143,11 +106,6 @@ class GraphAtomVal extends FeatureVal {
         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

package/src/val/HideFuncVal.ts

@@ -47,21 +47,6 @@ class HideFuncVal extends FuncBaseVal {
   }
 
 
-  /*
-  unify(peer: Val, ctx: AontuContext): Val {
-    const te = ctx.explain && explainOpen(ctx, ctx.explain, 'HideFunc', this, peer)
-    let out: Val | undefined = this.resolved
-
-    if (null == out) {
-      out = this.resolve(ctx, this.peg)
-    }
-
-    explainClose(te, out)
-    return out
-  }
-  */
-
-
   resolve(ctx: AontuContext, args: Val[]) {
     let out = args[0] ?? makeNilErr(ctx, 'arg', this)
     if (!out.isNil) {

package/src/val/IntegerVal.ts

@@ -26,71 +26,11 @@ class IntegerVal extends ScalarVal {
   isInteger = true
 
 
-  // Canon renders the EXACT digits of the value, not JavaScript's
-  // shortest round-tripping form.
-  //
-  // A JS number's toString emits the shortest decimal that parses back
-  // to the same double — at most 17 significant digits — so 2^60 printed
-  // as `1152921504606847000`, a DIFFERENT integer that merely rounds to
-  // the same double, while the Go port printed the true
-  // `1152921504606846976` from its int64. That was the one entry in the
-  // parity ledger (issue #21).
-  //
-  // Neither rendering was "the wrong number" while lossy literals were
-  // still accepted, which is why the ledger deferred to the Phase 6
-  // refusal — but Phase 6 refuses INEXACT literals, and every value in
-  // this window (2^60, 2^63-1024, …) is exactly representable and so is
-  // accepted. The divergence was never about exactness; it was about
-  // rendering. Once the value is exactly what the source asked for,
-  // there IS a right answer, and it is the exact digits.
-  //
-  // BigInt is exact here by construction: an IntegerVal's peg is
-  // integral and inside the int64 window (isIntegerKind, enforced in the
-  // constructor), so the bigint conversion cannot lose anything.
   get canon() {
     return integerDigits(this.peg as number)
   }
 
 
-  // The same exactness in GENERATED output -- the other half of #21, and
-  // the half canon cannot reach.
-  //
-  // `generate()` returns NATIVE values, and the emitter sees only those:
-  // by the time exactJSON has a JS number it can no longer tell an
-  // integer-kind 2^60 (whose exact digits are the answer) from a
-  // float-kind 1e21 (whose shortest form `1e+21` is the answer, and is
-  // what Go prints too). The kind has to travel WITH the value, so above
-  // the safe-integer range an integer-kind value generates as a `bigint`,
-  // which the emitter already writes as exact digits.
-  //
-  // WHY Number.isSafeInteger IS THE LINE. It is precisely "this double is
-  // an integer that renders its own exact digits": inside the range the
-  // integers are contiguous, so toString round-trips exactly and a
-  // `number` loses nothing. Outside it they are not, and JS itself
-  // declares the value untrustworthy -- so handing back a `number` there
-  // would give a consumer something that prints wrong AND does
-  // arithmetic wrong, silently. A bigint makes both explicit: mixing it
-  // with a number throws rather than quietly rounding.
-  //
-  // The line is deliberately the WELL-KNOWN one rather than the tightest
-  // possible one. Some doubles above the range do still render exactly
-  // (2^54, say), so a predicate of `BigInt(peg).toString() === String(peg)`
-  // would keep marginally more values as `number` -- at the cost of a
-  // contract no consumer could evaluate in their head, and of handing
-  // back unsafe numbers for arithmetic. "Integers up to
-  // Number.MAX_SAFE_INTEGER are numbers; beyond that, bigints" is a rule
-  // that can be stated once and relied on.
-  //
-  // This is a BREAKING change for a consumer reading integers above 2^53
-  // out of generate() -- but those were the values that were already
-  // silently wrong, and a TypeError on `out.x + 1` is the better failure.
-  // Go needs none of this: its integer leaf is an int64, exact across the
-  // whole window, and encoding/json writes its digits.
-  //
-  // The BYTES are unchanged below the line, and the values that cross it
-  // with 17 or fewer significant digits (2^53 itself) serialise the same
-  // either way -- only their runtime type moves, which is why the `gens`
-  // rows cannot see it and ts/test/exactjson.test.ts pins it instead.
   gen(_ctx?: AontuContext) {
     const peg = this.peg as number
     return Number.isSafeInteger(peg) ? peg : BigInt(peg)
@@ -108,7 +48,6 @@ class IntegerVal extends ScalarVal {
     if (!isIntegerKind(spec.peg)) {
       throw new AontuError('not-integer-kind: ' + spec.peg)
     }
-    // super({ peg: spec.peg, kind: Integer }, ctx)
     super({ ...spec, kind: Integer }, ctx)
   }
 

package/src/val/JunctionVal.ts

@@ -33,26 +33,6 @@ abstract class JunctionVal extends FeatureVal {
 
   clone(ctx: AontuContext, spec?: ValSpec): Val {
     let out = (super.clone(ctx, spec) as JunctionVal)
-    // A JUNCTION'S MEMBERS SIT AT THE JUNCTION'S OWN POSITION. That is
-    // the rule `repathInstance` (Val.ts) states for the instance walk
-    // -- a conjunct's members occupy the conjunct's position, which is
-    // what `A & B` means -- and it holds for every clone, not only for
-    // marked ones.
-    //
-    // Val.clone's ctx cut cannot derive it: MapVal.clone hands a child
-    // its path through the SPEC rather than by descending the ctx, so
-    // a member left to the cut takes the DRIVING context's path -- the
-    // map's -- and loses the field key it sits under. A conjunct
-    // member reached through a reference into a position at least as
-    // deep as its definition then carried the entity's path, and every
-    // reader of `Val.path` was told the wrong position: a rel()-minted
-    // link took the ENTITY's key as its predicate, so `inverse(n)`
-    // looked for a mirror under a relation nobody declared and
-    // reported a written mirror missing.
-    //
-    // The instantiation flag still descends with the mark (ADR-005).
-    // Go states the same invariant directly (go/clone.go, cloneAt), so
-    // this restores parity rather than inventing a behaviour.
     const childspec: any = spec?.mark || spec?.dup ?
       { mark: spec?.mark, dup: spec?.dup, path: out.path }
       : { path: out.path }

package/src/val/KeyFuncVal.ts

@@ -1,7 +1,6 @@
 /* Copyright (c) 2021-2025 Richard Rodger, MIT License */
 
 
-
 import type {
   Val,
   ValSpec,
@@ -14,7 +13,6 @@ import {
 import { StringVal } from '../val/StringVal'
 
 
-
 import { FuncBaseVal } from './FuncBaseVal'
 import { makeNilErr } from '../err'
 
@@ -27,7 +25,6 @@ class KeyFuncVal extends FuncBaseVal {
     ctx?: AontuContext
   ) {
     super(spec, ctx)
-    // this.dc = DONE
   }
 
 
@@ -40,34 +37,12 @@ class KeyFuncVal extends FuncBaseVal {
   }
 
 
-  // `key()` is the first value to take THE STAGING RULE (G8 phase 0,
-  // see AontuContext.settle): its answer is a segment of its own path,
-  // so it must not answer while a spread, a reference or a `move` can
-  // still move it. It residuates until the model stops changing, and
-  // fires on the settle pass. The residuation itself is FuncBaseVal's,
-  // shared with the generation combinators.
   staged = true
 
 
   resolve(ctx: AontuContext, _args: Val[]) {
     let out: Val = this
 
-    // if (!this.mark.type && !this.mark.hide) {
-    //
-    // THE LEVEL MUST BE AN INTEGER, OR ABSENT.
-    //
-    // A level is an index into the path (0 the own key, the default 1 the
-    // parent), so the argument is an integer or it is a mistake. Both
-    // exact integer leaves qualify -- `integer` and `biginteger` -- and
-    // everything else is refused rather than silently meaning "parent",
-    // which is what made a mistyped level undetectable.
-    //
-    // This also removes a crash. The test used to be
-    // `isNaN(move) ? 1 : +move` with the COERCING global isNaN, which is
-    // ToNumber, and ToNumber THROWS for a bigint (a biginteger's peg) and
-    // for the null-prototype object a map's peg is -- neither has a
-    // toString or valueOf to call. The exception escaped into unify's
-    // catch-all and surfaced as an opaque [aontu/internal].
     const argval: any = this.peg?.[0]
     let move = 1
 
@@ -86,28 +61,6 @@ class KeyFuncVal extends FuncBaseVal {
       }
     }
 
-    // THE PATH IS THE ONE IT IS BEING DRIVEN AT, not the one it
-    // remembers. `this.path` is a cache that the residuation clone
-    // refreshes each pass, and it is right for a key() the bag walk
-    // reaches directly -- but a key() nested inside a function or
-    // operator ARGUMENT is never reached that way: it is driven by its
-    // enclosing call, which re-paths nothing, so it kept the position
-    // the SOURCE TEXT put it at. Inside a template that is fatal: the
-    // source position of `&: {k: "x" + key()}` (or of `pack`'s
-    // template) is the template, not any of the destinations, and the
-    // parse-time path of a function argument is not a document
-    // position at all.
-    // A stored path is only usable if it IS one: a path segment that is
-    // not a key is not a position, and the parse-time path of a value
-    // written inside a function ARGUMENT carries exactly that -- the
-    // argument has no key, so its segment is not a string. Those values
-    // are also the ones the bag walk never re-paths (a call re-paths
-    // nothing it holds), which is why the stored path stays wrong
-    // forever rather than being refreshed on the next pass. For them
-    // the driving context is the only truth. For everything else the
-    // stored path stays authoritative, because a TRANSPLANTED value
-    // (move(), a shared clone) must answer for where it was put, not
-    // for whichever driver happened to reach it first.
     let positioned = true
     for (const seg of this.path) {
       if ('string' !== typeof seg) {
@@ -118,7 +71,6 @@ class KeyFuncVal extends FuncBaseVal {
 
     const here = positioned ? this.path : ctx.path
     const key = here[here.length - (1 + move)] ?? ''
-    // console.log('KEY', this.path, move, key)
 
     out = new StringVal({ peg: key })
     // }