aontu 0.58.0 → 0.60.0

package/src/val/ListVal.ts

@@ -335,7 +335,15 @@ class ListVal extends BagVal {
       { mark: spec?.mark, dup: spec?.dup } : {}
     for (let entry of Object.entries(this.peg)) {
       out.peg[entry[0]] =
-        (entry[1] as any)?.isVal ? (entry[1] as Val).clone(ctx, childspec) : entry[1]
+        (entry[1] as any)?.isVal ? (entry[1] as Val).clone(ctx, {
+          ...childspec,
+          // AN ELEMENT IS A POSITION, exactly as a map's child is
+          // (MapVal.clone). Without this an explicitly pathed clone
+          // rebased the list and left every element at its source
+          // path -- the Go twin descends by index (go/clone.go, the
+          // *ListVal arm of clonePathKind).
+          path: [...out.path, entry[0]],
+        }) : entry[1]
     }
     if (this.spread.cj) {
       out.spread.cj = this.spread.cj.clone(ctx, childspec)

package/src/val/PlaceVal.ts

@@ -133,7 +133,11 @@ function hasPlace(v: Val): boolean {
 // generator's to fill with its OWN source children when it fires.
 function fillPlace(v: Val, fill: Val, ctx: AontuContext): Val {
   if (true === (v as any).isPlace) {
-    return fill
+    // A FILL IS A POSITION. The hole knows where it sits in the
+    // instance; the datum arriving in it does not, and inserted as it
+    // stands it keeps the paths it had at its SOURCE, so every finding
+    // under it names a path that does not exist.
+    return fill.clone(ctx, { path: [...(v as any).path] })
   }
 
   const peg: any = (v as any).peg

package/src/val/RecurseVal.ts

@@ -204,6 +204,17 @@ function bumpRecurse(v: any, xc: number): void {
     v.xc = Math.max(v.xc, xc)
     return
   }
+  // A RAW REFERENCE TO A RECURSIVE TARGET IS THE RECURSION, minted or
+  // not -- the same reading containsRecurseOf already takes, and the
+  // reason bound 2 was inert. A freshly cloned level holds the
+  // definition's references UNRESOLVED, so this walk found no
+  // residual to stamp and `xc` read 0 at every expansion, in the
+  // healthy form too. The seed rides on the reference and the
+  // residual minted from it starts there (ts/src/val/RefVal.ts).
+  if (true === v.isRef) {
+    v.rxc = Math.max(v.rxc ?? 0, xc)
+    return
+  }
   const peg: any = v.peg
   if (true === v.isMap && null != peg) {
     for (const k of Object.keys(peg)) {

package/src/val/RefVal.ts

@@ -107,6 +107,15 @@ class RefVal extends FeatureVal {
   // after unification (see `canon` below). Not a ValSpec field: it is
   // a rendering of the settled tree, never a parse-time property.
   expansion: Val | undefined = undefined
+
+  // THE RECURSION SEED (use-cases/BUGS.md §57). A reference that names
+  // a recursive definition IS the fixpoint reference; it mints a
+  // RecurseVal when it resolves. bumpRecurse stamps the expansion
+  // depth here, because a freshly cloned level holds the definition's
+  // references UNRESOLVED and so has no residual to stamp -- which is
+  // why the design's second termination bound read 0 at every
+  // expansion. The minted residual starts from this.
+  rxc: number = 0
   prefix: boolean = false
 
   constructor(
@@ -329,7 +338,7 @@ class RefVal extends FeatureVal {
         out = makeNilErr(ctx, 'path_cycle', this)
       }
       else {
-        const rec: any = new RecurseVal({ target } as any, ctx)
+        const rec: any = new RecurseVal({ target, xc: this.rxc } as any, ctx)
         rec.site = this.site
         rec.path = [...this.path]
         out = rec
@@ -610,7 +619,8 @@ class RefVal extends FeatureVal {
         // residual is the resolved form, exactly as at the prefix
         // positions inside the definition.
         else if (null != out && !snap && containsRecurseOf(out, this.peg as any)) {
-          const rec: any = new RecurseVal({ target: [...this.peg] } as any, ctx)
+          const rec: any = new RecurseVal(
+            { target: [...this.peg], xc: this.rxc } as any, ctx)
           rec.site = this.site
           rec.path = [...this.path]
           out = rec
@@ -653,7 +663,31 @@ class RefVal extends FeatureVal {
           const lifted = true !== (ctx as any).argsnap
             || true === out.mark.type || true === out.mark.hide
 
-          out = out.clone(ctx)
+          // A REFERENCE'S COPY OWNS ITS ARGUMENTS (ADR-025). The copy
+          // is a per-destination instance exactly as a spread's or a
+          // generator's is, so ADR-005's rule holds here too: nothing
+          // path-dependent may be shared between two destinations, or
+          // the first destination's resolution answers for them all.
+          // The shallow clone shared a call's ARGUMENTS -- so
+          // `items: [&: $.entities.User]` over a `close({...})` target
+          // gave every element the one inner map, whose path each
+          // element rebased in turn, and the constraint that failed at
+          // element 2 reported element 0's path (use-cases GAP 8).
+          //
+          // A STAGED CALL IS THE EXCEPTION, because it has not decided
+          // yet. Its arguments are still being driven AT ITS OWN SITE
+          // (the staging rule, G8 phase 0), and a copy that owned them
+          // would drive its own set at the referring position instead:
+          // the relative `.side_effect` in a `match()` would read the
+          // referring field's siblings (use-cases/09-agent-tools), and
+          // an alias naming an `emit` rule table -- a template, which
+          // is exactly a value copied before it resolves -- would read
+          // its recursive `%w` as a self-reference. A staged call
+          // ANYWHERE in the target counts: what is referenced is
+          // usually the conjunct the call sits in, not the call.
+          // The copy shares what the source is still settling, and
+          // owns the rest.
+          out = out.clone(ctx, { dup: !out.holdsStaged })
 
           if (lifted) {
             walk(out, (_key: string | number | undefined, val: Val) => {
@@ -805,6 +839,10 @@ class RefVal extends FeatureVal {
       ...(spec || {})
     }) as RefVal)
     out.expansion = this.expansion
+    // The recursion seed travels with the clone: a spread template is
+    // cloned per destination, and each clone's residual must start
+    // where the level it came from left off.
+    out.rxc = this.rxc
     return out
   }
 

package/src/val/ReferFuncVal.ts

@@ -290,13 +290,25 @@ class ReferVal extends FeatureVal {
   // resolved string should take.
   settle(ctx: AontuContext, site: Val): Val {
     if (undefined === this.addr) {
-      // NOT DONE, unlike `string` or `min(1)`. A refer without an
-      // address has not done its work — it exists to check one — and
-      // the pass loop must keep offering it the chance. The cost is
-      // that a SCHEMA mentioning a link never resolves either, so
-      // `type({from: refer($.std.Port)})` is not expressible today;
-      // G4 phase 4 records why, and what it would take.
-      this.dc = 0
+      // DONE while unmet, as `string` and `min(1)` are, and as RelVal
+      // has been since it was written (see its constructor). An
+      // ADDRESS-LESS refer has nothing to check yet and nothing to
+      // refuse: it is its own settled residual, and the meet
+      // re-activates it the moment a value arrives, because map
+      // merges build the conjunct regardless.
+      //
+      // NOT-DONE here used to be justified as keeping the pass loop
+      // offering the refer a chance -- but that is the job of the
+      // OTHER pending branch below, where an address exists and its
+      // target has not appeared. This branch has no address to
+      // resolve, so staying not-done bought nothing and cost the
+      // schema idiom: a `type()` body holding a link never settled,
+      // so its mark never transferred, so generation could not skip
+      // the marked subtree and raised `mapval_no_gen` naming the
+      // definition. `type({p: integer})`, `type({p: path()})` and
+      // `type({p: min(1)})` all settled; only a link did not
+      // (aontu-lang/aontu#172, G4 phase 4's recorded cost).
+      this.dc = DONE
       return this
     }
     // The address is a TREE PATH, resolved from the link's own
@@ -477,11 +489,13 @@ class RelVal extends FeatureVal {
     super(spec, ctx)
     this.tval = (spec as any).tval ?? top()
     this.held = (spec as any).held
-    // DONE while unmet, deliberately -- the property refer() lacks and
-    // G4 phase 4 records the cost of: a type() body holding a rel()
+    // DONE while unmet, deliberately: a type() body holding a rel()
     // must SETTLE, or the schema idiom (`dependsOn?: rel($.T)` inside
     // a vocabulary) leaves the type unresolved and every reference to
-    // it deferring forever. An unmet rel is its own settled residual,
+    // it deferring forever. This was the property refer() lacked --
+    // G4 phase 4 recorded the cost -- until 2026-09-07, when an
+    // address-less refer was given it too (#172); the two now settle
+    // by the same rule, which is what the shared reasoning below is. An unmet rel is its own settled residual,
     // like `min(1)`; the meet re-activates it whenever a value
     // arrives, because map merges build the conjunct regardless.
     this.dc = DONE

package/src/val/Val.ts

@@ -44,9 +44,12 @@ type ValSpec = {
   // depth explicitly: `dup: true` makes FuncBaseVal, PrefVal and
   // OpBaseVal clone their inner Vals too, and the bag/junction clones
   // carry the flag down. Set by pack/each template instantiation,
-  // filter condition testing, and spread application (MapVal/
-  // ListVal.spreadClone) — never by the residuation or ref-resolution
-  // clones, whose sharing is pinned behaviour.
+  // filter condition testing, spread application (MapVal/
+  // ListVal.spreadClone), and REFERENCE RESOLUTION of a target that
+  // holds no staged call, whose copy is a per-destination instance
+  // too (ADR-025) — never by the residuation clone, whose sharing is
+  // pinned behaviour, and never by a copy of something still being
+  // settled at its own site, which is what keeps the ghost rows.
   dup?: boolean,
 
 
@@ -440,6 +443,33 @@ abstract class Val {
   }
 
 
+  // A STAGED CALL STANDING ANYWHERE IN THIS VALUE (the `staged` flag,
+  // G8 phase 0). Such a call has not decided: its arguments are still
+  // being driven AT ITS OWN SITE, so a REFERENCE's copy shares it
+  // rather than owning a set of arguments it would drive at the
+  // referring position instead (RefVal.find, ADR-025). Not cached:
+  // unlike isPathDependent this is a fact about the value's current
+  // state, and the whole point is that it stops being true.
+  get holdsStaged(): boolean {
+    if (true === (this as any).staged) {
+      return true
+    }
+    const peg: any = this.peg
+    if (Array.isArray(peg)) {
+      for (let i = 0; i < peg.length; i++) {
+        if (true === peg[i]?.isVal && peg[i].holdsStaged) return true
+      }
+    }
+    else if (null != peg && 'object' === typeof peg) {
+      for (const k in peg) {
+        if (true === peg[k]?.isVal && peg[k].holdsStaged) return true
+      }
+    }
+    const spreadCj = (this as any).spread?.cj as Val | undefined
+    return true === spreadCj?.isVal && (spreadCj as any).holdsStaged
+  }
+
+
   // PUT A MINTED VALUE WHERE THIS ONE STANDS: the site travels, and so
   // does provenance, because the two answer one question. A narrowed
   // disjunction, a lifted kind, a resolved reference -- each is a