aontu 0.40.0 → 0.42.0

package/src/val/MapVal.ts

@@ -8,7 +8,6 @@ import type {
 
 import {
   DONE,
-  SPREAD,
 } from '../type'
 
 import { AontuContext } from '../ctx'
@@ -28,13 +27,13 @@ import {
 } from './top'
 
 
-import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
 
 
 class MapVal extends BagVal {
   isMap = true
+  _canonCache?: string
 
   constructor(
     spec: ValSpec,
@@ -48,23 +47,6 @@ class MapVal extends BagVal {
 
     this.mark.type = !!spec.mark?.type
     this.mark.hide = !!spec.mark?.hide
-
-    let spread = (this.peg as any)[SPREAD]
-    delete (this.peg as any)[SPREAD]
-
-    if (spread) {
-      if ('&' === spread.o) {
-        // TODO: handle existing spread!
-        this.spread.cj =
-          Array.isArray(spread.v) ?
-            1 < spread.v.length ?
-              new ConjunctVal({ peg: spread.v }, ctx) :
-              spread.v[0] :
-            spread.v
-      }
-    }
-
-    // console.log('MAPVAL-ctor', this.type, spec)
   }
 
 
@@ -75,6 +57,23 @@ class MapVal extends BagVal {
 
     const TOP = top()
     peer = peer ?? TOP
+
+    // Fast path: both maps done, no spreads, peer's keys are a
+    // subset of this's keys with the same child references, and
+    // neither side has type/hide marks. No new information.
+    if (this.done && peer instanceof MapVal && peer.done
+        && !this.mark.type && !this.mark.hide
+        && !peer.mark.type && !peer.mark.hide) {
+      let canSkip = true
+      for (const k in peer.peg) {
+        if (this.peg[k] !== peer.peg[k]) {
+          canSkip = false
+          break
+        }
+      }
+      if (canSkip) return this
+    }
+
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Map', this, peer)
 
     let done: boolean = true
@@ -84,13 +83,12 @@ class MapVal extends BagVal {
     let out: MapVal | NilVal = (peer.isTop ? this : new MapVal({ peg: {} }, ctx))
 
     out.closed = this.closed
-    out.optionalKeys = [...this.optionalKeys]
-    out.spread.cj = this.spread.cj
+    out.optionalKeys = 0 < this.optionalKeys.length ? [...this.optionalKeys] : this.optionalKeys
     out.site = this.site
 
     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,56 +103,50 @@ 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
         }
-
       }
-
-      if (!exit) {
-        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') }),
-              out.spread.cj, peer.spread.cj, 'map-self')
-          )
-        )
-      }
-    }
-    else {
-      // console.log('MAPVAL-PEER-OTHER', this.id, this.canon, this.done, peer.id, peer.canon, peer.done)
     }
 
 
     if (!exit) {
       out.dc = this.dc + 1
 
-      // let newtype = this.type || peer.type
-
-      let spread_cj = out.spread.cj ?? TOP
+      // Fast path: self-unify with TOP.
+      // If all children are already done, the map is fully converged.
+      if (peer.isTop) {
+        let allChildrenDone = true
+        for (let key in this.peg) {
+          if (DONE !== this.peg[key]?.dc) {
+            allChildrenDone = false
+            break
+          }
+        }
+        if (allChildrenDone) {
+          out.dc = DONE
+          ctx.explain && explainClose(te, out)
+          return out
+        }
+      }
 
-      // Always unify own children first
+      // Unify own children
       for (let key in this.peg) {
-        const keyctx = ctx.descend(key)
-
-        const key_spread_cj = spread_cj.spreadClone(keyctx)
         const child = this.peg[key]
+        const keyctx = ctx.descend(key)
 
         propagateMarks(this, child)
 
         out.peg[key] =
-          undefined === child ? key_spread_cj :
+          undefined === child ? top() :
             child.isNil ? child :
-              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) }),
-                      child, key_spread_cj, 'map-own')
+              child.done ? child :
+                unite(te ? keyctx.clone({ explain: ec(te, 'KEY:' + key) }) : keyctx,
+                  child, top(), 'map-own')
 
         done = (done && DONE === out.peg[key].dc)
       }
 
-      const allowedKeys: string[] = this.closed ? Object.keys(this.peg) : []
       let bad: NilVal | undefined = undefined
 
       if (peer instanceof MapVal) {
@@ -165,12 +157,14 @@ class MapVal extends BagVal {
         for (let peerkey in upeer.peg) {
           let peerchild = upeer.peg[peerkey]
 
-          if (this.closed && !allowedKeys.includes(peerkey)) {
+          if (this.closed && !(peerkey in this.peg)) {
             bad = makeNilErr(ctx, 'closed', peerchild, undefined)
           }
 
           // key optionality is additive
-          if (upeer.optionalKeys.includes(peerkey) && !out.optionalKeys.includes(peerkey)) {
+          if (0 < upeer.optionalKeys.length
+              && upeer.optionalKeys.includes(peerkey)
+              && !out.optionalKeys.includes(peerkey)) {
             out.optionalKeys.push(peerkey)
           }
 
@@ -180,19 +174,11 @@ class MapVal extends BagVal {
 
           let oval = out.peg[peerkey] =
             undefined === child ? this.handleExpectedVal(peerkey, peerchild, this, ctx) :
-              child.isTop && peerchild.done ? peerchild :
-                child.isNil ? child :
-                  peerchild.isNil ? peerchild :
-                    unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
-                      child, peerchild, 'map-peer')
-
-          if (this.spread.cj) {
-            let key_spread_cj = spread_cj.spreadClone(peerctx)
-
-            oval = out.peg[peerkey] =
-              unite(te ? peerctx.clone({ explain: ec(te, 'PSP:' + peerkey) }) : peerctx,
-                oval, key_spread_cj, 'map-peer-spread')
-          }
+                child.isTop && peerchild.done ? peerchild :
+                  child.isNil ? child :
+                    peerchild.isNil ? peerchild :
+                      unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
+                        child, peerchild, 'map-peer')
 
           propagateMarks(this, oval)
 
@@ -213,58 +199,41 @@ class MapVal extends BagVal {
         out.dc = done ? DONE : out.dc
         propagateMarks(peer, out)
         propagateMarks(this, out)
+
       }
     }
 
-    // console.log(
-    //   'MAPVAL-OUT', out.canon,
-    //   '\n  SELF', this,
-    //   '\n  PEER', peer,
-    //   '\n  OUT', out,
-    //   '\n  FROM', (out as any).spread.cj
-    // )
-
     ctx.explain && explainClose(te, out)
 
     return out
   }
 
 
-  // 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.
+  // Optimized clone for use as a spread constraint: share
+  // path-independent children, clone only path-dependent ones.
   spreadClone(ctx: AontuContext): Val {
-    let allScalarKind = true
-    for (let key in this.peg) {
-      if (!(this.peg[key] as any)?.isScalarKind) {
-        allScalarKind = false
-        break
-      }
-    }
-
-    if (!allScalarKind) {
-      return this.clone(ctx)
-    }
+    if (!this.isPathDependent) return this
 
     let out = (super.clone(ctx) as MapVal)
     out.peg = {}
 
     for (let entry of Object.entries(this.peg)) {
-      out.peg[entry[0]] = entry[1]
-    }
-
-    // Must create a new spread object to avoid mutating the original.
-    out.spread = {
-      cj: this.spread.cj ? this.spread.cj.spreadClone(ctx) : undefined,
+      const child = entry[1] as Val
+      if (child?.isVal && child.isPathDependent) {
+        out.peg[entry[0]] = child.clone(ctx, { path: [...out.path, entry[0]] })
+      }
+      else if (child?.isVal) {
+        const wrapper = Object.create(child)
+        wrapper.mark = { ...child.mark }
+        out.peg[entry[0]] = wrapper
+      }
+      else {
+        out.peg[entry[0]] = child
+      }
     }
 
     out.closed = this.closed
-    out.optionalKeys = [...this.optionalKeys]
+    out.optionalKeys = 0 < this.optionalKeys.length ? [...this.optionalKeys] : this.optionalKeys
 
     return out
   }
@@ -277,36 +246,25 @@ class MapVal extends BagVal {
     for (let entry of Object.entries(this.peg)) {
       out.peg[entry[0]] =
         (entry[1] as any)?.isVal ?
-          // (entry[1] as Val).clone(ctx, spec?.mark ? { mark: spec.mark } : {}) :
           (entry[1] as Val).clone(ctx, {
             mark: spec?.mark ?? {},
             path: [...out.path, entry[0]]
           }) :
           entry[1]
     }
-    if (this.spread.cj) {
-      out.spread.cj = this.spread.cj.clone(ctx, spec?.mark ? { mark: spec.mark } : {})
-    }
 
     out.closed = this.closed
     out.optionalKeys = [...this.optionalKeys]
 
-    // out.from = this.from
-
-    // console.log('MAPVAL-CLONE', this.canon, '->', out.canon)
     return out
   }
 
 
   get canon() {
-    let keys = Object.keys(this.peg)
-    return '' +
-      // this.errcanon() +
-      // (this.mark.type ? '<type>' : '') +
-      // (this.id + '=') +
+    if (this._canonCache !== undefined) return this._canonCache
+    let keys = Object.keys(this.peg).sort()
+    const c = '' +
       '{' +
-      (this.spread.cj ? '&:' + this.spread.cj.canon +
-        (0 < keys.length ? ',' : '') : '') +
       keys
         .map(k => [
           JSON.stringify(k) +
@@ -315,18 +273,19 @@ class MapVal extends BagVal {
           (this.peg[k]?.canon ?? this.peg[k])
         ])
         .join(',') +
-      '}' // + '<' + (this.mark.hide ? 'H' : '') + '>'
-
+      '}'
+    if (this.done) this._canonCache = c
+    return c
   }
 
 
-  inspection(d?: number) {
-    return this.spread.cj ? '&:' + this.spread.cj.inspect(null == d ? 0 : d + 1) : ''
+  inspection(_d?: number) {
+    return ''
   }
 
 }
 
 
 export {
-  MapVal
+  MapVal,
 }

package/src/val/MoveFuncVal.ts

@@ -13,6 +13,7 @@ import {
 import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
+import { PathVal } from '../val/PathVal'
 
 import {
   walk
@@ -26,6 +27,60 @@ import { PrefFuncVal } from './PrefFuncVal'
 
 
 
+// Navigate the tree using a PathVal's resolved path and hide the source.
+function hideAtPath(root: Val, pv: PathVal) {
+  // Compute the refpath the same way PathVal.find does
+  const parts: string[] = []
+  for (const part of pv.peg) {
+    if ('string' === typeof part) parts.push(part)
+  }
+
+  let refpath: string[]
+  if (pv.absolute) {
+    refpath = parts
+  }
+  else {
+    refpath = pv.path.slice(0, -1).concat(parts)
+  }
+
+  // Walk to the source, handling conjuncts/disjuncts
+  let node: any = root
+  for (let i = 0; i < refpath.length; i++) {
+    const part = refpath[i]
+    if (node?.isMap || node?.isList) {
+      node = node.peg[part]
+    }
+    else if (node?.isConjunct || node?.isDisjunct) {
+      // Search junction terms for the key
+      let found = null
+      const stack = [...node.peg]
+      while (stack.length > 0) {
+        const term = stack.pop()
+        if (term?.isConjunct || term?.isDisjunct) {
+          stack.push(...term.peg)
+        }
+        else if ((term?.isMap || term?.isList) && term.peg[part] != null) {
+          found = term.peg[part]
+          break
+        }
+      }
+      node = found
+    }
+    else {
+      return
+    }
+    if (node == null) return
+  }
+
+  // Mark the source value hidden
+  node.mark.hide = true
+  walk(node, (_key: string | number | undefined, val: Val) => {
+    val.mark.hide = true
+    return val
+  })
+}
+
+
 class MoveFuncVal extends FuncBaseVal {
   isMoveFunc = true
 
@@ -50,30 +105,40 @@ class MoveFuncVal extends FuncBaseVal {
   }
 
   resolve(ctx: AontuContext, args: Val[]) {
-    let out = args[0] ?? makeNilErr(ctx, 'arg', this)
+    let arg = args[0] ?? makeNilErr(ctx, 'arg', this)
+    if (arg.isNil) return arg
 
-    const orig = out
+    let src: Val
 
-    if (!orig.isNil) {
-      const src = orig.clone(ctx)
+    if (arg instanceof PathVal) {
+      // Get clone for the destination
+      src = arg.find(ctx) as Val
+      if (src == null || src.isNil) return makeNilErr(ctx, 'arg', this)
 
-      if (src.isRef) {
-        src.mark._hide_found = true
-      }
+      // Hide the source in the tree by navigating to it
+      hideAtPath(ctx.root as Val, arg)
+    }
+    else {
+      src = arg.clone(ctx)
 
-      walk(orig, (_key: string | number | undefined, val: Val) => {
+      // Hide the original
+      arg.mark.hide = true
+      walk(arg, (_key: string | number | undefined, val: Val) => {
         val.mark.hide = true
         return val
       })
-
-      // out = new CopyFuncVal({ peg: [src] }, ctx)
-      out = new PrefFuncVal({ peg: [src] }, ctx)
-      // out = src
     }
 
-    // console.log('MOVE-resolve', orig, out)
+    // Clear marks on the clone (like copy)
+    src.mark.type = false
+    src.mark.hide = false
+    walk(src, (_key: string | number | undefined, val: Val) => {
+      val.mark.type = false
+      val.mark.hide = false
+      return val
+    })
 
-    return out
+    return new PrefFuncVal({ peg: [src] }, ctx)
   }
 }
 

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/PathFuncVal.ts

@@ -6,6 +6,10 @@ import type {
   ValSpec,
 } from '../type'
 
+import {
+  DONE,
+} from '../type'
+
 import {
   AontuContext,
 } from '../ctx'
@@ -13,7 +17,7 @@ import {
 import { makeNilErr } from '../err'
 
 import { NilVal } from '../val/NilVal'
-import { RefVal } from '../val/RefVal'
+import { PathVal } from '../val/PathVal'
 import { FuncBaseVal } from './FuncBaseVal'
 
 
@@ -45,12 +49,26 @@ class PathFuncVal extends FuncBaseVal {
     let arg = args[0]
 
     if (0 === this.prepared) {
-      if (arg.isScalar) {
-        arg = this.place(new RefVal({ peg: [arg], absolute: false }))
+      if (arg instanceof PathVal) {
+        // PathVal from dotted arg — resolve via find().
+        const found = arg.find(ctx)
+        if (found != null && !found.isNil) {
+          arg = found
+        }
+        else {
+          arg.dc = DONE
+        }
+      }
+      else if (arg.isScalar && arg.peg != null && arg.peg !== ''
+        && ('string' === typeof arg.peg || arg.isNumber)) {
+        // String or number arg like path("foo") or path(0.2) — create a path value
+        arg = this.place(new PathVal({ peg: [arg], absolute: false })) as PathVal
+        arg.dc = DONE
       }
-      else if (!arg.isRef) {
+      else if (arg.isNil || (arg.isScalar && (arg.peg === '' || arg.peg == null))) {
         arg = makeNilErr(ctx, 'invalid-arg', this)
       }
+      // else: already resolved by preprocessing — pass through
     }
 
     args[0] = arg
@@ -64,6 +82,13 @@ class PathFuncVal extends FuncBaseVal {
   resolve(ctx: AontuContext, args: Val[]) {
     let out = args[0] ?? makeNilErr(ctx, 'arg', this)
 
+    if (out instanceof PathVal) {
+      const found = out.find(ctx)
+      if (found != null && !found.isNil) {
+        out = found
+      }
+    }
+
     return out
   }