aontu 0.43.0 → 0.45.1

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

package/src/val/DisjunctVal.ts

@@ -30,7 +30,6 @@ import {
   top
 } from './top'
 
-
 import { NilVal, TRIAL_NIL } from '../val/NilVal'
 import { PrefVal } from '../val/PrefVal'
 import { JunctionVal } from '../val/JunctionVal'
@@ -68,11 +67,6 @@ class DisjunctVal extends JunctionVal {
   unify(peer: Val, ctx: AontuContext): Val {
     peer = peer ?? top()
 
-    // Fast path: already-done disjunct unifying with TOP.
-    if (this.done && peer.isTop) {
-      return this
-    }
-
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Disjunct', this, peer)
 
     if (!this.prefsRanked) {

package/src/val/ExpectVal.ts

@@ -51,25 +51,11 @@ class ExpectVal extends FeatureVal {
       this.peer = undefined === this.peer ? peer :
         unite(te ? ctx.clone({ explain: ec(te, 'PEER') }) : ctx, this.peer, peer, 'expect-peer')
 
-      // Unwrap nested ExpectVals to prevent infinite recursion
-      let peg = this.peg
-      while (peg?.isExpect) {
-        peg = peg.peg
-      }
+      const peeru =
+        unite(te ? ctx.clone({ explain: ec(te, 'EXPECT') }) : ctx, this.peer, this.peg, 'expect-self')
 
-      // Guard against re-entrant recursion
-      if ((this as any)._expectDepth > 0) {
-        out.dc = this.dc + 1
-      }
-      else {
-        (this as any)._expectDepth = ((this as any)._expectDepth || 0) + 1
-        const peeru =
-          unite(te ? ctx.clone({ explain: ec(te, 'EXPECT') }) : ctx, this.peer, peg, 'expect-self')
-        ;(this as any)._expectDepth--
-
-        if (peeru.isGenable) {
-          out = peeru
-        }
+      if (peeru.isGenable) {
+        out = peeru
       }
     }
 

package/src/val/JunctionVal.ts

@@ -17,7 +17,6 @@ import { FeatureVal } from './FeatureVal'
 // (ConjunctVal and DisjunctVal)
 abstract class JunctionVal extends FeatureVal {
   isJunction = true
-  _canonCache?: string
 
   constructor(
     spec: ValSpec,
@@ -39,13 +38,10 @@ abstract class JunctionVal extends FeatureVal {
   }
 
   get canon() {
-    if (this._canonCache !== undefined) return this._canonCache
-    const c = this.peg.map((v: Val) => {
+    return this.peg.map((v: Val) => {
       return (v as any).isJunction && Array.isArray(v.peg) && 1 < v.peg.length ?
         '(' + v.canon + ')' : v.canon // v.id + '=' + v.canon
     }).join(this.getJunctionSymbol()) // + '<' + (this.mark.hide ? 'H' : '') + '>'
-    if (this.done) this._canonCache = c
-    return c
   }
 
   // Abstract method to be implemented by subclasses to define their junction symbol

package/src/val/KeyFuncVal.ts

@@ -18,6 +18,7 @@ import { ConjunctVal } from '../val/ConjunctVal'
 
 import { FuncBaseVal } from './FuncBaseVal'
 
+
 class KeyFuncVal extends FuncBaseVal {
   isKeyFunc = true
 
@@ -40,12 +41,14 @@ class KeyFuncVal extends FuncBaseVal {
 
 
   unify(peer: Val, ctx: AontuContext): Val {
+    // TODO: this delay makes keys in spreads and refs work, but it is a hack - find a better way.
     let out: Val = this
 
     if (ctx.cc < 3) {
       this.notdone()
 
       if (peer.isTop || (peer.id === this.id)) {
+        // TODO: clone needed to avoid triggering unify_cycle - find a better way
         out = this.clone(ctx)
       }
       else if (peer.isNil) {

package/src/val/ListVal.ts

@@ -9,6 +9,7 @@ import type {
 
 import {
   DONE,
+  SPREAD,
 } from '../type'
 
 import { AontuContext } from '../ctx'
@@ -29,6 +30,7 @@ import {
   top
 } from './top'
 
+import { ConjunctVal } from './ConjunctVal'
 import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
 import { empty } from './Val'
@@ -36,7 +38,6 @@ import { empty } from './Val'
 
 class ListVal extends BagVal {
   isList = true
-  _canonCache?: string
 
   constructor(
     spec: {
@@ -50,6 +51,24 @@ class ListVal extends BagVal {
       throw new AontuError('ListVal spec.peg undefined')
     }
 
+    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
+
+        // let tmv = Array.isArray(spread.v) ? spread.v : [spread.v]
+        // this.spread.cj = new ConjunctVal({ peg: tmv }, ctx)
+      }
+    }
   }
 
 
@@ -67,7 +86,8 @@ class ListVal extends BagVal {
     let out: ListVal | NilVal = (peer.isTop ? this : new ListVal({ peg: [] }, ctx))
 
     out.closed = this.closed
-    out.optionalKeys = 0 < this.optionalKeys.length ? [...this.optionalKeys] : this.optionalKeys
+    out.optionalKeys = [...this.optionalKeys]
+    out.spread.cj = this.spread.cj
     out.site = this.site
 
     if (peer instanceof ListVal) {
@@ -77,6 +97,13 @@ class ListVal extends BagVal {
       }
       else {
         out.closed = out.closed || peer.closed
+        out.spread.cj = null == out.spread.cj ? peer.spread.cj : (
+          null == peer.spread.cj ? out.spread.cj : (
+            out.spread.cj =
+            unite(te ? ctx.clone({ explain: ec(te, 'SPR') }) : ctx,
+              out.spread.cj, peer.spread.cj, 'list-peer')
+          )
+        )
       }
     }
 
@@ -84,39 +111,29 @@ class ListVal extends BagVal {
     if (!exit) {
       out.dc = this.dc + 1
 
-      // Fast path: self-unify with TOP.
-      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
-        }
-      }
+      let spread_cj = out.spread.cj || TOP
 
-      // Unify own children
+      // Always unify children first
       for (let key in this.peg) {
         const keyctx = ctx.descend(key)
+        const key_spread_cj = spread_cj.spreadClone(keyctx)
         const child = this.peg[key]
 
         propagateMarks(this, child)
 
         out.peg[key] =
-          undefined === child ? top() :
+          undefined === child ? key_spread_cj :
             child.isNil ? child :
-              child.done ? child :
-                unite(te ? keyctx.clone({ explain: ec(te, 'PEG:' + key) }) : keyctx,
-                  child, top(), 'list-own')
+              key_spread_cj.isNil ? key_spread_cj :
+                key_spread_cj.isTop && child.done ? child :
+                  child.isTop && key_spread_cj.done ? key_spread_cj :
+                    unite(te ? keyctx.clone({ explain: ec(te, 'PEG:' + key) }) : keyctx,
+                      child, key_spread_cj, 'list-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 ListVal) {
@@ -124,10 +141,11 @@ class ListVal extends BagVal {
           te ? ctx.clone({ explain: ec(te, 'PER') }) : ctx,
           peer, TOP, 'list-peer-list') as ListVal)
 
+        // NOTE: peerkey is the index
         for (let peerkey in upeer.peg) {
           let peerchild = upeer.peg[peerkey]
 
-          if (this.closed && !(peerkey in this.peg)) {
+          if (this.closed && !allowedKeys.includes(peerkey)) {
             bad = makeNilErr(ctx, 'closed', peerchild, undefined)
           }
 
@@ -137,11 +155,19 @@ class ListVal extends BagVal {
 
           let oval = out.peg[peerkey] =
             undefined === child ? peerchild :
-                child.isTop && peerchild.done ? peerchild :
-                  child.isNil ? child :
-                    peerchild.isNil ? peerchild :
-                      unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
-                        child, peerchild, 'list-peer')
+              child.isTop && peerchild.done ? peerchild :
+                child.isNil ? child :
+                  peerchild.isNil ? peerchild :
+                    unite(te ? peerctx.clone({ explain: ec(te, 'CHD') }) : peerctx,
+                      child, peerchild, 'list-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,
+                out.peg[peerkey], key_spread_cj, 'list-spread')
+          }
 
           propagateMarks(this, oval)
 
@@ -171,18 +197,39 @@ class ListVal extends BagVal {
   }
 
 
-  // Spread clone: share path-independent children directly, clone
-  // only path-dependent ones. See MapVal.spreadClone for rationale.
+  // Spread clone: only deep-clone children that are path-dependent
+  // (isFunc, isRef). Share all other children directly.
+  // 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.
   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) {
+        allScalarKind = false
+        break
+      }
+    }
+
+    if (!allScalarKind) {
+      return this.clone(ctx)
+    }
+
     let out = (super.clone(ctx) as ListVal)
 
     for (let entry of Object.entries(this.peg)) {
-      const child = entry[1] as Val
-      out.peg[entry[0]] = child?.isPathDependent
-        ? child.clone(ctx, { mark: {} })
-        : child
+      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,
     }
 
     out.closed = this.closed
@@ -198,6 +245,10 @@ class ListVal extends BagVal {
       out.peg[entry[0]] =
         (entry[1] as any)?.isVal ? (entry[1] as Val).clone(ctx, spec?.mark ? { mark: spec.mark } : {}) : 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]
 
@@ -207,19 +258,18 @@ class ListVal extends BagVal {
 
 
   get canon() {
-    if (this._canonCache !== undefined) return this._canonCache
     // console.log('LISTVAL-CANON', this.optionalKeys)
     let keys = Object.keys(this.peg)
-    const c = '' +
+    return '' +
       // this.errcanon() +
       '[' +
+      (this.spread.cj ? '&:' + this.spread.cj.canon +
+        (0 < keys.length ? ',' : '') : '') +
       keys
         .map(k => this.optionalKeys.includes(k) ?
           k + '?:' + this.peg[k].canon :
           this.peg[k].canon).join(',') +
       ']'
-    if (this.done) this._canonCache = c
-    return c
   }
 }