aontu 0.44.0 → 0.46.0

package/src/unify.ts

@@ -10,9 +10,6 @@ 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
@@ -29,9 +26,8 @@ import {
 } from './val/top'
 
 
-
 // TODO: FIX: false positive when too many top unifications
-const MAXCYCLE = 9999
+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
@@ -54,19 +50,12 @@ 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.isConjunct && !a.isDisjunct
-          && !a.isPath && !a.isPref && !a.isFunc && !a.isExpect) {
+            && !a.isNil && !b.isNil
+            && !a.isMap && !a.isList
+            && !a.isConjunct && !a.isDisjunct
+            && !a.isRef && !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
-        }
       }
     }
   }
@@ -78,25 +67,21 @@ 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.
-  let saw: string
-  if (ctx.opts.debug) {
-    saw = (a ? a.id + (a.done ? '' : '*') : '') + '~' +
+  const saw = ctx.opts.debug
+    ? (a ? a.id + (a.done ? '' : '*') : '') + '~' +
       (b ? b.id + (b.done ? '' : '*') : '') + '@' + ctx.pathstr
-  }
-  else {
-    saw = (a ? a.id + (a.done ? 'd' : '') : 0) + '~' +
+    : (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.get(saw) ?? 0
+  const sawCount = ctx.seen[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.set(saw, sawCount + 1)
+    ctx.seen[saw] = sawCount + 1
 
     try {
       let unified = false
@@ -133,7 +118,7 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
         out = update(b, a)
         why = 'bn'
       }
-      else if (a.isConjunct || a.isExpect || a.isSpread) {
+      else if (a.isConjunct || a.isExpect) {
         out = a.unify(b, te ? ctx.clone({ explain: ec(te, 'AC') }) : ctx)
         unified = true
         why = 'a*'
@@ -141,11 +126,10 @@ const unite = (ctx: AontuContext, a: any, b: any, whence: string) => {
       else if (
         b.isConjunct
         || b.isDisjunct
-        || b.isPath
+        || b.isRef
         || b.isPref
         || b.isFunc
         || b.isExpect
-        || b.isSpread
       ) {
         out = b.unify(a, te ? ctx.clone({ explain: ec(te, 'BW') }) : ctx)
         unified = true
@@ -185,11 +169,6 @@ 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
 }
 
@@ -200,269 +179,6 @@ 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
@@ -513,28 +229,15 @@ 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 = new Map()
-        uctx._refCloneCache = new Map()
-        uctx._uniteCache = new Map()
+        uctx.seen = {}
         res = unite(te ? uctx.clone({ explain: ec(te, 'run') }) : uctx, res, top(), 'unify')
 
         if (0 < uctx.err.length) {

package/src/utility.ts

@@ -11,11 +11,8 @@ function propagateMarks(source: Val, target: Val): void {
   if (source.isTop || target.isTop) {
     return
   }
-  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]
+  for (let name in source.mark) {
+    (target.mark as any)[name] = (target.mark as any)[name] || (source.mark as any)[name]
   }
 }
 

package/src/val/BagVal.ts

@@ -29,6 +29,10 @@ abstract class BagVal extends FeatureVal {
   closed: boolean = false
   optionalKeys: string[] = []
 
+  spread = {
+    cj: (undefined as Val | undefined),
+  }
+
   constructor(
     spec: ValSpec,
     ctx?: AontuContext
@@ -38,6 +42,7 @@ 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
   }
 
@@ -87,15 +92,11 @@ abstract class BagVal extends FeatureVal {
         || child.isMap
         || child.isList
         || child.isPref
-        || child.isPath
+        || child.isRef
         || child.isDisjunct
-        || child.isConjunct
         || child.isNil
       ) {
-        // 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)
+        let cval = child.gen(ctx)
 
         if (optional && (undefined === cval || empty(cval))) {
           continue

package/src/val/ConjunctVal.ts

@@ -36,57 +36,6 @@ 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
@@ -122,11 +71,6 @@ 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
@@ -152,12 +96,7 @@ 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
@@ -178,22 +117,7 @@ class ConjunctVal extends JunctionVal {
     }
 
     upeer = norm(upeer)
-
-    // 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)
+    // console.log('CONJUNCT-UPEER', this.id, upeer.map((v: Val) => v.canon))
 
     // Unify terms against each other
 
@@ -217,28 +141,17 @@ 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.isPath && !(t1.isPath)) {
+      else if (t0.isRef && !(t1.isRef)) {
         outvals.push(t0)
         t0 = t1
       }
 
-      else if (t1.isPath && !(t0.isPath)) {
+      else if (t1.isRef && !(t0.isRef)) {
         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)
@@ -246,7 +159,7 @@ class ConjunctVal extends JunctionVal {
         newtype = this.mark.type || val.mark.type
         newhide = this.mark.hide || val.mark.hide
 
-        // Unite was just a conjunct anyway, so discard.
+        // Unite was just a conjunt anyway, so discard.
         if (val.isConjunct) {
           outvals.push(t0)
           t0 = t1
@@ -302,15 +215,6 @@ 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,
@@ -343,17 +247,18 @@ class ConjunctVal extends JunctionVal {
 function norm(terms: Val[]): Val[] {
 
   let expand: Val[] = []
-  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])
+  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]
       }
+      pI += cterms.length - 1
+    }
+    else {
+      expand[pI] = terms[tI]
     }
   }
-  flattenTerms(terms)
 
 
   // Consistent ordering ensures order independent unification.
@@ -377,29 +282,6 @@ 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,10 +61,9 @@ class CopyFuncVal extends FuncBaseVal {
 
     // console.log('CR', out)
 
-    if (!out.isPath) {
-      out.mark.type = false
-      out.mark.hide = false
+    if (!out.isRef) {
       walk(out, (_key: string | number | undefined, val: Val) => {
+        // console.log('WALK', val)
         val.mark.type = false
         val.mark.hide = false
         return val