aontu 0.41.0 → 0.42.0

package/src/unify.ts

@@ -10,6 +10,9 @@ import { DONE } from './type'
 import { makeNilErr } from './err'
 
 import { NilVal } from './val/NilVal'
+import { StringVal } from './val/StringVal'
+import { PathVal } from './val/PathVal'
+import { KeyFuncVal } from './val/KeyFuncVal'
 
 import {
   Lang
@@ -26,8 +29,9 @@ import {
 } from './val/top'
 
 
+
 // TODO: FIX: false positive when too many top unifications
-const MAXCYCLE = 999
+const MAXCYCLE = 9999
 
 // 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
@@ -50,12 +54,19 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
       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) {
+          && !a.isNil && !b.isNil
+          && !a.isConjunct && !a.isDisjunct
+          && !a.isPath && !a.isPref && !a.isFunc && !a.isExpect) {
           return a
         }
+
+        // Id-keyed cache: reuse results for the exact same Val pair.
+        const uc = ctx._uniteCache
+        if (uc !== undefined) {
+          const ucKey = a.id + '|' + b.id
+          const ucHit = uc.get(ucKey)
+          if (ucHit !== undefined) return ucHit
+        }
       }
     }
   }
@@ -67,21 +78,25 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
 
   // Cycle-detection key. Use numeric path index for speed; fall back to
   // full string key when debug is enabled so the saw value is human-readable.
-  const saw = ctx.opts.debug
-    ? (a ? a.id + (a.done ? '' : '*') : '') + '~' +
+  let saw: string
+  if (ctx.opts.debug) {
+    saw = (a ? a.id + (a.done ? '' : '*') : '') + '~' +
       (b ? b.id + (b.done ? '' : '*') : '') + '@' + ctx.pathstr
-    : (a ? a.id + (a.done ? 'd' : '') : 0) + '~' +
+  }
+  else {
+    saw = (a ? a.id + (a.done ? 'd' : '') : 0) + '~' +
       (b ? b.id + (b.done ? 'd' : '') : 0) + '~' + ctx.pathidx
+  }
 
   // NOTE: if this error occurs "unreasonably", attemp to avoid unnecesary unification
   // See for example PrefVal peg.id equality inspection.
-  const sawCount = ctx.seen[saw] ?? 0
+  const sawCount = ctx.seen.get(saw) ?? 0
   if (MAXCYCLE < sawCount) {
     // console.log('SAW', sawCount, saw, a?.id, a?.canon, b?.id, b?.canon, ctx.cc)
     out = makeNilErr(ctx, 'unify_cycle', a, b)
   }
   else {
-    ctx.seen[saw] = sawCount + 1
+    ctx.seen.set(saw, sawCount + 1)
 
     try {
       let unified = false
@@ -118,7 +133,7 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
         out = update(b, a)
         why = 'bn'
       }
-      else if (a.isConjunct || a.isExpect) {
+      else if (a.isConjunct || a.isExpect || a.isSpread) {
         out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'AC') }) : ctx)
         unified = true
         why = 'a*'
@@ -126,10 +141,11 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
       else if (
         b.isConjunct
         || b.isDisjunct
-        || b.isRef
+        || b.isPath
         || b.isPref
         || b.isFunc
         || b.isExpect
+        || b.isSpread
       ) {
         out = b.unify(a, te ? ctx.clone({ explain: ec(te, 'BW') }) : ctx)
         unified = true
@@ -169,6 +185,11 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
 
   ctx.explain && explainClose(te, out)
 
+  // Store in id-keyed cache when both operands were done.
+  if (a?.done && b?.done && out?.done && ctx._uniteCache !== undefined) {
+    ctx._uniteCache.set(a.id + '|' + b.id, out)
+  }
+
   return out
 }
 
@@ -179,6 +200,269 @@ function update(x: Val, _y: Val) {
 }
 
 
+// Resolve all PathVals using the pre-collected paths list.
+// Mutates the tree in place, replacing each PathVal with its cloned target.
+function resolvePaths(root: Val, ctx: AontuContext, paths: PathVal[]) {
+  for (const pv of paths) {
+    if (pv.done) continue
+
+    // Resolve: find target, following chains.
+    // Suppress errors during pre-resolution — intermediate PathVals
+    // (from multi-dot expressions like ..a.q) may fail here but the
+    // final PathVal resolves correctly during unification.
+    const savedErr = ctx.err
+    ctx.err = []
+    let found: any = pv.find(ctx)
+    ctx.err = savedErr
+    if (found == null || found.isNil) continue
+
+    // Skip if target or container contains a mark-setting function
+    // (type/hide/move) — let unification resolve it first.
+    if (hasMarkFunc(found)) continue
+    if (hasMarkFuncAtPath(root, pv.path)) continue
+
+    while (found instanceof PathVal) {
+      if (found.done && found._resolved) {
+        found = found._resolved
+        break
+      }
+      const next = found.find(ctx)
+      if (next == null || next.isNil) break
+      found.dc = DONE
+      found._resolved = next
+      found = next
+    }
+
+    // If found value is a key() function, set its path to the
+    // destination so it evaluates at the right position.
+    if (found.isKeyFunc) {
+      found.path = pv.path
+    }
+
+    pv.dc = DONE
+    pv._resolved = found
+
+    // Replace PathVal in tree using its path
+    replaceAtPath(root, pv.path, pv, found)
+
+    // Walk the placed value to resolve any PathVals cloned into it
+    resolveNestedPaths(found, ctx)
+  }
+}
+
+
+// Check if a value contains a type() or hide() function.
+// Check if the value AT the path position is inside a mark-setting function.
+function hasMarkFuncAtPath(root: Val, path: string[]): boolean {
+  let node: any = root
+  for (let i = 0; i < path.length; i++) {
+    const part = path[i]
+    if (node.isMap || node.isList) {
+      node = node.peg[part]
+    }
+    else if (node.isConjunct || node.isDisjunct) {
+      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 false
+    }
+    if (node == null) return false
+  }
+  return hasMarkFunc(node)
+}
+
+
+function hasMarkFunc(val: any): boolean {
+  if (val == null || !val.isVal) return false
+  if (val.isTypeFunc || val.isHideFunc || val.isMoveFunc) return true
+  if (val.isConjunct || val.isDisjunct) {
+    for (const t of val.peg) {
+      if (hasMarkFunc(t)) return true
+    }
+  }
+  return false
+}
+
+
+// Resolve any PathVals found inside a value (e.g. cloned subtrees).
+// Iterative stack-based walk — no recursion.
+function resolveNestedPaths(val: any, ctx: AontuContext) {
+  const stack: any[] = [val]
+  while (stack.length > 0) {
+    const v = stack.pop()
+    if (v == null || !v.isVal) continue
+
+    if (v.isMap || v.isList) {
+      for (const k in v.peg) {
+        const child = v.peg[k]
+        if (child instanceof PathVal && !child.done) {
+          const found = child.find(ctx)
+          if (found != null && !found.isNil) {
+            v.peg[k] = found
+            child.dc = DONE
+            child._resolved = found
+            stack.push(found)
+          }
+        }
+        else if (child?.isVal) {
+          stack.push(child)
+        }
+      }
+    }
+    else if (v.isConjunct || v.isDisjunct) {
+      for (let i = 0; i < v.peg.length; i++) {
+        const child = v.peg[i]
+        if (child instanceof PathVal && !child.done) {
+          const found = child.find(ctx)
+          if (found != null && !found.isNil) {
+            v.peg[i] = found
+            child.dc = DONE
+            child._resolved = found
+            stack.push(found)
+          }
+        }
+        else if (child?.isVal) {
+          stack.push(child)
+        }
+      }
+    }
+    else if (v.isFeature) {
+      if (v.peg instanceof PathVal && !v.peg.done) {
+        const found = v.peg.find(ctx)
+        if (found != null && !found.isNil) {
+          v.peg.dc = DONE
+          v.peg._resolved = found
+          v.peg = found
+          stack.push(found)
+        }
+      }
+      else if (Array.isArray(v.peg)) {
+        for (let i = 0; i < v.peg.length; i++) {
+          if (v.peg[i]?.isVal) stack.push(v.peg[i])
+        }
+      }
+      else if (v.peg?.isVal) {
+        stack.push(v.peg)
+      }
+    }
+  }
+}
+
+
+// Replace target Val in the tree, using path to navigate and a stack
+// to search through junctions, features, and nested structures.
+// No recursion — uses a single loop with an explicit stack.
+function replaceAtPath(root: Val, path: string[], target: Val, replacement: Val,
+  intoSpreads: boolean = true): boolean {
+  let node: any = root
+
+  // Descend through map/list using path segments.
+  // When a non-map/list is encountered (junction, feature),
+  // push its children onto the search stack and stop descending.
+  let pi = 0
+  for (; pi < path.length; pi++) {
+    if (node.isMap || node.isList) {
+      const child = node.peg[path[pi]]
+      if (child == null) break
+
+      // Last segment: check for direct replacement
+      if (pi === path.length - 1) {
+        if (child === target) {
+          node.peg[path[pi]] = replacement
+          return true
+        }
+        // Target not at this position — search within child
+        node = child
+        pi++
+        break
+      }
+
+      node = child
+    }
+    else {
+      // Hit a non-navigable node — search it
+      break
+    }
+  }
+
+  // If path fully consumed with no match, or hit a junction/feature,
+  // search the current node using a stack.
+  const stack: any[] = [node]
+
+  while (stack.length > 0) {
+    const val = stack.pop()
+    if (val == null || !val.isVal) continue
+
+    if (val.isMap || val.isList) {
+      for (const k in val.peg) {
+        if (val.peg[k] === target) {
+          val.peg[k] = replacement
+          return true
+        }
+        if (val.peg[k]?.isVal) stack.push(val.peg[k])
+      }
+    }
+    else if (val.isConjunct || val.isDisjunct) {
+      for (let i = 0; i < val.peg.length; i++) {
+        if (val.peg[i] === target) {
+          val.peg[i] = replacement
+          return true
+        }
+        stack.push(val.peg[i])
+      }
+    }
+    else if (val.isFeature) {
+      if (val.peg === target) {
+        val.peg = replacement
+        return true
+      }
+      if (intoSpreads || !val.isSpread) {
+        if (Array.isArray(val.peg)) {
+          for (let i = 0; i < val.peg.length; i++) {
+            if (val.peg[i] === target) {
+              val.peg[i] = replacement
+              return true
+            }
+            if (val.peg[i]?.isVal) stack.push(val.peg[i])
+          }
+        }
+        else if (val.peg?.isVal) {
+          stack.push(val.peg)
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+
+// Resolve all KeyFuncVals (not inside spreads) to StringVals.
+// Uses the KeyFuncVal's path to determine the key name.
+function resolveKeys(root: Val, keys: KeyFuncVal[]) {
+  for (const kv of keys) {
+    const resolved = kv.resolve(null as any, kv.peg)
+    if (resolved instanceof StringVal) {
+      resolved.dc = DONE
+      resolved.path = kv.path
+      replaceAtPath(root, kv.path, kv, resolved, false)
+    }
+  }
+}
+
+
 class Unify {
   root: Val
   res: Val
@@ -229,15 +513,28 @@ class Unify {
       uctx.err = this.err
       uctx.explain = this.explain
 
+      // Path resolution phase: replace all PathVals with cloned targets.
+      // Pure structural replacement — no unification.
+      resolvePaths(res, uctx, this.lang.paths)
+      uctx = uctx.clone({ root: res })
+
+      // Key resolution phase: replace key() functions (not in spreads)
+      // with their resolved StringVal.
+      resolveKeys(res, this.lang.keys)
+
       const explain = null == ctx?.explain ? undefined : ctx?.explain
       const te = explain && explainOpen(uctx, explain, 'root', res)
 
       // NOTE: if true === res.done already, then this loop never needs to run.
+      // RefVals defer on cc=0 and while ctx.sc > 0.
+      // SpreadVal.unify maintains ctx.sc via increment/decrement.
       let maxcc = 9 // 99
       for (; this.cc < maxcc && DONE !== res.dc; this.cc++) {
         // console.log('CC', this.cc, res.canon)
         uctx.cc = this.cc
-        uctx.seen = {}
+        uctx.seen = new Map()
+        uctx._refCloneCache = new Map()
+        uctx._uniteCache = new Map()
         res = unite(te ? uctx.clone({ explain: ec(te, 'run') }) : uctx, res, top(), 'unify')
 
         if (0 < uctx.err.length) {

package/src/utility.ts

@@ -11,8 +11,11 @@ function propagateMarks(source: Val, target: Val): void {
   if (source.isTop || target.isTop) {
     return
   }
-  for (let name in source.mark) {
-    (target.mark as any)[name] = (target.mark as any)[name] || (source.mark as any)[name]
+  const sm = source.mark as any
+  if (!sm.type && !sm.hide) return
+  const tm = target.mark as any
+  for (let name in sm) {
+    tm[name] = tm[name] || sm[name]
   }
 }
 

package/src/val/BagVal.ts

@@ -29,10 +29,6 @@ abstract class BagVal extends FeatureVal {
   closed: boolean = false
   optionalKeys: string[] = []
 
-  spread = {
-    cj: (undefined as Val | undefined),
-  }
-
   constructor(
     spec: ValSpec,
     ctx?: AontuContext
@@ -42,7 +38,6 @@ abstract class BagVal extends FeatureVal {
 
   clone(ctx: AontuContext, spec?: ValSpec): Val {
     const bag = super.clone(ctx, spec) as BagVal
-    bag.spread = this.spread
     return bag
   }
 
@@ -92,11 +87,15 @@ abstract class BagVal extends FeatureVal {
         || child.isMap
         || child.isList
         || child.isPref
-        || child.isRef
+        || child.isPath
         || child.isDisjunct
+        || child.isConjunct
         || child.isNil
       ) {
-        let cval = child.gen(ctx)
+        // Optional keys: use separate error context so gen errors
+        // don't propagate when the key is dropped.
+        const genctx = optional ? ctx.clone({ err: [], collect: true }) : ctx
+        let cval = child.gen(genctx)
 
         if (optional && (undefined === cval || empty(cval))) {
           continue

package/src/val/ConjunctVal.ts

@@ -36,6 +36,57 @@ import {
   top
 } from './top'
 
+import { MapVal } from './MapVal'
+
+
+// Shallow merge two MapVals: combine keys without deep unification.
+// For shared keys, merge child terms from both maps into one ConjunctVal
+// so spreads at that level see all children from both terms.
+function shallowMerge(a: MapVal, b: MapVal, ctx: AontuContext): MapVal {
+  const out = new MapVal({ peg: {} }, ctx)
+  out.site = a.site
+  out.closed = a.closed || b.closed
+  out.optionalKeys = [...a.optionalKeys]
+  for (const k of b.optionalKeys) {
+    if (!out.optionalKeys.includes(k)) out.optionalKeys.push(k)
+  }
+
+  let done = true
+
+  // Copy all keys from a
+  for (const k in a.peg) {
+    out.peg[k] = a.peg[k]
+  }
+
+  // Merge keys from b
+  for (const k in b.peg) {
+    if (k in out.peg) {
+      const av = out.peg[k]
+      const bv = b.peg[k]
+
+      // Flatten both sides' terms into a single ConjunctVal
+      const terms: Val[] = []
+      if (av.isConjunct) { terms.push(...av.peg) } else { terms.push(av) }
+      if (bv.isConjunct) { terms.push(...bv.peg) } else { terms.push(bv) }
+
+      out.peg[k] = new ConjunctVal({ peg: terms }, ctx)
+      done = false
+    }
+    else {
+      out.peg[k] = b.peg[k]
+    }
+  }
+
+  for (const k in out.peg) {
+    done = done && (DONE === out.peg[k]?.dc)
+  }
+
+  out.dc = done ? DONE : 1
+  propagateMarks(a, out)
+  propagateMarks(b, out)
+  return out
+}
+
 
 
 // TODO: move main logic to op/conjunct
@@ -71,6 +122,11 @@ class ConjunctVal extends JunctionVal {
   unify(peer: Val, ctx: AontuContext): Val {
     peer = peer ?? top()
 
+    // Fast path: done conjunct self-unifying with TOP.
+    if (this.done && peer.isTop) {
+      return this
+    }
+
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Conjunct', this, peer)
 
     let done = true
@@ -96,7 +152,12 @@ class ConjunctVal extends JunctionVal {
       this.peg[vI].mark.hide = newhide
       // console.log('CONJUNCT-TERM', this.id, vI, this.peg[vI].canon)
 
+      // Defer unify-with-TOP for map terms with spreads when other
+      // map terms exist — the shallow merge fold handles them instead.
+      const hasMapPeers = this.peg.length > 1 && this.peg[vI].isMap &&
+        this.peg.some((p: Val, i: number) => i !== vI && p.isMap)
       upeer[vI] = (this.peg[vI].done && peer.isTop) ? this.peg[vI] :
+        (hasMapPeers && hasSpreads(this.peg[vI])) ? this.peg[vI] :
         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
@@ -117,7 +178,22 @@ class ConjunctVal extends JunctionVal {
     }
 
     upeer = norm(upeer)
-    // console.log('CONJUNCT-UPEER', this.id, upeer.map((v: Val) => v.canon))
+
+    // Stable partition: fold pure terms first, spread-bearing terms
+    // last. Pure terms (no spreads, no path-dependent functions)
+    // unify cheaply. Dynamic terms are then folded in, applying
+    // spread constraints once to the merged result rather than
+    // incrementally at every intermediate fold step.
+    const pure: Val[] = []
+    const dyn: Val[] = []
+    for (const term of upeer) {
+      if (term.isPathDependent || hasSpreads(term)) {
+        dyn.push(term)
+      } else {
+        pure.push(term)
+      }
+    }
+    upeer = pure.concat(dyn)
 
     // Unify terms against each other
 
@@ -141,17 +217,28 @@ class ConjunctVal extends JunctionVal {
 
       // Can't unite with a RefVal, unless also a RefVal with same path.
       // else if (t0 instanceof RefVal && !(t1 instanceof RefVal)) {
-      else if (t0.isRef && !(t1.isRef)) {
+      else if (t0.isPath && !(t1.isPath)) {
         outvals.push(t0)
         t0 = t1
       }
 
-      else if (t1.isRef && !(t0.isRef)) {
+      else if (t1.isPath && !(t0.isPath)) {
         outvals.push(t0)
         t0 = t1
       }
 
 
+      // Shallow merge: when both are maps AND the conjunct contains spreads,
+      // combine keys into inner ConjunctVals instead of deep unification.
+      // This ensures spreads see ALL children across terms before being applied.
+      else if (t0.isMap && t1.isMap && (hasSpreads(t0) || hasSpreads(t1))) {
+        const merged = shallowMerge(t0 as any, t1 as any, ctx)
+        done = done && DONE === merged.dc
+        newtype = this.mark.type || merged.mark.type
+        newhide = this.mark.hide || merged.mark.hide
+        t0 = merged
+      }
+
       else {
         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)
@@ -159,7 +246,7 @@ class ConjunctVal extends JunctionVal {
         newtype = this.mark.type || val.mark.type
         newhide = this.mark.hide || val.mark.hide
 
-        // Unite was just a conjunt anyway, so discard.
+        // Unite was just a conjunct anyway, so discard.
         if (val.isConjunct) {
           outvals.push(t0)
           t0 = t1
@@ -215,6 +302,15 @@ class ConjunctVal extends JunctionVal {
 
 
   gen(ctx?: AontuContext) {
+    // If this conjunct contains a SpreadVal + a generable Val,
+    // gen the generable Val (spread is an unresolved constraint
+    // that's a no-op at gen time — e.g., empty map with spread).
+    if (this.peg.length === 2) {
+      const [a, b] = this.peg
+      if (a.isSpread && b.isGenable) return b.gen(ctx as any)
+      if (b.isSpread && a.isGenable) return a.gen(ctx as any)
+    }
+
     // Unresolved conjunct cannot be generated, so always an error.
     let nil = makeNilErr(
       ctx,
@@ -247,18 +343,17 @@ class ConjunctVal extends JunctionVal {
 function norm(terms: Val[]): Val[] {
 
   let expand: Val[] = []
-  for (let tI = 0, pI = 0; tI < terms.length; tI++, pI++) {
-    if (terms[tI].isConjunct) {
-      const cterms = terms[tI].peg
-      for (let cI = 0; cI < cterms.length; cI++) {
-        expand[pI + cI] = cterms[cI]
+  function flattenTerms(terms: Val[]) {
+    for (let tI = 0; tI < terms.length; tI++) {
+      if (terms[tI].isConjunct) {
+        flattenTerms(terms[tI].peg)
+      }
+      else {
+        expand.push(terms[tI])
       }
-      pI += cterms.length - 1
-    }
-    else {
-      expand[pI] = terms[tI]
     }
   }
+  flattenTerms(terms)
 
 
   // Consistent ordering ensures order independent unification.
@@ -282,6 +377,29 @@ function norm(terms: Val[]): Val[] {
 }
 
 
+// Check if a Val tree contains any SpreadVal constraints.
+// Cached on _hasSpreads for performance.
+function hasSpreads(v: any): boolean {
+  if (v._hasSpreads !== undefined) return v._hasSpreads
+  let result = false
+  if (v.isSpread) {
+    result = true
+  }
+  else if (v.isMap || v.isList) {
+    for (const k in v.peg) {
+      if (v.peg[k]?.isVal && hasSpreads(v.peg[k])) { result = true; break }
+    }
+  }
+  else if (v.isJunction) {
+    for (const p of v.peg) {
+      if (p?.isVal && hasSpreads(p)) { result = true; break }
+    }
+  }
+  v._hasSpreads = result
+  return result
+}
+
+
 export {
   norm,
   ConjunctVal,

package/src/val/CopyFuncVal.ts

@@ -61,9 +61,10 @@ class CopyFuncVal extends FuncBaseVal {
 
     // console.log('CR', out)
 
-    if (!out.isRef) {
+    if (!out.isPath) {
+      out.mark.type = false
+      out.mark.hide = false
       walk(out, (_key: string | number | undefined, val: Val) => {
-        // console.log('WALK', val)
         val.mark.type = false
         val.mark.hide = false
         return val