aontu 0.40.0 → 0.41.0

package/src/unify.ts

@@ -32,6 +32,34 @@ const MAXCYCLE = 999
 // Vals should only have to unify downwards (in .unify) over Vals they understand.
 // and for complex Vals, TOP, which means self unify if not yet done
 const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
+  // Fast paths that don't recurse and so don't need cycle-detection:
+  // short-circuit before the saw-key build and seen-map lookup (which
+  // together cost ~2.5µs per call). Only return early when the result
+  // is already `done` — a non-done result would need the trailing
+  // top() unify below.
+  //
+  //   A6a: same ref, already done
+  //   A6b: different ref but same id + both done
+  //   P1:  exact-equal scalars that are already done (14% of calls
+  //        in foo-sdk, ~100% with a.done=true)
+  if (a !== undefined && a !== null) {
+    if (a === b) {
+      if (a.done) return a
+    }
+    else if (b !== undefined && b !== null) {
+      if (a.done && b.done) {
+        if (a.id === b.id) return a
+        if (a.constructor === b.constructor && a.peg === b.peg
+            && !a.isNil && !b.isNil
+            && !a.isMap && !a.isList
+            && !a.isConjunct && !a.isDisjunct
+            && !a.isRef && !a.isPref && !a.isFunc && !a.isExpect) {
+          return a
+        }
+      }
+    }
+  }
+
   const te = ctx.explain && explainOpen(ctx, ctx.explain, 'unite', a, b)
 
   let out = a
@@ -56,63 +84,67 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
     ctx.seen[saw] = sawCount + 1
 
     try {
-
       let unified = false
 
-      if (b && (!a || a.isTop)) {
+      // Dispatch ladder. Structure note:
+      //   - `a == null` is degenerate (shouldn't happen in practice:
+      //     the top-level call seeds with a real Val). Kept for safety.
+      //   - TOP is the unit element: unifying with it returns the
+      //     other side. Handle both sides.
+      //   - Otherwise route by Val type. Complex Vals (Conjunct,
+      //     Disjunct, Ref, Pref, Func, Expect) have their own unify
+      //     that knows how to absorb the peer; prefer `a.unify` when
+      //     `a` is complex, else `b.unify` when `b` is complex. If
+      //     neither is complex and it's not a plain-scalar match, fall
+      //     through to the generic `a.unify` (concrete Val classes
+      //     each handle their own peer case).
+      if (a == null) {
         out = b
         why = 'b'
       }
-
-      else if (a && (!b || b.isTop)) {
+      else if (b == null || b.isTop) {
         out = a
         why = 'a'
       }
-
-      else if (a && b && !b.isTop) {
-        if (a.isNil) {
-          out = update(a, b)
-          why = 'an'
-        }
-        else if (b.isNil) {
-          out = update(b, a)
-          why = 'bn'
-        }
-        else if (a.isConjunct) {
-          out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'CJ') }) : ctx)
-          unified = true
-          why = 'acj'
-        }
-        else if (a.isExpect) {
-          out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'AE') }) : ctx)
-          unified = true
-          why = 'ae'
-        }
-        else if (
-          b.isConjunct
-          || b.isDisjunct
-          || b.isRef
-          || b.isPref
-          || b.isFunc
-          || b.isExpect
-        ) {
-
-          out = b.unify(a, te ? ctx.clone({ explain: ec(te, 'BW') }) : ctx)
-          unified = true
-          why = 'bv'
-        }
-
-        // Exactly equal scalars.
-        else if (a.constructor === b.constructor && a.peg === b.peg) {
-          out = update(a, b)
-          why = 'up'
-        }
-
-        else {
-          out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'GN') }) : ctx)
-          unified = true
-          why = 'ab'
-        }
+      else if (a.isTop) {
+        out = b
+        why = 'b'
+      }
+      else if (a.isNil) {
+        out = update(a, b)
+        why = 'an'
+      }
+      else if (b.isNil) {
+        out = update(b, a)
+        why = 'bn'
+      }
+      else if (a.isConjunct || a.isExpect) {
+        out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'AC') }) : ctx)
+        unified = true
+        why = 'a*'
+      }
+      else if (
+        b.isConjunct
+        || b.isDisjunct
+        || b.isRef
+        || b.isPref
+        || b.isFunc
+        || b.isExpect
+      ) {
+        out = b.unify(a, te ? ctx.clone({ explain: ec(te, 'BW') }) : ctx)
+        unified = true
+        why = 'bv'
+      }
+      // Exactly equal scalars (not caught by early fast-path — e.g.
+      // because a or b isn't .done yet).
+      else if (a.constructor === b.constructor && a.peg === b.peg) {
+        out = update(a, b)
+        why = 'up'
+      }
+      else {
+        out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'GN') }) : ctx)
+        unified = true
+        why = 'ab'
       }
 
       if (!out || !out.unify) {
@@ -120,19 +152,16 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
         why += 'N'
       }
 
-      // console.log('UNITE-DONE', out.id, out.canon, out.done)
-
-      // if (DONE !== out.dc && !unified) {
+      // Any non-done top-level result self-unifies with TOP to ensure
+      // its children finish converging. Skipped when `unified` is true
+      // because the branch that set `out = X.unify(Y, ctx)` already
+      // ran that Val's own unify logic.
       if (!out.done && !unified) {
-        let nout = out.unify(top(), te ? ctx.clone({ explain: ec(te, 'ND') }) : ctx)
-        out = nout
+        out = out.unify(top(), te ? ctx.clone({ explain: ec(te, 'ND') }) : ctx)
         why += 'T'
       }
-
-      // console.log('UNITE', why, a?.id, a?.canon, a?.done, b?.id, b?.canon, b?.done, '->', out?.id, out?.canon, out?.done)
     }
     catch (err: any) {
-      // console.log(err)
       // TODO: handle unexpected
       out = makeNilErr(ctx, 'internal', a, b)
     }

package/src/val/ConjunctVal.ts

@@ -97,7 +97,7 @@ class ConjunctVal extends JunctionVal {
       // console.log('CONJUNCT-TERM', this.id, vI, this.peg[vI].canon)
 
       upeer[vI] = (this.peg[vI].done && peer.isTop) ? this.peg[vI] :
-        unite(ctx.clone({ explain: ec(te, 'OWN') }), this.peg[vI], peer, 'cj-own')
+        unite(te ? ctx.clone({ explain: ec(te, 'OWN') }) : ctx, this.peg[vI], peer, 'cj-own')
 
       upeer[vI].mark.type = newtype = newtype || upeer[vI].mark.type
       upeer[vI].mark.hide = newhide = newhide || upeer[vI].mark.hide
@@ -153,7 +153,7 @@ class ConjunctVal extends JunctionVal {
 
 
       else {
-        val = unite(ctx.clone({ explain: ec(te, 'DEF') }), t0, t1, 'cj-peer-t0t1')
+        val = unite(te ? ctx.clone({ explain: ec(te, 'DEF') }) : ctx, t0, t1, 'cj-peer-t0t1')
         // console.log('CONJUNCT-T', t0.canon, t1?.canon, '->', val.canon)
         done = done && DONE === val.dc
         newtype = this.mark.type || val.mark.type

package/src/val/DisjunctVal.ts

@@ -30,7 +30,7 @@ import {
   top
 } from './top'
 
-import { NilVal } from '../val/NilVal'
+import { NilVal, TRIAL_NIL } from '../val/NilVal'
 import { PrefVal } from '../val/PrefVal'
 import { JunctionVal } from '../val/JunctionVal'
 
@@ -79,21 +79,46 @@ class DisjunctVal extends JunctionVal {
 
     let oval: Val[] = []
 
-    // Conjunction (&) distributes over disjunction (|)
+    // Conjunction (&) distributes over disjunction (|).
+    //
+    // Each member is tried against peer in isolation: if that trial
+    // produces any errors, the member fails and is marked with a NilVal.
+    // Previously this used `ctx?.clone({err: []})` per member - a
+    // per-iteration context clone (two Object.creates) just to hold a
+    // throwaway error array. For schemas with many disjunctions
+    // (e.g. `*true | boolean`, `method: GET | PUT | ...`) this was the
+    // single largest source of clones in the unify hot path.
+    //
+    // Swap-and-restore avoids the clone: the existing ctx's err array
+    // is saved, replaced with a fresh array for each trial, then
+    // restored. ctx mutation is scoped to this loop and fully undone
+    // before return.
+    const savedErr = ctx.err
+    const savedTrialMode = ctx._trialMode
+    // 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
+    // not affected.
+    ctx._trialMode = true
     for (let vI = 0; vI < this.peg.length; vI++) {
       const v = this.peg[vI]
-      const cloneCtx = ctx?.clone({ err: [] })
+      const trialErr: any[] = []
+      ctx.err = trialErr
 
-      // // // console.log('DJ-DIST-A', this.peg[vI].canon, peer.canon)
-      oval[vI] = unite(cloneCtx.clone({ explain: ec(te, 'DIST:' + vI) }), v, peer, 'dj-peer')
-      // // // console.log('DJ-DIST-B', oval[vI].canon, cloneCtx?.err)
+      oval[vI] = unite(te ? ctx.clone({ explain: ec(te, 'DIST:' + vI) }) : ctx, v, peer, 'dj-peer')
 
-      if (0 < cloneCtx?.err.length) {
-        oval[vI] = makeNilErr(cloneCtx, '|:empty-dist', this)
+      if (0 < trialErr.length) {
+        // C1: failed-trial marker is never user-visible — it just
+        // signals "this disjunct member doesn't match" and is
+        // filtered out before the result is built. Use the shared
+        // sentinel instead of allocating a fresh NilVal per trial.
+        oval[vI] = TRIAL_NIL
       }
 
       done = done && DONE === oval[vI].dc
     }
+    ctx._trialMode = savedTrialMode
+    ctx.err = savedErr
 
     // // // console.log('DISJUNCT-unify-B', this.id, oval.map(v => v.canon))
 
@@ -107,12 +132,13 @@ class DisjunctVal extends JunctionVal {
 
       // // // console.log('DISJUNCT-unify-C', this.id, oval.map(v => v.id + '=' + v.canon))
 
-      // TODO: not an error Nil!
-      let remove = new NilVal()
+      // Dedup: duplicate Vals in the disjunct are replaced with the
+      // trial sentinel, which is filtered out a few lines below.
+      // (No need for a fresh NilVal — any isNil value gets filtered.)
       for (let vI = 0; vI < oval.length; vI++) {
         for (let kI = vI + 1; kI < oval.length; kI++) {
           if (oval[kI].same(oval[vI])) {
-            oval[kI] = remove
+            oval[kI] = TRIAL_NIL
           }
         }
       }

package/src/val/ExpectVal.ts

@@ -49,10 +49,10 @@ class ExpectVal extends FeatureVal {
 
     if (!peer.isTop) {
       this.peer = undefined === this.peer ? peer :
-        unite(ctx.clone({ explain: ec(te, 'PEER') }), this.peer, peer, 'expect-peer')
+        unite(te ? ctx.clone({ explain: ec(te, 'PEER') }) : ctx, this.peer, peer, 'expect-peer')
 
       const peeru =
-        unite(ctx.clone({ explain: ec(te, 'EXPECT') }), this.peer, this.peg, 'expect-self')
+        unite(te ? ctx.clone({ explain: ec(te, 'EXPECT') }) : ctx, this.peer, this.peg, 'expect-self')
 
       if (peeru.isGenable) {
         out = peeru

package/src/val/FuncBaseVal.ts

@@ -100,7 +100,7 @@ class FuncBaseVal extends FeatureVal {
 
             let newarg = arg
             if (!arg.done) {
-              newarg = arg.unify(TOP, ctx.clone({ explain: ec(te, 'ARG') }))
+              newarg = arg.unify(TOP, te ? ctx.clone({ explain: ec(te, 'ARG') }) : ctx)
               newtype = newtype || newarg.mark.type
               newhide = newhide || newarg.mark.hide
               // console.log('FUNCBASE-UNIFY-PEG-B', arg.canon, arg.done, '->', newarg.canon, newarg.done)
@@ -118,7 +118,7 @@ class FuncBaseVal extends FeatureVal {
           // console.log('FUNC-RESOLVED', ctx.cc, resolved?.canon)
 
           out = resolved.done && peer.isTop ? resolved :
-            unite(ctx.clone({ explain: ec(te, 'PEG') }),
+            unite(te ? ctx.clone({ explain: ec(te, 'PEG') }) : ctx,
               resolved, peer, 'func-' + this.funcname() + '/' + this.id)
           propagateMarks(this, out)
 

package/src/val/IntegerVal.ts

@@ -43,7 +43,7 @@ class IntegerVal extends ScalarVal {
 
     if (null != peer) {
       if (peer.isScalarKind) {
-        out = peer.unify(this, ctx.clone({ explain: ec(te, 'KND') }))
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'KND') }) : ctx)
       }
       else if (
         peer.isScalar &&

package/src/val/ListVal.ts

@@ -92,7 +92,7 @@ class ListVal extends BagVal {
 
     if (peer instanceof ListVal) {
       if (!this.closed && peer.closed) {
-        out = peer.unify(this, ctx.clone({ explain: ec(te, 'PMC') })) as ListVal
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'PMC') }) : ctx) as ListVal
         exit = true
       }
       else {
@@ -100,7 +100,7 @@ class ListVal extends BagVal {
         out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
           null == peer.spread.cj ? out.spread.cj : (
             out.spread.cj =
-            unite(ctx.clone({ explain: ec(te, 'SPR') }),
+            unite(te ? ctx.clone({ explain: ec(te, 'SPR') }) : ctx,
               out.spread.cj, peer.spread.cj, 'list-peer')
           )
         )
@@ -127,7 +127,7 @@ class ListVal extends BagVal {
               key_spread_cj.isNil ? key_spread_cj :
                 key_spread_cj.isTop && child.done ? child :
                   child.isTop && key_spread_cj.done ? key_spread_cj :
-                    unite(keyctx.clone({ explain: ec(te, 'PEG:' + key) }),
+                    unite(te ? keyctx.clone({ explain: ec(te, 'PEG:' + key) }) : keyctx,
                       child, key_spread_cj, 'list-own')
 
         done = (done && DONE === out.peg[key].dc)
@@ -205,6 +205,10 @@ class ListVal extends BagVal {
   // always done, never path-dependent, and never has marks mutated.
   // For anything more complex, fall back to full deep clone.
   spreadClone(ctx: AontuContext): Val {
+    // B1: share directly when the spread tree has no path-dependent
+    // leaves. See MapVal.spreadClone for rationale.
+    if (!this.isPathDependent) return this
+
     let allScalarKind = true
     for (let key in this.peg) {
       if (!(this.peg[key] as any)?.isScalarKind) {

package/src/val/MapVal.ts

@@ -90,7 +90,7 @@ class MapVal extends BagVal {
 
     if (peer instanceof MapVal) {
       if (!this.closed && peer.closed) {
-        out = peer.unify(this, ctx.clone({ explain: ec(te, 'PMC') })) as MapVal
+        out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'PMC') }) : ctx) as MapVal
         exit = true
       }
 
@@ -105,7 +105,7 @@ class MapVal extends BagVal {
             && peerkeys.join('~') < selfkeys.join('~')
           )
         ) {
-          out = peer.unify(this, ctx.clone({ explain: ec(te, 'SPC') })) as MapVal
+          out = peer.unify(this, te ? ctx.clone({ explain: ec(te, 'SPC') }) : ctx) as MapVal
           exit = true
         }
 
@@ -115,7 +115,7 @@ class MapVal extends BagVal {
         out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
           null == peer.spread.cj ? out.spread.cj : (
             out.spread.cj =
-            unite(ctx.clone({ explain: ec(te, 'SPR') }),
+            unite(te ? ctx.clone({ explain: ec(te, 'SPR') }) : ctx,
               out.spread.cj, peer.spread.cj, 'map-self')
           )
         )
@@ -148,7 +148,7 @@ class MapVal extends BagVal {
               key_spread_cj.isNil ? key_spread_cj :
                 key_spread_cj.isTop && child.done ? child :
                   child.isTop && key_spread_cj.done ? key_spread_cj :
-                    unite(keyctx.clone({ explain: ec(te, 'KEY:' + key) }),
+                    unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
                       child, key_spread_cj, 'map-own')
 
         done = (done && DONE === out.peg[key].dc)
@@ -230,15 +230,23 @@ class MapVal extends BagVal {
   }
 
 
-  // Spread clone: only deep-clone children that are path-dependent
-  // (isFunc, isRef). Share all other children directly to avoid
-  // N x M allocations for maps with N keys and M spread fields.
-  // Spread clone: when all children are ScalarKindVal (simple type
-  // constraints like `string`, `number`), share them directly to avoid
-  // N x M allocations. ScalarKindVal is safe to share: it is immutable,
-  // always done, never path-dependent, and never has marks mutated.
-  // For anything more complex, fall back to full deep clone.
+  // Spread clone: return a Val usable as the per-key spread constraint.
+  //
+  // Three tiers:
+  //   1. tree is path-independent (no RefVal/KeyFuncVal/PathFuncVal/
+  //      MoveFuncVal/SuperFuncVal anywhere below): return `this` directly.
+  //      Nothing in the unify path mutates the spread root, and no
+  //      child depends on its own stored .path, so sharing is safe.
+  //   2. top-level children are all ScalarKindVal: shallow clone
+  //      (share children, fresh MapVal wrapper).
+  //   3. otherwise: full deep clone via `this.clone(ctx)`.
+  //
+  // Tier 1 handles the foo-sdk common case of simple type-constraint
+  // spreads like `&:{active: *true | boolean, version: *'0.0.1' | string}`,
+  // which are cloned thousands of times per run.
   spreadClone(ctx: AontuContext): Val {
+    if (!this.isPathDependent) return this
+
     let allScalarKind = true
     for (let key in this.peg) {
       if (!(this.peg[key] as any)?.isScalarKind) {

package/src/val/NilVal.ts

@@ -16,7 +16,7 @@ import {
 
 import { Val, EMPTY_ERR } from './Val'
 
-import { AontuError } from '../err'
+import { AontuError, descErr } from '../err'
 
 
 class NilVal extends Val {
@@ -142,6 +142,9 @@ class NilVal extends Val {
     ctx.adderr(this)
 
     if (!ctx.collect) {
+      if (null == this.msg || '' === this.msg) {
+        descErr(this, ctx)
+      }
       const err = new AontuError(this.msg, [this])
       throw err
     }
@@ -162,6 +165,19 @@ class NilVal extends Val {
 }
 
 
+// Shared sentinel for transient "this unification branch failed"
+// markers. Used by DisjunctVal.unify to flag failed member trials
+// (and to dedup results) without allocating a fresh NilVal per
+// failure. The sentinel is filtered out before the disjunct result
+// is constructed, so its .why / .site / .primary fields are never
+// inspected by user-visible code.
+//
+// Do NOT use this sentinel for errors that may surface: those need
+// real NilVals with proper site/path info for descErr formatting.
+const TRIAL_NIL = new NilVal({ why: '|:trial-nil' })
+
+
 export {
   NilVal,
+  TRIAL_NIL,
 }

package/src/val/OpBaseVal.ts

@@ -117,7 +117,7 @@ class OpBaseVal extends FeatureVal {
       }
       else {
         out = result.done && peer.isTop ? result :
-          unite(ctx.clone({ explain: ec(te, 'RES') }), result, peer, 'op')
+          unite(te ? ctx.clone({ explain: ec(te, 'RES') }) : ctx, result, peer, 'op')
       }
 
       out.dc = DONE === out.dc ? DONE : this.dc + 1

package/src/val/PrefVal.ts

@@ -62,7 +62,7 @@ class PrefVal extends FeatureVal {
     let why = ''
 
     if (!this.peg.done) {
-      const resolved = unite(ctx.clone({ explain: ctx.explain && ec(te, 'RES') }),
+      const resolved = unite(te ? ctx.clone({ explain: ec(te, 'RES') }) : ctx,
         this.peg, top(), 'pref/resolve')
       // console.log('PREF-RESOLVED', this.peg.canon, '->', resolved)
       this.peg = resolved
@@ -96,7 +96,7 @@ class PrefVal extends FeatureVal {
         //   peer.peg.id, peer.peg, peer.peg.done,
         // )
 
-        let peg = unite(ctx.clone({ explain: ctx.explain && ec(te, 'PREF-PEER') }),
+        let peg = unite(te ? ctx.clone({ explain: ec(te, 'PREF-PEER') }) : ctx,
           this.peg, peer.peg, 'pref-peer/' + this.id)
         out = new PrefVal({ peg }, ctx)
         // console.log('PREF-RANK-SAME-OUT', peg, peg.done, out, out.done)
@@ -106,7 +106,7 @@ class PrefVal extends FeatureVal {
     else if (!peer.isTop) {
       why += 'super-'
 
-      out = unite(ctx.clone({ explain: ctx.explain && ec(te, 'SUPER') }),
+      out = unite(te ? ctx.clone({ explain: ec(te, 'SUPER') }) : ctx,
         this.superpeg, peer, 'pref-super/' + this.id)
       if (out.same(this.superpeg)) {
         out = this.peg

package/src/val/RefVal.ts

@@ -177,7 +177,7 @@ class RefVal extends FeatureVal {
         }
       }
       else {
-        out = unite(ctx.clone({ explain: ec(te, 'RES') }), resolved, peer, 'ref')
+        out = unite(te ? ctx.clone({ explain: ec(te, 'RES') }) : ctx, resolved, peer, 'ref')
         why = 'u'
       }